Mongo Go Models (mgm) is a fast and simple MongoDB ODM for Go (based on official Mongo Go Driver)

I am loving mgm! I am also willing to help contribute to make it better.

I think adding a mock package to make mocking the DB easier would be a great improvement to this project

Hello,

I would like to retrieve the ID of the fresh inserted document.

Taking this snippet from the documentation:

book := NewBook("Pride and Prejudice", 345)

// Make sure to pass the model by reference.
err := mgm.Coll(book).Create(book)

I would like to retrieve the "book" ID, how can i do this without perform another search ?

Best regards

Describe the bug

I have a model with the DefaultModel included.

I have a method which does something like the following:

func  Update(dto dto.MyModel) error {
        // Convert from a DTO
	m, err := (&MyModel{}).FromDTO(dto)
	if err != nil {
		return fmt.Errorf("converting from DTO: %w", err)
	}

	if err := m.Save(); err != nil {
		return fmt.Errorf("saving model: %w", err)
	}

	return nil
}

The conversion from a DTO leaves CreatedAt as the zero-value, because that info is left out of my DTOs.

The problem is that CreatedAt is not declared as omitempty, so when I .Save() like this, it is overwritten with a zero value.

To Reproduce Steps to reproduce the behavior:

1. Create a document
2. Instantiate another document struct with the same primary key and set CreatedAt to nothing (or anything you want)
3. Save the document

Expected behavior

Changes to CreatedAt are ignored, or at least ignored if CreatedAt is the zero value of time.Time.

Screenshots

N/A

Environment (please complete the following information):

• OS: a Docker container running golang:bullseye

Additional context

As a workaround, I can stick to a get-modify-save pattern where I save the original CreatedAt time and restore it before the save instead of attempting to directly update/upsert.

Let's say you have this model:

type Book struct {
  mgm.DefaultModel `bson:",inline"`

  Author string `bson:"author"`

  // ... more fields ...
}

Somewhere in your code you want to change the author's name, so you have:

book := &Book{}
_, err := mgm.Coll(book).UpdateOne(mgm.Ctx(), bson.M{
  "_id": id
}, bson.M{
  "$set": bson.M{
    "author": authorName,
  },
})

Time goes on, the codebase grows, many contributors, and the realization is made that a book can have multiple authors, so the model is changed to:

type Book struct {
  mgm.DefaultModel `bson:",inline"`

  Authors []string `bson:"authors"`

  // ... more fields ...
}

The update code won't throw any sort of error or warning because there is no type safety. Without many lines of code to perform tag reflection (and even more lines if it's a nested field), is there a clean way to make a partial update to a model where type safety is preserved?

Describe the bug "connection() : auth error: sasl conversation error: unable to authenticate using mechanism "SCRAM-SHA-1": (AtlasError) Authentication failed.

Everything was working fine till today I get error with authentication failed. I didn't changed anything, not a single line of code but still I get error on any operation with mgm connection() : auth error: sasl conversation error: unable to authenticate using mechanism \"SCRAM-SHA-1\": (AtlasError) Authentication failed.

To Reproduce Steps to reproduce the behavior: 1.

err = mgm.SetDefaultConfig(nil, "directory", options.Client().ApplyURI(os.Getenv("MONGODB_URI")))
if err != nil {
	log.Fatal(err)
}

2. Export MONGODB_URI with mongodb atlas cluster uri.
3. Run the server.
4. Do Some operation.

Expected behavior Operation should complete without any error.

Environment (please complete the following information):

• OS: Ubuntu 20.04

The following functions GetID, SetID and PrepareID all know there return type... There is no need to return a interface{} as this causes unneeded casting by anyone using the package.

Also cleaned up some of the reflection in those functions above to make them "smarter" using switch on type.

This makes it always assume we can take either a string (gets converted) or a primitive.ObjectID

While creating a new data using mgm.create method, its successfully created the data with created at and updated at details in defaultmodel field. But While updating the data using updateOne or FindOneandUpdate, its successfully updated but the created at and Updated at field details became 0001-01-01T00:00:00.000+00:00 in the database. I know, here i am using mongo drive function so that defaultmodel fields are not accessed so that the created at and updated at becames 0001-01-01T00:00:00.000+00:00.

why I am using mongo drive function because while update using mgm.update, there is only one parameter as model. so I find the data which i need to update and manually map the details and send the parameter to that function. Even though, it's not updating properly in database.

Expected behavior:

1. please provide an extra filter parameter to update function in mgm. so that it will be easy to use mgm.update function Or tell us how to use the mgm.update function, Because the Previous information provided by you is not clear.

Environment (please complete the following information):

• OS: Ubuntu

Have added support for passing context in hooks. This tackles this issue

Have added new interfaces for hooks like OldNameWithCtx e.g (CreatingHookWithCtx) and have deprecated the old interface. This was done to support the backward compatibility

The new Interfaces follow the same func names but additionally takes a context field

// CreatingHookWithCtx is called before saving a new model to the database
type CreatingHookWithCtx interface {
	Creating(context.Context) error
}

Have added appropriate test as well in hooks_test.go file

Describe the bug

Syntax is wrong

result := []Book{}

err := mgm.Coll(&Book{}).SimpleFind(&result, bson.M{"age": bson.M{operator.Gt: 24}})

Should be:

result := []Book

err := mgm.Coll(&Book{}).SimpleFind(&result, bson.M{"age": bson.M{operator.Gt: 24}})

Or maybe i miss something ?

Additionnaly, maybe add the FindAll method example:

	var result []Book

	err := collection.SimpleFind(&result, bson.D{})

	log.Fatalf("here is the books: %v", result)

best regards

Describe the bug I'm building a simple CRUD API, and when trying to use the "FindOneAndUpdate" method, it's not completing the update call when passing in the document id as a filter parameter

Models:

type Car struct{
	CarName   string  `json:"car_name"   bson:"car_name"`
	Make      string  `json:"make"       bson:"make"`
	ModelYear int     `json:"model_year" bson:"model_year"`
	CarType   string  `json:"car_type"   bson:"car_type"`
	Price     float64 `json:"price"      bson:"price"`
}

type User struct{
	mgm.DefaultModel `bson:",inline"`
	Name            string `json:"name" bson:"name"`
	FavoriteCarType string `json:"favorite_car_type" bson:"favorite_car_type"`
	FavoriteCar     string `json:"favorite_car" bson:"favorite_car"`
	FavoriteCars    []Car  `json:"favorite_cars" bson:"favorite_cars"`
}

Update user method:

type UserController struct{
	router *mux.Router
}

func (u *UserController) updateUser(res http.ResponseWriter, req *http.Request){
	id := mux.Vars(req)["id"]
	user := bson.M{}

	json.NewDecoder(req.Body).Decode(&user)

	result := mgm.Coll(&model.User{}).FindOneAndUpdate(mgm.Ctx(), bson.M{"_id": id}, bson.M{"$set": user})

        //The above method call causes the following error message to be returned
	if result.Err() != nil{
		utilities.SendJSON(http.StatusNotFound, res, utilities.M{"message":  result.Err().Error()})
		return
	}

	utilities.SendJSON(200, res, utilities.M{"result": result})
}

Update query (Postman):

{
    "favorite_car_type": "performance van",
    "favorite_car": "Pacifica SRT"
}

route to "updateUser()" method: localhost:8080/users/{id}

Utilities:

type M map[string]interface{} 

//SendJSON - Utility function to send JSON
func SendJSON(statusCode int, res http.ResponseWriter, body interface{}){
	res.Header().Set("Content-Type", "application/json")
	res.WriteHeader(statusCode)
	json.NewEncoder(res).Encode(body)
	
	return
}

When getting a user by id by calling the FindByID method:

 id := mux.Vars(req)["id"]
	user := model.User{}

	//find all the user in the "users" collection who have "id" as their favorite car type
	result := mgm.Coll(&model.User{}).FindByID(id, &user)

the above code works, but for the updateUser method, the error block is hit every time. Is there something I'm missing?

Describe the bug When using mgm model with mgm.DefaultModel in nested struct inside model, ID, created_at and updated_at of this struct is not updated when using Save() and Update().

To Reproduce Save/Update model with nested struct that has mgm.DefaultModel. Saved/Updated collection does have null _id, created_at and updated_at fields.

Example model:

type GameReview struct {
  mgm.DefaultModel `bson:",inline"`
  Content string `bson:"content"`
}

type Game struct {
  mgm.DefaultModel  `bson:",inline"`
  Name string `bson:"name"`
}

Expected behavior ID, created_at and updated_at fields should be updated.

Environment (please complete the following information):

• Ubuntu 20.04
• go1.14.7

Due to the nature of the error, it will occur on every environment.

Describe the bug Authentication error when trying to connect to Mongo. I get the following error when trying to connect to mongo using user credentials -

{
    "error": "connection() error occured during connection handshake: auth error: sasl conversation error: unable to authenticate using mechanism \"SCRAM-SHA-1\": (AuthenticationFailed) Authentication failed.",
    "ok": false
}

I am able to login via mongo-shell using the same creds as in the screenshot below. However the ORM throws error -

Note: This is similar to this closed issue.

To Reproduce Steps to reproduce the behavior:

1. Create a test user with the following creds -

   MONGODB_PORT="27017"
   MONGODB_URL="localhost"
   MONGODB_USERNAME="test"
   MONGODB_PASSWORD="test123"
   MONGODB_DB="todos"
   

2. Connect to mongo using the ODM

   	package main
   
   	import (
   		"log"
   
   		"github.com/Kamva/mgm/v2"
   		"go.mongodb.org/mongo-driver/mongo/options"
   	)
   
   	func init() {
   		err = mgm.SetDefaultConfig(nil, "todos", options.Client().ApplyURI("mongodb://test:test123@localhost:27017"))
   		if err != nil {
   			log.Fatal("Error setting default config")
   			log.Fatal(err)
   		}
   	}
   

Expected behavior Connection should not fail when trying to connect via above piece of code

Screenshots If applicable, add screenshots to help explain your problem.

Environment (please complete the following information):

• OS: MacOS Big Sur
• Mongo: v5.0.6

Additional context Add any other context about the problem here.

Is your feature request related to a problem? Please describe.

• Problem
  • Currently, hook is supported only for the following methods.
    • Create & CreateWithCtx
    • Update & UpdateWithCtx
    • Delete & DeleteWithCtx
  • This is inconvenient to create/update/delete multiple entries as the hook support does not exist. One must loop over the above methods to operate over multiple entries.
  • It's difficult to perform atomic operations and rollback (when dealing with multiple entries), if using just the above mentioned function, as one must define transaction and so on, creating verbose code.

Describe the solution you'd like

• Add support for methods that allows creating/updating/deleting multiple entries, with support for hooks.

Describe alternatives you've considered

• Currently the solution with the above mentioned methods include,
  • Looping over the methods to perform batch operations
  • Wrapping batch operation in transaction, so that rollback can be performed in case of failure
  • Using native methods (e.g. InsertMany, UpdateMany, DeleteMany). But, hook support does not exist.

Additional context

• N/A

Is your feature request related to a problem? Please describe. When saving an update to a model, the entire document is overwritten in the database, as opposed to only the fields that have changed, which could open you up to concurrency issues. Tracking changes can also be useful when implementing something like audit log.

Describe the solution you'd like An update that only $sets the changed fields and a function API (e.g. model.HasChanged("FieldName")) to check what fields have changed in the hooks.

Describe alternatives you've considered I'm not sure how this could implemented without changes to mgm, but open to ideas for sure!

Additional context Would you all be open to a PR to add this if I put some work into it?

Hi,

I needed to have optimistic locking behavior on my project so implemented it in this pull request. It is based on a version field that gets incremented when saving. It can also be done through an updatedOn field but this PR uses the version technique for the DefaultModel.

It works the following way : A new field called "Version" has been added to DefaultModel (saves to "version" in the db) Models have to implement a Versionable interface so that the behavior kicks in. DefaultModel implements it and so documents using the DefaultModel will have this enabled by default). This interface has 3 methods : GetVersion() -> returns the version number of this document IncrementVersion() -> responsible for updating the version number GetVersionFieldName() -> returns the name of the field that holds the version number

Then when the actual update is called, we can simply check that in the query part of the udpate that the version is the same as when the document was retrieved. If not, a custom error is raised.

Hey, first of all, great project!

Is your feature request related to a problem? Please describe. One of the most annoying things about MongoDB and GOlang is querying.

Describe the solution you'd like I would like to see a query build that is simple enough and doesn't involve bson. For example

q := Query("field1", "value1") // optional "and"
q.And("field2", "value2").And("field3", "value3")
  .And(Query("foo1", "v1").Or("foo2", "v2"))

This would greatly simplify most generic queries.