Add simple comparison predicates

internal/mongo/generator.go

@@ -120,24 +120,24 @@ func (g mongoRepositoryGenerator) generateMethodImplementation(methodSpec spec.M
 func (g mongoRepositoryGenerator) generateFindImplementation(operation spec.FindOperation) (string, error) {
 	buffer := new(bytes.Buffer)
 
-	var queryFields []string
-	for _, fieldName := range operation.Query.Fields {
-		structField, ok := g.StructModel.Fields.ByName(fieldName)
+	var predicates []predicate
+	for _, predicateSpec := range operation.Query.Predicates {
+		structField, ok := g.StructModel.Fields.ByName(predicateSpec.Field)
 		if !ok {
-			return "", fmt.Errorf("struct field %s not found", fieldName)
+			return "", fmt.Errorf("struct field %s not found", predicateSpec.Field)
 		}
 
 		bsonTag, ok := structField.Tags["bson"]
 		if !ok {
-			return "", fmt.Errorf("struct field %s does not have bson tag", fieldName)
+			return "", fmt.Errorf("struct field %s does not have bson tag", predicateSpec.Field)
 		}
 
-		queryFields = append(queryFields, bsonTag[0])
+		predicates = append(predicates, predicate{Field: bsonTag[0], Operator: predicateSpec.Operator})
 	}
 
 	tmplData := mongoFindTemplateData{
-		EntityType:  g.StructModel.Name,
-		QueryFields: queryFields,
+		EntityType: g.StructModel.Name,
+		Predicates: predicates,
 	}
 
 	if operation.Mode == spec.QueryModeOne {

internal/mongo/generator_test.go

@@ -22,6 +22,16 @@ func TestGenerateMongoRepository(t *testing.T) {
 				Type: code.SimpleType("string"),
 				Tags: map[string][]string{"bson": {"username"}},
 			},
+			{
+				Name: "Gender",
+				Type: code.SimpleType("Gender"),
+				Tags: map[string][]string{"bson": {"gender"}},
+			},
+			{
+				Name: "Age",
+				Type: code.SimpleType("int"),
+				Tags: map[string][]string{"bson": {"age"}},
+			},
 		},
 	}
 	intf := code.Interface{
@@ -69,6 +79,61 @@ func TestGenerateMongoRepository(t *testing.T) {
 					code.SimpleType("error"),
 				},
 			},
+			{
+				Name: "FindByGenderNot",
+				Params: []code.Param{
+					{Name: "ctx", Type: code.ExternalType{PackageAlias: "context", Name: "Context"}},
+					{Name: "gender", Type: code.SimpleType("int")},
+				},
+				Returns: []code.Type{
+					code.ArrayType{ContainedType: code.PointerType{ContainedType: code.SimpleType("UserModel")}},
+					code.SimpleType("error"),
+				},
+			},
+			{
+				Name: "FindByAgeLessThan",
+				Params: []code.Param{
+					{Name: "ctx", Type: code.ExternalType{PackageAlias: "context", Name: "Context"}},
+					{Name: "age", Type: code.SimpleType("int")},
+				},
+				Returns: []code.Type{
+					code.ArrayType{ContainedType: code.PointerType{ContainedType: code.SimpleType("UserModel")}},
+					code.SimpleType("error"),
+				},
+			},
+			{
+				Name: "FindByAgeLessThanEqual",
+				Params: []code.Param{
+					{Name: "ctx", Type: code.ExternalType{PackageAlias: "context", Name: "Context"}},
+					{Name: "age", Type: code.SimpleType("int")},
+				},
+				Returns: []code.Type{
+					code.ArrayType{ContainedType: code.PointerType{ContainedType: code.SimpleType("UserModel")}},
+					code.SimpleType("error"),
+				},
+			},
+			{
+				Name: "FindByAgeGreaterThan",
+				Params: []code.Param{
+					{Name: "ctx", Type: code.ExternalType{PackageAlias: "context", Name: "Context"}},
+					{Name: "age", Type: code.SimpleType("int")},
+				},
+				Returns: []code.Type{
+					code.ArrayType{ContainedType: code.PointerType{ContainedType: code.SimpleType("UserModel")}},
+					code.SimpleType("error"),
+				},
+			},
+			{
+				Name: "FindByAgeGreaterThanEqual",
+				Params: []code.Param{
+					{Name: "ctx", Type: code.ExternalType{PackageAlias: "context", Name: "Context"}},
+					{Name: "age", Type: code.SimpleType("int")},
+				},
+				Returns: []code.Type{
+					code.ArrayType{ContainedType: code.PointerType{ContainedType: code.SimpleType("UserModel")}},
+					code.SimpleType("error"),
+				},
+			},
 		},
 	}
 
@@ -142,6 +207,76 @@ func (r *UserRepositoryMongo) FindByIDAndUsername(ctx context.Context, arg0 prim
 	}
 	return &entity, nil
 }
+
+func (r *UserRepositoryMongo) FindByGenderNot(ctx context.Context, arg0 int) ([]*UserModel, error) {
+	cursor, err := r.collection.Find(ctx, bson.M{
+		"gender": bson.M{"$ne": arg0},
+	})
+	if err != nil {
+		return nil, err
+	}
+	var entities []*UserModel
+	if err := cursor.All(ctx, &entities); err != nil {
+		return nil, err
+	}
+	return entities, nil
+}
+
+func (r *UserRepositoryMongo) FindByAgeLessThan(ctx context.Context, arg0 int) ([]*UserModel, error) {
+	cursor, err := r.collection.Find(ctx, bson.M{
+		"age": bson.M{"$lt": arg0},
+	})
+	if err != nil {
+		return nil, err
+	}
+	var entities []*UserModel
+	if err := cursor.All(ctx, &entities); err != nil {
+		return nil, err
+	}
+	return entities, nil
+}
+
+func (r *UserRepositoryMongo) FindByAgeLessThanEqual(ctx context.Context, arg0 int) ([]*UserModel, error) {
+	cursor, err := r.collection.Find(ctx, bson.M{
+		"age": bson.M{"$lte": arg0},
+	})
+	if err != nil {
+		return nil, err
+	}
+	var entities []*UserModel
+	if err := cursor.All(ctx, &entities); err != nil {
+		return nil, err
+	}
+	return entities, nil
+}
+
+func (r *UserRepositoryMongo) FindByAgeGreaterThan(ctx context.Context, arg0 int) ([]*UserModel, error) {
+	cursor, err := r.collection.Find(ctx, bson.M{
+		"age": bson.M{"$gt": arg0},
+	})
+	if err != nil {
+		return nil, err
+	}
+	var entities []*UserModel
+	if err := cursor.All(ctx, &entities); err != nil {
+		return nil, err
+	}
+	return entities, nil
+}
+
+func (r *UserRepositoryMongo) FindByAgeGreaterThanEqual(ctx context.Context, arg0 int) ([]*UserModel, error) {
+	cursor, err := r.collection.Find(ctx, bson.M{
+		"age": bson.M{"$gte": arg0},
+	})
+	if err != nil {
+		return nil, err
+	}
+	var entities []*UserModel
+	if err := cursor.All(ctx, &entities); err != nil {
+		return nil, err
+	}
+	return entities, nil
+}
 `
 	expectedCodeLines := strings.Split(expectedCode, "\n")
 	actualCodeLines := strings.Split(code, "\n")

internal/mongo/models.go

@@ -0,0 +1,30 @@
+package mongo
+
+import (
+	"fmt"
+
+	"github.com/sunboyy/repogen/internal/spec"
+)
+
+type predicate struct {
+	Field    string
+	Operator spec.Operator
+}
+
+func (p predicate) Code(argIndex int) string {
+	switch p.Operator {
+	case spec.OperatorEqual:
+		return fmt.Sprintf(`"%s": arg%d`, p.Field, argIndex)
+	case spec.OperatorNot:
+		return fmt.Sprintf(`"%s": bson.M{"$ne": arg%d}`, p.Field, argIndex)
+	case spec.OperatorLessThan:
+		return fmt.Sprintf(`"%s": bson.M{"$lt": arg%d}`, p.Field, argIndex)
+	case spec.OperatorLessThanEqual:
+		return fmt.Sprintf(`"%s": bson.M{"$lte": arg%d}`, p.Field, argIndex)
+	case spec.OperatorGreaterThan:
+		return fmt.Sprintf(`"%s": bson.M{"$gt": arg%d}`, p.Field, argIndex)
+	case spec.OperatorGreaterThanEqual:
+		return fmt.Sprintf(`"%s": bson.M{"$gte": arg%d}`, p.Field, argIndex)
+	}
+	return ""
+}

internal/mongo/templates.go

@@ -75,19 +75,19 @@ func (data mongoMethodTemplateData) Returns() string {
 
 const findOneTemplate = `	var entity {{.EntityType}}
 	if err := r.collection.FindOne(ctx, bson.M{
-{{range $index, $field := .QueryFields}}		"{{$field}}": arg{{$index}},
+{{range $index, $field := .Predicates}}		{{$field.Code $index}},
 {{end}}	}).Decode(&entity); err != nil {
 		return nil, err
 	}
 	return &entity, nil`
 
 type mongoFindTemplateData struct {
-	EntityType  string
-	QueryFields []string
+	EntityType string
+	Predicates []predicate
 }
 
 const findManyTemplate = `	cursor, err := r.collection.Find(ctx, bson.M{
-{{range $index, $field := .QueryFields}}		"{{$field}}": arg{{$index}},
+{{range $index, $field := .Predicates}}		{{$field.Code $index}},
 {{end}}	})
 	if err != nil {
 		return nil, err