feat: supports configuring multiple converters

mql.go

@@ -71,9 +71,9 @@ func exprToWhereClause(e expr, fValidators map[string]validator, opt ...Option)
 		if err != nil {
 			return nil, fmt.Errorf("%s: %w", op, err)
 		}
-		switch {
-		case opts.withValidateConvertColumn == v.column && !isNil(opts.withValidateConvertFn):
-			return opts.withValidateConvertFn(v.column, v.comparisonOp, v.value)
+		switch validateConvertFn, ok := opts.withValidateConvertFns[v.column]; {
+		case ok && !isNil(validateConvertFn):
+			return validateConvertFn(v.column, v.comparisonOp, v.value)
 		default:
 			columnName := strings.ToLower(v.column)
 			if n, ok := opts.withColumnMap[columnName]; ok {

mql_test.go

@@ -187,6 +187,33 @@ func TestParse(t *testing.T) {
 			wantErrIs:       mql.ErrInvalidParameter,
 			wantErrContains: "missing field name: invalid parameter",
 		},
+		{
+			name:  "err-WithConverter-duplicated-converter",
+			query: "name=\"alice\" and email=\"[email protected]\"",
+			model: testModel{},
+			opts: []mql.Option{
+				mql.WithConverter(
+					"name",
+					func(columnName string, comparisonOp mql.ComparisonOp, value *string) (*mql.WhereClause, error) {
+						return &mql.WhereClause{Condition: "name=?", Args: []any{"alice"}}, nil
+					},
+				),
+				mql.WithConverter(
+					"email",
+					func(columnName string, comparisonOp mql.ComparisonOp, value *string) (*mql.WhereClause, error) {
+						return &mql.WhereClause{Condition: "email=?", Args: []any{"[email protected]"}}, nil
+					},
+				),
+				mql.WithConverter(
+					"name",
+					func(columnName string, comparisonOp mql.ComparisonOp, value *string) (*mql.WhereClause, error) {
+						return &mql.WhereClause{Condition: "duplicated-Converter name=?", Args: []any{"alice"}}, nil
+					},
+				),
+			},
+			wantErrIs:       mql.ErrInvalidParameter,
+			wantErrContains: "duplicated convert: invalid parameter",
+		},
 		{
 			name:  "success-WithConverter",
 			query: "(name = \"alice\" and email=\"[email protected]\") or age > 21",
@@ -210,6 +237,41 @@ func TestParse(t *testing.T) {
 				Args:      []any{"success-WithConverter: alice", "[email protected]", 21},
 			},
 		},
+		{
+			name:  "success-WithMultiConverters",
+			query: "(name = \"alice\" and email=\"[email protected]\") or age > 21",
+			model: testModel{},
+			opts: []mql.Option{
+				mql.WithConverter(
+					"name",
+					func(columnName string, comparisonOp mql.ComparisonOp, value *string) (*mql.WhereClause, error) {
+						return &mql.WhereClause{
+							// intentionally not the correct condition and
+							// args, but this makes verifying the test
+							// easier.
+							Condition: fmt.Sprintf("success-WithConverter: %s%s?", columnName, comparisonOp),
+							Args:      []any{"success-WithConverter: alice"},
+						}, nil
+					},
+				),
+				mql.WithConverter(
+					"email",
+					func(columnName string, comparisonOp mql.ComparisonOp, value *string) (*mql.WhereClause, error) {
+						return &mql.WhereClause{
+							// intentionally not the correct condition and
+							// args, but this makes verifying the test
+							// easier.
+							Condition: fmt.Sprintf("success-WithConverter: %s%s?", columnName, comparisonOp),
+							Args:      []any{"success-WithConverter: email=\"[email protected]\""},
+						}, nil
+					},
+				),
+			},
+			want: &mql.WhereClause{
+				Condition: "((success-WithConverter: name=? and success-WithConverter: email=?) or age>?)",
+				Args:      []any{"success-WithConverter: alice", "success-WithConverter: email=\"[email protected]\"", 21},
+			},
+		},
 		{
 			name:            "err-ignored-field-used-in-query",
 			query:           "email=\"[email protected]\" or name=\"alice\"",

options.go

@@ -8,20 +8,20 @@ import (
 )
 
 type options struct {
-	withSkipWhitespace        bool
-	withColumnMap             map[string]string
-	withValidateConvertFn     ValidateConvertFunc
-	withValidateConvertColumn string
-	withIgnoredFields         []string
-	withPgPlaceholder         bool
+	withSkipWhitespace     bool
+	withColumnMap          map[string]string
+	withValidateConvertFns map[string]ValidateConvertFunc
+	withIgnoredFields      []string
+	withPgPlaceholder      bool
 }
 
 // Option - how options are passed as args
 type Option func(*options) error
 
 func getDefaultOptions() options {
 	return options{
-		withColumnMap: make(map[string]string),
+		withColumnMap:          make(map[string]string),
+		withValidateConvertFns: make(map[string]ValidateConvertFunc),
 	}
 }
 
@@ -67,8 +67,10 @@ func WithConverter(fieldName string, fn ValidateConvertFunc) Option {
 	return func(o *options) error {
 		switch {
 		case fieldName != "" && !isNil(fn):
-			o.withValidateConvertFn = fn
-			o.withValidateConvertColumn = fieldName
+			if _, exists := o.withValidateConvertFns[fieldName]; exists {
+				return fmt.Errorf("%s: duplicated convert: %w", op, ErrInvalidParameter)
+			}
+			o.withValidateConvertFns[fieldName] = fn
 		case fieldName == "" && !isNil(fn):
 			return fmt.Errorf("%s: missing field name: %w", op, ErrInvalidParameter)
 		case fieldName != "" && isNil(fn):