const ( + OP_FIND_ONE = "findOne" + OP_FIND_PAGED = "findPaged" + OP_FIND_ALL = "findAll" + OP_FIND = "find" +)+ + +
const COUNTER_COL = "@counters"
+
+
+ var ( + ErrNotASlice = errors.New("Current object or field is not a slice!") + ErrNotAStruct = errors.New("Current object or field is not a struct!") + ErrOutOfBounds = errors.New("Index(es) out of bounds!") + ErrAppendMultipleDocuments = errors.New("Cannot append to multiple documents!") + ErrNotSliceOrStruct = errors.New("Current object or field is not a slice nor a struct!") + ErrUnsupportedID = errors.New("Unknown or unsupported id type provided") +)+ +
DB - The mongodb database handle +
var DB *mongo.Database+ +
DBClient - The mongodb client +
var DBClient *mongo.Client+ +
ModelRegistry - the ModelRegistry stores a map containing + pointers to Model instances, keyed by an associated + model name +
var ModelRegistry = make(TModelRegistry)+ +
NextStringID - Override this function with your own + string ID generator! +
var NextStringID func() string+ + +
func Connect(uri string, dbName string)+ + +
func Create(d any) any+
Create creates a new instance of a given Document + type and returns a pointer to it. + + +
func CreateSlice[T any](d T) []*T+
CreateSlice - convenience method which creates a new slice + of type *T (where T is a type which embeds Document) and + returns it + + +
type Counter struct {
+ Current any `bson:"current"`
+ Collection string `bson:"collection"`
+}
+
+
+
+ type Document struct {
+ // Created time. updated/added automatically.
+ Created time.Time `bson:"createdAt" json:"createdAt"`
+ // Modified time. updated/added automatically.
+ Modified time.Time `bson:"updatedAt" json:"updatedAt"`
+ // contains filtered or unexported fields
+}
+
+
+
+ func (d *Document) Append(field string, a ...interface{}) error+
Append appends one or more items to `field`. + will error if this Model contains a reference + to multiple documents, or if `field` is not a + slice. + + +
func (d *Document) Delete() error+
Delete - deletes a model instance from the database + + +
func (d *Document) Pull(field string, a ...any) error+
Pull - removes elements from the subdocument slice stored in `field`. + + +
func (d *Document) Remove() error+
Remove - alias for Delete + + +
func (d *Document) Save() error+
Save - updates this Model in the database, + or inserts it if it doesn't exist + + +
func (d *Document) Swap(field string, i, j int) error+
Swap - swaps the elements at indexes `i` and `j` in the + slice stored at `field` + + +
type DocumentSlice []IDocument+ + +
func (d *DocumentSlice) Delete() error+ + +
func (d *DocumentSlice) Remove() error+ + +
func (d *DocumentSlice) Save() error+ + +
type GridFSFile struct {
+ ID primitive.ObjectID `bson:"_id"`
+ Name string `bson:"filename"`
+ Length int `bson:"length"`
+}
+
+
+
+ HasID is a simple interface that you must implement + in your models, using a pointer receiver. + This allows for more flexibility in cases where + your ID isn't an ObjectID (e.g., int, uint, string...). +
and yes, those darn ugly ObjectIDs are supported :) +
type HasID interface {
+ Id() any
+ SetId(id any)
+}
+
+
+ type HasIDSlice []HasID+ + +
type IDocument interface {
+ Append(field string, a ...interface{}) error
+ Pull(field string, a ...any) error
+ Swap(field string, i, j int) error
+ Delete() error
+ Remove() error
+ Save() error
+ // contains filtered or unexported methods
+}
+
+
+ type IDocumentSlice interface {
+ Delete() error
+ Remove() error
+ Save() error
+ // contains filtered or unexported methods
+}
+
+
+ type IModel interface {
+ FindRaw(query interface{}, opts ...*options.FindOptions) (*mongo.Cursor, error)
+ Find(query interface{}, opts ...*options.FindOptions) (*Query, error)
+ FindByID(id interface{}) (*Query, error)
+ FindOne(query interface{}, options ...*options.FindOneOptions) (*Query, error)
+ FindPaged(query interface{}, page int64, perPage int64, options ...*options.FindOptions) (*Query, error)
+ // contains filtered or unexported methods
+}
+
+
+ prolly won't need to use indexes, but just in case... +
type InternalIndex struct {
+ Fields []string
+ Options []string
+ // contains filtered or unexported fields
+}
+
+
+
+ Model - type which contains "static" methods like + Find, FindOne, etc. +
type Model struct {
+ Indexes map[string][]InternalIndex
+ Type reflect.Type
+ // contains filtered or unexported fields
+}
+
+
+
+ func (m *Model) Find(query interface{}, opts ...*options.FindOptions) (*Query, error)+
Find - find all documents satisfying `query`. + returns a pointer to a Query for further chaining. + + +
func (m *Model) FindByID(id interface{}) (*Query, error)+
FindByID - find a single document by its _id field. + Wrapper around FindOne with an ID query as its first argument + + +
func (m *Model) FindOne(query interface{}, options ...*options.FindOneOptions) (*Query, error)+
FindOne - find a single document satisfying `query`. + returns a pointer to a Query for further chaining. + + +
func (m *Model) FindPaged(query interface{}, page int64, perPage int64, opts ...*options.FindOptions) (*Query, error)+
FindPaged - Wrapper around FindAll with the Skip and Limit options populated. + returns a pointer to a Query for further chaining. + + +
func (m *Model) FindRaw(query interface{}, opts ...*options.FindOptions) (*mongo.Cursor, error)+
FindRaw - find documents satisfying `query` and return a plain mongo cursor. + + +
type Query struct {
+ // contains filtered or unexported fields
+}
+
+
+
+ func (q *Query) Exec(result interface{})+
Exec - executes the query and puts its results into the + provided argument. +
Will panic if called more than once on the same Query instance. + + +
func (q *Query) JSON() (string, error)+
JSON - marshals this Query's results into json format + + +
func (q *Query) LoadFile(fields ...string) *Query+
LoadFile - loads the contents of one or more files + stored in gridFS into the fields named by `fields`. +
gridFS fields can be either a `string` or `[]byte`, and are + tagged with `gridfs:"BUCKET,FILE_FORMAT` + where: +
func (q *Query) Populate(fields ...string) *Query+
Populate populates document references via reflection + + +
Reference stores a typed document reference +
type Reference struct {
+ // owning model name
+ Model string
+ // the name of the struct field
+ FieldName string
+ // index of field in owning struct
+ Idx int
+ // the type of the referenced object
+ HydratedType reflect.Type
+
+ // field kind (struct, slice, ...)
+ Kind reflect.Kind
+ // contains filtered or unexported fields
+}
+
+
+
+ type TModelRegistry map[string]*Model+ + +
func (r TModelRegistry) Get(name string) *Model+ + +
func (r TModelRegistry) Has(i interface{}) (string, *Model, bool)+
Has returns the model typename and Model instance corresponding + to the argument passed, as well as a boolean indicating whether it + was found. otherwise returns `"", nil, false` + + +
func (r TModelRegistry) HasByName(n string) (string, *Model, bool)+
HasByName functions almost identically to Has, + except that it takes a string as its argument. + + +
func (r TModelRegistry) Index(n string) int+
Index returns the index at which the Document struct is embedded + + +
func (r TModelRegistry) Model(mdl ...any)+
Model registers models in the ModelRegistry, where + they can be accessed via a model's struct name + + +