CLeanup postgres tests

app/main.go

@@ -8,6 +8,7 @@ import (
 	"repo-pattern/app/models"
 	"repo-pattern/app/repository"
 	"repo-pattern/app/repository/smartfilter"
+	"time"
 
 	"gorm.io/gorm"
 )
@@ -17,6 +18,17 @@ var (
 	FALSE = false
 )
 
+type CertFilter struct {
+	Alive                *bool      `filterfield:"field=alive,operator=EQ"`
+	SerialNumber         *string    `filterfield:"field=serial_number,operator=NE"`
+	SerialNumberContains *string    `filterfield:"field=serial_number,operator=LIKE"`
+	IssuerContains       *string    `filterfield:"field=issuer,operator=ILIKE"`
+	Id                   *string    `filterfield:"field=id,operator=EQ"`
+	Ids                  *[]string  `filterfield:"field=id,operator=IN"`
+	IdsNot               *[]string  `filterfield:"field=id,operator=NOT_IN"`
+	CreatedAt_Lt         *time.Time `filterfield:"field=created_at,operator=LT"`
+}
+
 func doMagic(db *gorm.DB) {
 	var err error
 	query := db
@@ -29,7 +41,7 @@ func doMagic(db *gorm.DB) {
 	// createdTime := time.Date(2024, 5, 26, 16, 8, 0, 0, location)
 	ids := []string{"eb2bcac6-5173-4dbb-93b7-e7c03b924a03", "db9fb837-3483-4736-819d-f427dc8cda23", "1fece5e7-8e8d-4828-8298-3b1f07fd29ff"}
 
-	filter := smartfilter.CertFilter{
+	filter := CertFilter{
 		// Alive: &FALSE,
 		// Id:    &id,
 		// SerialNumber: &serialNumber,
@@ -56,7 +68,7 @@ func doList(db *gorm.DB) {
 	repo := repository.RepoBase[models.Cert]{}
 	repo.Init(db)
 
-	filter := smartfilter.CertFilter{
+	filter := CertFilter{
 		Alive: &TRUE,
 	}
 
@@ -76,7 +88,7 @@ func doGet(db *gorm.DB) {
 
 	id := "db9fb837-3483-4736-819d-f427dc8cda23"
 
-	filter := smartfilter.CertFilter{
+	filter := CertFilter{
 		Id: &id,
 	}
 
@@ -93,7 +105,7 @@ func doExists(db *gorm.DB) {
 
 	id := "db9fb837-3483-4736-819d-f427dc8cda23"
 
-	filter := smartfilter.CertFilter{
+	filter := CertFilter{
 		Id: &id,
 	}
 

app/repository/smartfilter/filterfield.go

@@ -234,7 +234,6 @@ type sliceGetter struct {
 func (sg sliceGetter) getValue(ff *FilterField, v reflect.Value) error {
 	for n := range v.Len() {
 		element := v.Index(n)
-		fmt.Printf("ELEMENT: %+v\n", element)
 
 		switch element.Kind() {
 		case reflect.Bool:

app/repository/smartfilter/handlers_test.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/DATA-DOG/go-sqlmock"
 	"github.com/go-playground/assert"
-	"gorm.io/driver/mysql"
+	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
 )
 
@@ -17,9 +17,9 @@ func NewMockDB() (*gorm.DB, sqlmock.Sqlmock) {
 		log.Fatalf("An error '%s' was not expected when opening a stub database connection", err)
 	}
 
-	gormDB, err := gorm.Open(mysql.New(mysql.Config{
+	gormDB, err := gorm.Open(postgres.New(postgres.Config{
+		WithoutQuotingCheck: true,
 		Conn:                db,
-		SkipInitializeWithVersion: true,
 	}), &gorm.Config{})
 
 	if err != nil {
@@ -38,7 +38,7 @@ func (m MyModel) TableName() string {
 	return "my_models"
 }
 
-type TestCase struct {
+type HandleOperatorTestCase struct {
 	name        string
 	filterField FilterField
 	expected    string
@@ -63,7 +63,7 @@ func TestHandleOperatorEQ(t *testing.T) {
 	db, _ := NewMockDB()
 	testFunc := handleOperatorEQ
 
-	testCases := []TestCase{
+	testCases := []HandleOperatorTestCase{
 		{
 			name: "handleOperatorEQ bool true",
 			filterField: FilterField{
@@ -71,7 +71,7 @@ func TestHandleOperatorEQ(t *testing.T) {
 				boolValue: &boolTrue,
 				valueKind: reflect.Bool,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field = true ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field = true ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorEQ bool false",
@@ -80,7 +80,7 @@ func TestHandleOperatorEQ(t *testing.T) {
 				boolValue: &boolFalse,
 				valueKind: reflect.Bool,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field = false ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field = false ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorEQ int64",
@@ -89,7 +89,7 @@ func TestHandleOperatorEQ(t *testing.T) {
 				intValue:  &int64Value,
 				valueKind: reflect.Int64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field = -123456 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field = -123456 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorEQ uint64",
@@ -98,7 +98,7 @@ func TestHandleOperatorEQ(t *testing.T) {
 				uintValue: &uint64Value,
 				valueKind: reflect.Uint64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field = 123456 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field = 123456 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorEQ float",
@@ -107,7 +107,7 @@ func TestHandleOperatorEQ(t *testing.T) {
 				floatValue: &floatValue,
 				valueKind:  reflect.Float64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field = -123456.789 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field = -123456.789 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorEQ string",
@@ -116,7 +116,7 @@ func TestHandleOperatorEQ(t *testing.T) {
 				strValue:  &strValue,
 				valueKind: reflect.String,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field = 'Some Value' ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field = 'Some Value' ORDER BY my_models.id LIMIT 1",
 		},
 	}
 
@@ -136,7 +136,7 @@ func TestHandleOperatorNE(t *testing.T) {
 	db, _ := NewMockDB()
 	testFunc := handleOperatorNE
 
-	testCases := []TestCase{
+	testCases := []HandleOperatorTestCase{
 		{
 			name: "handleOperatorNE bool true",
 			filterField: FilterField{
@@ -144,7 +144,7 @@ func TestHandleOperatorNE(t *testing.T) {
 				boolValue: &boolTrue,
 				valueKind: reflect.Bool,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field != true ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field != true ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorNE bool false",
@@ -153,7 +153,7 @@ func TestHandleOperatorNE(t *testing.T) {
 				boolValue: &boolFalse,
 				valueKind: reflect.Bool,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field != false ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field != false ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorNE int64",
@@ -162,7 +162,7 @@ func TestHandleOperatorNE(t *testing.T) {
 				intValue:  &int64Value,
 				valueKind: reflect.Int64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field != -123456 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field != -123456 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorNE uint64",
@@ -171,7 +171,7 @@ func TestHandleOperatorNE(t *testing.T) {
 				uintValue: &uint64Value,
 				valueKind: reflect.Uint64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field != 123456 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field != 123456 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorNE float",
@@ -180,7 +180,7 @@ func TestHandleOperatorNE(t *testing.T) {
 				floatValue: &floatValue,
 				valueKind:  reflect.Float64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field != -123456.789 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field != -123456.789 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorNE string",
@@ -189,7 +189,7 @@ func TestHandleOperatorNE(t *testing.T) {
 				strValue:  &strValue,
 				valueKind: reflect.String,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field != 'Some Value' ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field != 'Some Value' ORDER BY my_models.id LIMIT 1",
 		},
 	}
 
@@ -209,7 +209,7 @@ func TestHandleOperatorLIKE(t *testing.T) {
 	db, _ := NewMockDB()
 	testFunc := handleOperatorLIKE
 
-	testCases := []TestCase{
+	testCases := []HandleOperatorTestCase{
 		{
 			name: "handleOperatorLIKE",
 			filterField: FilterField{
@@ -217,7 +217,7 @@ func TestHandleOperatorLIKE(t *testing.T) {
 				strValue:  &strValue,
 				valueKind: reflect.String,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field LIKE '%Some Value%' ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field LIKE '%Some Value%' ORDER BY my_models.id LIMIT 1",
 		},
 	}
 
@@ -237,7 +237,7 @@ func TestHandleOperatorILIKE(t *testing.T) {
 	db, _ := NewMockDB()
 	testFunc := handleOperatorILIKE
 
-	testCases := []TestCase{
+	testCases := []HandleOperatorTestCase{
 		{
 			name: "handleOperatorILIKE",
 			filterField: FilterField{
@@ -245,7 +245,7 @@ func TestHandleOperatorILIKE(t *testing.T) {
 				strValue:  &strValue,
 				valueKind: reflect.String,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field ILIKE '%Some Value%' ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field ILIKE '%Some Value%' ORDER BY my_models.id LIMIT 1",
 		},
 	}
 
@@ -265,7 +265,7 @@ func TestHandleOperatorGT(t *testing.T) {
 	db, _ := NewMockDB()
 	testFunc := handleOperatorGT
 
-	testCases := []TestCase{
+	testCases := []HandleOperatorTestCase{
 		{
 			name: "handleOperatorGT int64",
 			filterField: FilterField{
@@ -273,7 +273,7 @@ func TestHandleOperatorGT(t *testing.T) {
 				intValue:  &int64Value,
 				valueKind: reflect.Int64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field > -123456 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field > -123456 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorGT uint64",
@@ -282,7 +282,7 @@ func TestHandleOperatorGT(t *testing.T) {
 				uintValue: &uint64Value,
 				valueKind: reflect.Uint64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field > 123456 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field > 123456 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorGT float",
@@ -291,7 +291,7 @@ func TestHandleOperatorGT(t *testing.T) {
 				floatValue: &floatValue,
 				valueKind:  reflect.Float64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field > -123456.789 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field > -123456.789 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorGT string",
@@ -300,7 +300,7 @@ func TestHandleOperatorGT(t *testing.T) {
 				strValue:  &strValue,
 				valueKind: reflect.String,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field > 'Some Value' ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field > 'Some Value' ORDER BY my_models.id LIMIT 1",
 		},
 	}
 
@@ -320,7 +320,7 @@ func TestHandleOperatorGE(t *testing.T) {
 	db, _ := NewMockDB()
 	testFunc := handleOperatorGE
 
-	testCases := []TestCase{
+	testCases := []HandleOperatorTestCase{
 		{
 			name: "handleOperatorGE int64",
 			filterField: FilterField{
@@ -328,7 +328,7 @@ func TestHandleOperatorGE(t *testing.T) {
 				intValue:  &int64Value,
 				valueKind: reflect.Int64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field >= -123456 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field >= -123456 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorGE uint64",
@@ -337,7 +337,7 @@ func TestHandleOperatorGE(t *testing.T) {
 				uintValue: &uint64Value,
 				valueKind: reflect.Uint64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field >= 123456 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field >= 123456 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorGE float",
@@ -346,7 +346,7 @@ func TestHandleOperatorGE(t *testing.T) {
 				floatValue: &floatValue,
 				valueKind:  reflect.Float64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field >= -123456.789 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field >= -123456.789 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorGE string",
@@ -355,7 +355,7 @@ func TestHandleOperatorGE(t *testing.T) {
 				strValue:  &strValue,
 				valueKind: reflect.String,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field >= 'Some Value' ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field >= 'Some Value' ORDER BY my_models.id LIMIT 1",
 		},
 	}
 
@@ -375,7 +375,7 @@ func TestHandleOperatorLT(t *testing.T) {
 	db, _ := NewMockDB()
 	testFunc := handleOperatorLT
 
-	testCases := []TestCase{
+	testCases := []HandleOperatorTestCase{
 		{
 			name: "handleOperatorLT int64",
 			filterField: FilterField{
@@ -383,7 +383,7 @@ func TestHandleOperatorLT(t *testing.T) {
 				intValue:  &int64Value,
 				valueKind: reflect.Int64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field < -123456 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field < -123456 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorLT uint64",
@@ -392,7 +392,7 @@ func TestHandleOperatorLT(t *testing.T) {
 				uintValue: &uint64Value,
 				valueKind: reflect.Uint64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field < 123456 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field < 123456 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorLT float",
@@ -401,7 +401,7 @@ func TestHandleOperatorLT(t *testing.T) {
 				floatValue: &floatValue,
 				valueKind:  reflect.Float64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field < -123456.789 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field < -123456.789 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorLT string",
@@ -410,7 +410,7 @@ func TestHandleOperatorLT(t *testing.T) {
 				strValue:  &strValue,
 				valueKind: reflect.String,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field < 'Some Value' ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field < 'Some Value' ORDER BY my_models.id LIMIT 1",
 		},
 	}
 
@@ -430,7 +430,7 @@ func TestHandleOperatorLE(t *testing.T) {
 	db, _ := NewMockDB()
 	testFunc := handleOperatorLE
 
-	testCases := []TestCase{
+	testCases := []HandleOperatorTestCase{
 		{
 			name: "handleOperatorLE int64",
 			filterField: FilterField{
@@ -438,7 +438,7 @@ func TestHandleOperatorLE(t *testing.T) {
 				intValue:  &int64Value,
 				valueKind: reflect.Int64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field <= -123456 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field <= -123456 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorLE uint64",
@@ -447,7 +447,7 @@ func TestHandleOperatorLE(t *testing.T) {
 				uintValue: &uint64Value,
 				valueKind: reflect.Uint64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field <= 123456 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field <= 123456 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorLE float",
@@ -456,7 +456,7 @@ func TestHandleOperatorLE(t *testing.T) {
 				floatValue: &floatValue,
 				valueKind:  reflect.Float64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field <= -123456.789 ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field <= -123456.789 ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorLE string",
@@ -465,7 +465,7 @@ func TestHandleOperatorLE(t *testing.T) {
 				strValue:  &strValue,
 				valueKind: reflect.String,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field <= 'Some Value' ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field <= 'Some Value' ORDER BY my_models.id LIMIT 1",
 		},
 	}
 
@@ -485,7 +485,7 @@ func TestHandleOperatorIN(t *testing.T) {
 	db, _ := NewMockDB()
 	testFunc := handleOperatorIN
 
-	testCases := []TestCase{
+	testCases := []HandleOperatorTestCase{
 		{
 			name: "handleOperatorIN bool",
 			filterField: FilterField{
@@ -493,7 +493,7 @@ func TestHandleOperatorIN(t *testing.T) {
 				boolValues: &boolValues,
 				valueKind:  reflect.Bool,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field IN (true,false) ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field IN (true,false) ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorIN int64",
@@ -502,7 +502,7 @@ func TestHandleOperatorIN(t *testing.T) {
 				intValues: &int64Values,
 				valueKind: reflect.Int64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field IN (-123456,1,123456) ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field IN (-123456,1,123456) ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorIN uint64",
@@ -511,7 +511,7 @@ func TestHandleOperatorIN(t *testing.T) {
 				uintValues: &uint64Values,
 				valueKind:  reflect.Uint64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field IN (123456,1234567,1234568) ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field IN (123456,1234567,1234568) ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorIN float",
@@ -520,7 +520,7 @@ func TestHandleOperatorIN(t *testing.T) {
 				floatValues: &floatValues,
 				valueKind:   reflect.Float64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field IN (-123456.789,-1,123456.789) ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field IN (-123456.789,-1,123456.789) ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorIN string",
@@ -529,7 +529,7 @@ func TestHandleOperatorIN(t *testing.T) {
 				strValues: &strValues,
 				valueKind: reflect.String,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field IN ('First Value','Second Value','Third Value') ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field IN ('First Value','Second Value','Third Value') ORDER BY my_models.id LIMIT 1",
 		},
 	}
 
@@ -549,7 +549,7 @@ func TestHandleOperatorNOT_IN(t *testing.T) {
 	db, _ := NewMockDB()
 	testFunc := handleOperatorNOT_IN
 
-	testCases := []TestCase{
+	testCases := []HandleOperatorTestCase{
 		{
 			name: "handleOperatorNOT_IN bool",
 			filterField: FilterField{
@@ -557,7 +557,7 @@ func TestHandleOperatorNOT_IN(t *testing.T) {
 				boolValues: &boolValues,
 				valueKind:  reflect.Bool,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field NOT IN (true,false) ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field NOT IN (true,false) ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorNOT_IN int64",
@@ -566,7 +566,7 @@ func TestHandleOperatorNOT_IN(t *testing.T) {
 				intValues: &int64Values,
 				valueKind: reflect.Int64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field NOT IN (-123456,1,123456) ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field NOT IN (-123456,1,123456) ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorNOT_IN uint64",
@@ -575,7 +575,7 @@ func TestHandleOperatorNOT_IN(t *testing.T) {
 				uintValues: &uint64Values,
 				valueKind:  reflect.Uint64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field NOT IN (123456,1234567,1234568) ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field NOT IN (123456,1234567,1234568) ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorNOT_IN float",
@@ -584,7 +584,7 @@ func TestHandleOperatorNOT_IN(t *testing.T) {
 				floatValues: &floatValues,
 				valueKind:   reflect.Float64,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field NOT IN (-123456.789,-1,123456.789) ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field NOT IN (-123456.789,-1,123456.789) ORDER BY my_models.id LIMIT 1",
 		},
 		{
 			name: "handleOperatorNOT_IN string",
@@ -593,7 +593,7 @@ func TestHandleOperatorNOT_IN(t *testing.T) {
 				strValues: &strValues,
 				valueKind: reflect.String,
 			},
-			expected: "SELECT * FROM `my_models` WHERE my_table.my_field NOT IN ('First Value','Second Value','Third Value') ORDER BY `my_models`.`id` LIMIT 1",
+			expected: "SELECT * FROM my_models WHERE my_table.my_field NOT IN ('First Value','Second Value','Third Value') ORDER BY my_models.id LIMIT 1",
 		},
 	}
 

app/repository/smartfilter/smartfilter.go

@@ -5,14 +5,14 @@ import (
 	"reflect"
 	"slices"
 	"strings"
-	"time"
 
 	"gorm.io/gorm"
 	"gorm.io/gorm/schema"
 )
 
 const TAG_NAME = "filterfield"
-const TAG_VALUE_SEPARATOR = ","
+const TAG_PAIRS_SEPARATOR = ","
+const TAG_KEYVALUE_SEPARATOR = "="
 
 type handlerFunc func(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB
 
@@ -29,17 +29,6 @@ var operatorHandlers = map[Operator]handlerFunc{
 	OperatorNOT_IN: handleOperatorNOT_IN,
 }
 
-type CertFilter struct {
-	Alive                *bool      `filterfield:"alive,EQ"`
-	SerialNumber         *string    `filterfield:"serial_number,NE"`
-	SerialNumberContains *string    `filterfield:"serial_number,LIKE"`
-	IssuerContains       *string    `filterfield:"issuer,ILIKE"`
-	Id                   *string    `filterfield:"id,EQ"`
-	Ids                  *[]string  `filterfield:"id,IN"`
-	IdsNot               *[]string  `filterfield:"id,NOT_IN"`
-	CreatedAt_Lt         *time.Time `filterfield:"created_at,LT"`
-}
-
 type ReflectedStructField struct {
 	name     string
 	value    reflect.Value
@@ -112,19 +101,39 @@ func ToQuery(model schema.Tabler, filter interface{}, query *gorm.DB) (*gorm.DB,
 }
 
 func newFilterField(tagValue string) (*FilterField, error) {
-	values := strings.Split(tagValue, TAG_VALUE_SEPARATOR)
-	if len(values) != 2 {
-		return nil, fmt.Errorf("incorrect number of tag values: %s", tagValue)
-	}
+	filterField := FilterField{}
 
-	operator := Operator(values[1])
+	tagValue = strings.TrimSpace(tagValue)
+	pairs := strings.Split(tagValue, TAG_PAIRS_SEPARATOR)
+
+	for _, pair := range pairs {
+		kvs := strings.Split(pair, TAG_KEYVALUE_SEPARATOR)
+		if len(kvs) != 2 {
+			return nil, fmt.Errorf("invalid tag value: %s", strings.TrimSpace(pair))
+		}
+		key := strings.TrimSpace(kvs[0])
+		value := strings.TrimSpace(kvs[1])
+
+		switch key {
+		case "field":
+			filterField.Name = value
+		case "operator":
+			operator := Operator(value)
 			if !slices.Contains(OPERATORS, operator) {
 				return nil, fmt.Errorf("unknown operator: %s", operator)
 			}
+			filterField.Operator = operator
+		default:
+			return nil, fmt.Errorf("invalid value key: %s", key)
+		}
+	}
 
-	f := FilterField{
-		Name:     values[0],
-		Operator: operator,
+	if len(filterField.Name) == 0 {
+		return nil, fmt.Errorf("missing field name in tag: %s", tagValue)
 	}
-	return &f, nil
+	if len(filterField.Operator) == 0 {
+		return nil, fmt.Errorf("missing operator in tag: %s", tagValue)
+	}
+
+	return &filterField, nil
 }

app/repository/smartfilter/smartfilter_test.go

@@ -129,3 +129,77 @@ func TestGetFilterFields(t *testing.T) {
 		assert.Equal(t, 0, len(result))
 	})
 }
+
+type TagParseTestCase struct {
+	name     string
+	tagValue string
+	expected FilterField
+}
+
+func TestFilterField(t *testing.T) {
+	testCases := []TagParseTestCase{
+		{
+			name:     "Parse without spaces",
+			tagValue: "field=field_1,operator=EQ",
+			expected: FilterField{
+				Name:     "field_1",
+				Operator: OperatorEQ,
+			},
+		},
+		{
+			name:     "Parse spaces between pairs",
+			tagValue: "   field=field_2 ,   operator=LT   ",
+			expected: FilterField{
+				Name:     "field_2",
+				Operator: OperatorLT,
+			},
+		},
+		{
+			name:     "Parse spaces between around keys and values",
+			tagValue: "operator   = LIKE , field = field_3",
+			expected: FilterField{
+				Name:     "field_3",
+				Operator: OperatorLIKE,
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			filterField, err := newFilterField(testCase.tagValue)
+			assert.Nil(t, err)
+			assert.Equal(t, testCase.expected.Name, filterField.Name)
+			assert.Equal(t, testCase.expected.Operator, filterField.Operator)
+		})
+	}
+
+	t.Run("Fail on invalid tag value", func(t *testing.T) {
+		filterField, err := newFilterField("field=field_1=fail, operator=EQ")
+		assert.Nil(t, filterField)
+		assert.EqualError(t, err, "invalid tag value: field=field_1=fail")
+	})
+
+	t.Run("Fail on invalid operator", func(t *testing.T) {
+		filterField, err := newFilterField("field=field_1, operator=FAIL")
+		assert.Nil(t, filterField)
+		assert.EqualError(t, err, "unknown operator: FAIL")
+	})
+
+	t.Run("Fail on invalid value key", func(t *testing.T) {
+		filterField, err := newFilterField("failkey=field_1, operator=FAIL")
+		assert.Nil(t, filterField)
+		assert.EqualError(t, err, "invalid value key: failkey")
+	})
+
+	t.Run("Fail on missing field name", func(t *testing.T) {
+		filterField, err := newFilterField("operator=EQ")
+		assert.Nil(t, filterField)
+		assert.EqualError(t, err, "missing field name in tag: operator=EQ")
+	})
+
+	t.Run("Fail on missing operator", func(t *testing.T) {
+		filterField, err := newFilterField("field=field_1")
+		assert.Nil(t, filterField)
+		assert.EqualError(t, err, "missing operator in tag: field=field_1")
+	})
+}

go.mod

@@ -3,6 +3,8 @@ module repo-pattern
 go 1.22.3
 
 require (
+	github.com/DATA-DOG/go-sqlmock v1.5.2
+	github.com/go-playground/assert v1.2.1
 	github.com/google/uuid v1.6.0
 	github.com/kelseyhightower/envconfig v1.4.0
 	github.com/mozillazg/go-slugify v0.2.0
@@ -16,9 +18,7 @@ require (
 
 require (
 	filippo.io/edwards25519 v1.1.0 // indirect
-	github.com/DATA-DOG/go-sqlmock v1.5.2 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/go-playground/assert v1.2.1 // indirect
 	github.com/go-sql-driver/mysql v1.8.1 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9 // indirect

go.sum

@@ -48,14 +48,8 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=