Merge pull request #62 from amichaelyu/param_fix

feat: enhance filter builder to support multiple filters on the same …

Author: muratmirgun

filterbuilder.go

@@ -58,6 +58,21 @@ func (f *FilterBuilder) ExecuteToWithContext(ctx context.Context, to interface{}
 
 var filterOperators = []string{"eq", "neq", "gt", "gte", "lt", "lte", "like", "ilike", "is", "in", "cs", "cd", "sl", "sr", "nxl", "nxr", "adj", "ov", "fts", "plfts", "phfts", "wfts"}
 
+// appendFilter is a helper method that appends a filter to existing filters on a column
+func (f *FilterBuilder) appendFilter(column, filterValue string) *FilterBuilder {
+	if existing, ok := f.params[column]; ok && existing != "" {
+		// If a filter already exists for this column, combine with 'and'
+		f.params["and"] = fmt.Sprintf("(%s.%s,%s.%s)", column, existing, column, filterValue)
+		delete(f.params, column)
+	} else if existingAnd, ok := f.params["and"]; ok {
+		// If an 'and' parameter already exists, append to it
+		f.params["and"] = strings.TrimSuffix(existingAnd, ")") + "," + column + "." + filterValue + ")"
+	} else {
+		f.params[column] = filterValue
+	}
+	return f
+}
+
 func isOperator(value string) bool {
 	for _, operator := range filterOperators {
 		if value == operator {
@@ -74,8 +89,7 @@ func (f *FilterBuilder) Filter(column, operator, value string) *FilterBuilder {
 		f.client.ClientError = fmt.Errorf("invalid filter operator")
 		return f
 	}
-	f.params[column] = fmt.Sprintf("%s.%s", operator, value)
-	return f
+	return f.appendFilter(column, fmt.Sprintf("%s.%s", operator, value))
 }
 
 func (f *FilterBuilder) And(filters, foreignTable string) *FilterBuilder {
@@ -100,60 +114,50 @@ func (f *FilterBuilder) Not(column, operator, value string) *FilterBuilder {
 	if !isOperator(operator) {
 		return f
 	}
-	f.params[column] = fmt.Sprintf("not.%s.%s", operator, value)
-	return f
+	return f.Filter(column, "not."+operator, value)
 }
 
 func (f *FilterBuilder) Match(userQuery map[string]string) *FilterBuilder {
 	for key, value := range userQuery {
-		f.params[key] = "eq." + value
+		f.Filter(key, "eq", value)
 	}
 	return f
 }
 
 func (f *FilterBuilder) Eq(column, value string) *FilterBuilder {
-	f.params[column] = "eq." + value
-	return f
+	return f.Filter(column, "eq", value)
 }
 
 func (f *FilterBuilder) Neq(column, value string) *FilterBuilder {
-	f.params[column] = "neq." + value
-	return f
+	return f.Filter(column, "neq", value)
 }
 
 func (f *FilterBuilder) Gt(column, value string) *FilterBuilder {
-	f.params[column] = "gt." + value
-	return f
+	return f.Filter(column, "gt", value)
 }
 
 func (f *FilterBuilder) Gte(column, value string) *FilterBuilder {
-	f.params[column] = "gte." + value
-	return f
+	return f.Filter(column, "gte", value)
 }
 
 func (f *FilterBuilder) Lt(column, value string) *FilterBuilder {
-	f.params[column] = "lt." + value
-	return f
+	return f.Filter(column, "lt", value)
 }
 
 func (f *FilterBuilder) Lte(column, value string) *FilterBuilder {
-	f.params[column] = "lte." + value
-	return f
+	return f.Filter(column, "lte", value)
 }
 
 func (f *FilterBuilder) Like(column, value string) *FilterBuilder {
-	f.params[column] = "like." + value
-	return f
+	return f.Filter(column, "like", value)
 }
 
 func (f *FilterBuilder) Ilike(column, value string) *FilterBuilder {
-	f.params[column] = "ilike." + value
-	return f
+	return f.Filter(column, "ilike", value)
 }
 
 func (f *FilterBuilder) Is(column, value string) *FilterBuilder {
-	f.params[column] = "is." + value
-	return f
+	return f.Filter(column, "is", value)
 }
 
 func (f *FilterBuilder) In(column string, values []string) *FilterBuilder {
@@ -167,8 +171,7 @@ func (f *FilterBuilder) In(column string, values []string) *FilterBuilder {
 			cleanedValues = append(cleanedValues, value)
 		}
 	}
-	f.params[column] = fmt.Sprintf("in.(%s)", strings.Join(cleanedValues, ","))
-	return f
+	return f.appendFilter(column, fmt.Sprintf("in.(%s)", strings.Join(cleanedValues, ",")))
 }
 
 func (f *FilterBuilder) Contains(column string, value []string) *FilterBuilder {
@@ -179,8 +182,7 @@ func (f *FilterBuilder) Contains(column string, value []string) *FilterBuilder {
 
 	valueString := fmt.Sprintf("{%s}", strings.Join(newValue, ","))
 
-	f.params[column] = "cs." + valueString
-	return f
+	return f.appendFilter(column, "cs."+valueString)
 }
 
 func (f *FilterBuilder) ContainedBy(column string, value []string) *FilterBuilder {
@@ -191,51 +193,45 @@ func (f *FilterBuilder) ContainedBy(column string, value []string) *FilterBuilde
 
 	valueString := fmt.Sprintf("{%s}", strings.Join(newValue, ","))
 
-	f.params[column] = "cd." + valueString
-	return f
+	return f.appendFilter(column, "cd."+valueString)
 }
 
 func (f *FilterBuilder) ContainsObject(column string, value interface{}) *FilterBuilder {
 	sum, err := json.Marshal(value)
 	if err != nil {
 		f.client.ClientError = err
+		return f
 	}
-	f.params[column] = "cs." + string(sum)
-	return f
+	return f.appendFilter(column, "cs."+string(sum))
 }
 
 func (f *FilterBuilder) ContainedByObject(column string, value interface{}) *FilterBuilder {
 	sum, err := json.Marshal(value)
 	if err != nil {
 		f.client.ClientError = err
+		return f
 	}
-	f.params[column] = "cs." + string(sum)
-	return f
+	return f.appendFilter(column, "cd."+string(sum))
 }
 
 func (f *FilterBuilder) RangeLt(column, value string) *FilterBuilder {
-	f.params[column] = "sl." + value
-	return f
+	return f.appendFilter(column, "sl."+value)
 }
 
 func (f *FilterBuilder) RangeGt(column, value string) *FilterBuilder {
-	f.params[column] = "sr." + value
-	return f
+	return f.appendFilter(column, "sr."+value)
 }
 
 func (f *FilterBuilder) RangeGte(column, value string) *FilterBuilder {
-	f.params[column] = "nxl." + value
-	return f
+	return f.appendFilter(column, "nxl."+value)
 }
 
 func (f *FilterBuilder) RangeLte(column, value string) *FilterBuilder {
-	f.params[column] = "nxr." + value
-	return f
+	return f.appendFilter(column, "nxr."+value)
 }
 
 func (f *FilterBuilder) RangeAdjacent(column, value string) *FilterBuilder {
-	f.params[column] = "adj." + value
-	return f
+	return f.appendFilter(column, "adj."+value)
 }
 
 func (f *FilterBuilder) Overlaps(column string, value []string) *FilterBuilder {
@@ -245,8 +241,7 @@ func (f *FilterBuilder) Overlaps(column string, value []string) *FilterBuilder {
 	}
 
 	valueString := fmt.Sprintf("{%s}", strings.Join(newValue, ","))
-	f.params[column] = "ov." + valueString
-	return f
+	return f.appendFilter(column, "ov."+valueString)
 }
 
 // TextSearch performs a full-text search filter. For more information, see
@@ -268,8 +263,7 @@ func (f *FilterBuilder) TextSearch(column, userQuery, config, tsType string) *Fi
 	if config != "" {
 		configPart = fmt.Sprintf("(%s)", config)
 	}
-	f.params[column] = typePart + "fts" + configPart + "." + userQuery
-	return f
+	return f.appendFilter(column, typePart+"fts"+configPart+"."+userQuery)
 }
 
 // OrderOpts describes the options to be provided to Order.

filterbuilder_test.go

@@ -263,3 +263,120 @@ func TestFilterBuilder_Single(t *testing.T) {
 		assert.Error(err)
 	})
 }
+
+func TestFilterAppend(t *testing.T) {
+	tests := []struct {
+		name     string
+		build    func(*FilterBuilder) *FilterBuilder
+		expected map[string]string
+	}{
+		{
+			name: "Single filter on column",
+			build: func(fb *FilterBuilder) *FilterBuilder {
+				return fb.Eq("age", "25")
+			},
+			expected: map[string]string{
+				"age": "eq.25",
+			},
+		},
+		{
+			name: "Multiple filters on same column",
+			build: func(fb *FilterBuilder) *FilterBuilder {
+				return fb.Gte("age", "25").Lte("age", "35")
+			},
+			expected: map[string]string{
+				"and": "(age.gte.25,age.lte.35)",
+			},
+		},
+		{
+			name: "Three filters on same column",
+			build: func(fb *FilterBuilder) *FilterBuilder {
+				return fb.Gte("age", "25").Lte("age", "35").Neq("age", "30")
+			},
+			expected: map[string]string{
+				"and": "(age.gte.25,age.lte.35,age.neq.30)",
+			},
+		},
+		{
+			name: "Multiple columns with multiple filters",
+			build: func(fb *FilterBuilder) *FilterBuilder {
+				return fb.Eq("status", "active").Gte("age", "25").Lte("age", "35")
+			},
+			expected: map[string]string{
+				"status": "eq.active",
+				"and":    "(age.gte.25,age.lte.35)",
+			},
+		},
+		{
+			name: "In filter followed by another filter",
+			build: func(fb *FilterBuilder) *FilterBuilder {
+				return fb.In("id", []string{"1", "2", "3"}).Eq("id", "4")
+			},
+			expected: map[string]string{
+				"and": "(id.in.(1,2,3),id.eq.4)",
+			},
+		},
+		{
+			name: "Contains filter followed by another filter",
+			build: func(fb *FilterBuilder) *FilterBuilder {
+				return fb.Contains("tags", []string{"golang", "postgres"}).Overlaps("tags", []string{"javascript"})
+			},
+			expected: map[string]string{
+				"and": "(tags.cs.{\"golang\",\"postgres\"},tags.ov.{\"javascript\"})",
+			},
+		},
+		{
+			name: "Text search followed by Like filter",
+			build: func(fb *FilterBuilder) *FilterBuilder {
+				return fb.TextSearch("title", "golang", "", "plain").Like("title", "%tutorial%")
+			},
+			expected: map[string]string{
+				"and": "(title.plfts.golang,title.like.%tutorial%)",
+			},
+		},
+		{
+			name: "Range filters on same column",
+			build: func(fb *FilterBuilder) *FilterBuilder {
+				return fb.RangeGt("period", "[2022-01-01,2022-12-31]").RangeLt("period", "[2023-01-01,2023-12-31]")
+			},
+			expected: map[string]string{
+				"and": "(period.sr.[2022-01-01,2022-12-31],period.sl.[2023-01-01,2023-12-31])",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			client := NewClient("http://localhost:3000", "", nil)
+			fb := &FilterBuilder{
+				client:    client,
+				method:    "GET",
+				tableName: "test",
+				headers:   make(map[string]string),
+				params:    make(map[string]string),
+			}
+
+			result := tt.build(fb)
+
+			// Check that we got the expected params
+			if len(result.params) != len(tt.expected) {
+				t.Errorf("Expected %d params, got %d", len(tt.expected), len(result.params))
+			}
+
+			for key, expectedValue := range tt.expected {
+				if actualValue, ok := result.params[key]; !ok {
+					t.Errorf("Expected param %s not found", key)
+				} else if actualValue != expectedValue {
+					t.Errorf("Param %s: expected %s, got %s", key, expectedValue, actualValue)
+				}
+			}
+
+			// Check that no unexpected params exist
+			for key := range result.params {
+				if _, ok := tt.expected[key]; !ok {
+					t.Errorf("Unexpected param %s found", key)
+				}
+			}
+		})
+	}
+}