Rename search package to filter package

.golangci.yml

@@ -35,7 +35,7 @@ linters-settings:
   godot:
     capital: true
   ireturn:
-    allow: "error,empty,anon,stdlib,.*(or|er)$,github.com/99designs/gqlgen/graphql.Marshaler,github.com/dstotijn/hetty/pkg/api.QueryResolver,github.com/dstotijn/hetty/pkg/search.Expression"
+    allow: "error,empty,anon,stdlib,.*(or|er)$,github.com/99designs/gqlgen/graphql.Marshaler,github.com/dstotijn/hetty/pkg/api.QueryResolver,github.com/dstotijn/hetty/pkg/filter.Expression"
 
 issues:
   exclude-rules:

pkg/api/resolvers.go

@@ -18,12 +18,12 @@ import (
 	"github.com/oklog/ulid"
 	"github.com/vektah/gqlparser/v2/gqlerror"
 
+	"github.com/dstotijn/hetty/pkg/filter"
 	"github.com/dstotijn/hetty/pkg/proj"
 	"github.com/dstotijn/hetty/pkg/proxy"
 	"github.com/dstotijn/hetty/pkg/proxy/intercept"
 	"github.com/dstotijn/hetty/pkg/reqlog"
 	"github.com/dstotijn/hetty/pkg/scope"
-	"github.com/dstotijn/hetty/pkg/search"
 	"github.com/dstotijn/hetty/pkg/sender"
 )
 
@@ -639,7 +639,7 @@ func (r *mutationResolver) UpdateInterceptSettings(
 	}
 
 	if input.RequestFilter != nil && *input.RequestFilter != "" {
-		expr, err := search.ParseQuery(*input.RequestFilter)
+		expr, err := filter.ParseQuery(*input.RequestFilter)
 		if err != nil {
 			return nil, fmt.Errorf("could not parse request filter: %w", err)
 		}
@@ -648,7 +648,7 @@ func (r *mutationResolver) UpdateInterceptSettings(
 	}
 
 	if input.ResponseFilter != nil && *input.ResponseFilter != "" {
-		expr, err := search.ParseQuery(*input.ResponseFilter)
+		expr, err := filter.ParseQuery(*input.ResponseFilter)
 		if err != nil {
 			return nil, fmt.Errorf("could not parse response filter: %w", err)
 		}
@@ -916,43 +916,43 @@ func scopeToScopeRules(rules []scope.Rule) []ScopeRule {
 	return scopeRules
 }
 
-func findRequestsFilterFromInput(input *HTTPRequestLogFilterInput) (filter reqlog.FindRequestsFilter, err error) {
+func findRequestsFilterFromInput(input *HTTPRequestLogFilterInput) (findFilter reqlog.FindRequestsFilter, err error) {
 	if input == nil {
 		return
 	}
 
 	if input.OnlyInScope != nil {
-		filter.OnlyInScope = *input.OnlyInScope
+		findFilter.OnlyInScope = *input.OnlyInScope
 	}
 
 	if input.SearchExpression != nil && *input.SearchExpression != "" {
-		expr, err := search.ParseQuery(*input.SearchExpression)
+		expr, err := filter.ParseQuery(*input.SearchExpression)
 		if err != nil {
 			return reqlog.FindRequestsFilter{}, fmt.Errorf("could not parse search query: %w", err)
 		}
 
-		filter.SearchExpr = expr
+		findFilter.SearchExpr = expr
 	}
 
 	return
 }
 
-func findSenderRequestsFilterFromInput(input *SenderRequestFilterInput) (filter sender.FindRequestsFilter, err error) {
+func findSenderRequestsFilterFromInput(input *SenderRequestFilterInput) (findFilter sender.FindRequestsFilter, err error) {
 	if input == nil {
 		return
 	}
 
 	if input.OnlyInScope != nil {
-		filter.OnlyInScope = *input.OnlyInScope
+		findFilter.OnlyInScope = *input.OnlyInScope
 	}
 
 	if input.SearchExpression != nil && *input.SearchExpression != "" {
-		expr, err := search.ParseQuery(*input.SearchExpression)
+		expr, err := filter.ParseQuery(*input.SearchExpression)
 		if err != nil {
 			return sender.FindRequestsFilter{}, fmt.Errorf("could not parse search query: %w", err)
 		}
 
-		filter.SearchExpr = expr
+		findFilter.SearchExpr = expr
 	}
 
 	return

pkg/db/badger/proj_test.go

@@ -15,9 +15,9 @@ import (
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/oklog/ulid"
 
+	"github.com/dstotijn/hetty/pkg/filter"
 	"github.com/dstotijn/hetty/pkg/proj"
 	"github.com/dstotijn/hetty/pkg/scope"
-	"github.com/dstotijn/hetty/pkg/search"
 )
 
 //nolint:gosec
@@ -45,7 +45,7 @@ func TestUpsertProject(t *testing.T) {
 	database := DatabaseFromBadgerDB(badgerDB)
 	defer database.Close()
 
-	searchExpr, err := search.ParseQuery("foo AND bar OR NOT baz")
+	searchExpr, err := filter.ParseQuery("foo AND bar OR NOT baz")
 	if err != nil {
 		t.Fatalf("unexpected error (expected: nil, got: %v)", err)
 	}

pkg/search/ast.go → pkg/filter/ast.go

@@ -1,4 +1,4 @@
-package search
+package filter
 
 import (
 	"encoding/gob"
@@ -78,8 +78,10 @@ func (rl *RegexpLiteral) UnmarshalBinary(data []byte) error {
 }
 
 func init() {
-	gob.Register(PrefixExpression{})
-	gob.Register(InfixExpression{})
-	gob.Register(StringLiteral{})
-	gob.Register(RegexpLiteral{})
+	// The `filter` package was previously named `search`.
+	// We use the legacy names for backwards compatibility with existing database data.
+	gob.RegisterName("github.com/dstotijn/hetty/pkg/search.PrefixExpression", PrefixExpression{})
+	gob.RegisterName("github.com/dstotijn/hetty/pkg/search.InfixExpression", InfixExpression{})
+	gob.RegisterName("github.com/dstotijn/hetty/pkg/search.StringLiteral", StringLiteral{})
+	gob.RegisterName("github.com/dstotijn/hetty/pkg/search.RegexpLiteral", RegexpLiteral{})
 }

pkg/filter/ast_test.go

@@ -0,0 +1,212 @@
+package filter_test
+
+import (
+	"regexp"
+	"testing"
+
+	"github.com/dstotijn/hetty/pkg/filter"
+)
+
+func TestExpressionString(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		expression filter.Expression
+		expected   string
+	}{
+		{
+			name:       "string literal expression",
+			expression: filter.StringLiteral{Value: "foobar"},
+			expected:   `"foobar"`,
+		},
+		{
+			name: "boolean expression with equal operator",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpEq,
+				Left:     filter.StringLiteral{Value: "foo"},
+				Right:    filter.StringLiteral{Value: "bar"},
+			},
+			expected: `("foo" = "bar")`,
+		},
+		{
+			name: "boolean expression with not equal operator",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpNotEq,
+				Left:     filter.StringLiteral{Value: "foo"},
+				Right:    filter.StringLiteral{Value: "bar"},
+			},
+			expected: `("foo" != "bar")`,
+		},
+		{
+			name: "boolean expression with greater than operator",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpGt,
+				Left:     filter.StringLiteral{Value: "foo"},
+				Right:    filter.StringLiteral{Value: "bar"},
+			},
+			expected: `("foo" > "bar")`,
+		},
+		{
+			name: "boolean expression with less than operator",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpLt,
+				Left:     filter.StringLiteral{Value: "foo"},
+				Right:    filter.StringLiteral{Value: "bar"},
+			},
+			expected: `("foo" < "bar")`,
+		},
+		{
+			name: "boolean expression with greater than or equal operator",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpGtEq,
+				Left:     filter.StringLiteral{Value: "foo"},
+				Right:    filter.StringLiteral{Value: "bar"},
+			},
+			expected: `("foo" >= "bar")`,
+		},
+		{
+			name: "boolean expression with less than or equal operator",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpLtEq,
+				Left:     filter.StringLiteral{Value: "foo"},
+				Right:    filter.StringLiteral{Value: "bar"},
+			},
+			expected: `("foo" <= "bar")`,
+		},
+		{
+			name: "boolean expression with regular expression operator",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpRe,
+				Left:     filter.StringLiteral{Value: "foo"},
+				Right:    filter.RegexpLiteral{regexp.MustCompile("bar")},
+			},
+			expected: `("foo" =~ "bar")`,
+		},
+		{
+			name: "boolean expression with not regular expression operator",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpNotRe,
+				Left:     filter.StringLiteral{Value: "foo"},
+				Right:    filter.RegexpLiteral{regexp.MustCompile("bar")},
+			},
+			expected: `("foo" !~ "bar")`,
+		},
+		{
+			name: "boolean expression with AND, OR and NOT operators",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpAnd,
+				Left:     filter.StringLiteral{Value: "foo"},
+				Right: filter.InfixExpression{
+					Operator: filter.TokOpOr,
+					Left:     filter.StringLiteral{Value: "bar"},
+					Right: filter.PrefixExpression{
+						Operator: filter.TokOpNot,
+						Right:    filter.StringLiteral{Value: "baz"},
+					},
+				},
+			},
+			expected: `("foo" AND ("bar" OR (NOT "baz")))`,
+		},
+		{
+			name: "boolean expression with nested group",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpOr,
+				Left: filter.InfixExpression{
+					Operator: filter.TokOpAnd,
+					Left:     filter.StringLiteral{Value: "foo"},
+					Right:    filter.StringLiteral{Value: "bar"},
+				},
+				Right: filter.PrefixExpression{
+					Operator: filter.TokOpNot,
+					Right:    filter.StringLiteral{Value: "baz"},
+				},
+			},
+			expected: `(("foo" AND "bar") OR (NOT "baz"))`,
+		},
+		{
+			name: "implicit boolean expression with string literal operands",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpAnd,
+				Left: filter.InfixExpression{
+					Operator: filter.TokOpAnd,
+					Left:     filter.StringLiteral{Value: "foo"},
+					Right:    filter.StringLiteral{Value: "bar"},
+				},
+				Right: filter.StringLiteral{Value: "baz"},
+			},
+			expected: `(("foo" AND "bar") AND "baz")`,
+		},
+		{
+			name: "implicit boolean expression nested in group",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpAnd,
+				Left:     filter.StringLiteral{Value: "foo"},
+				Right:    filter.StringLiteral{Value: "bar"},
+			},
+			expected: `("foo" AND "bar")`,
+		},
+		{
+			name: "implicit and explicit boolean expression with string literal operands",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpAnd,
+				Left: filter.InfixExpression{
+					Operator: filter.TokOpAnd,
+					Left:     filter.StringLiteral{Value: "foo"},
+					Right: filter.InfixExpression{
+						Operator: filter.TokOpOr,
+						Left:     filter.StringLiteral{Value: "bar"},
+						Right:    filter.StringLiteral{Value: "baz"},
+					},
+				},
+				Right: filter.StringLiteral{Value: "yolo"},
+			},
+			expected: `(("foo" AND ("bar" OR "baz")) AND "yolo")`,
+		},
+		{
+			name: "implicit boolean expression with comparison operands",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpAnd,
+				Left: filter.InfixExpression{
+					Operator: filter.TokOpEq,
+					Left:     filter.StringLiteral{Value: "foo"},
+					Right:    filter.StringLiteral{Value: "bar"},
+				},
+				Right: filter.InfixExpression{
+					Operator: filter.TokOpRe,
+					Left:     filter.StringLiteral{Value: "baz"},
+					Right:    filter.RegexpLiteral{regexp.MustCompile("yolo")},
+				},
+			},
+			expected: `(("foo" = "bar") AND ("baz" =~ "yolo"))`,
+		},
+		{
+			name: "eq operator takes precedence over boolean ops",
+			expression: filter.InfixExpression{
+				Operator: filter.TokOpOr,
+				Left: filter.InfixExpression{
+					Operator: filter.TokOpEq,
+					Left:     filter.StringLiteral{Value: "foo"},
+					Right:    filter.StringLiteral{Value: "bar"},
+				},
+				Right: filter.InfixExpression{
+					Operator: filter.TokOpEq,
+					Left:     filter.StringLiteral{Value: "baz"},
+					Right:    filter.StringLiteral{Value: "yolo"},
+				},
+			},
+			expected: `(("foo" = "bar") OR ("baz" = "yolo"))`,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			got := tt.expression.String()
+			if tt.expected != got {
+				t.Errorf("expected: %v, got: %v", tt.expected, got)
+			}
+		})
+	}
+}

pkg/search/http.go → pkg/filter/http.go

@@ -1,4 +1,4 @@
-package search
+package filter
 
 import (
 	"errors"
@@ -15,7 +15,7 @@ func MatchHTTPHeaders(op TokenType, expr Expression, headers http.Header) (bool,
 	case TokOpEq:
 		strLiteral, ok := expr.(StringLiteral)
 		if !ok {
-			return false, errors.New("search: expression must be a string literal")
+			return false, errors.New("filter: expression must be a string literal")
 		}
 
 		// Return `true` if at least one header (<key>: <value>) is equal to the string literal.
@@ -31,7 +31,7 @@ func MatchHTTPHeaders(op TokenType, expr Expression, headers http.Header) (bool,
 	case TokOpNotEq:
 		strLiteral, ok := expr.(StringLiteral)
 		if !ok {
-			return false, errors.New("search: expression must be a string literal")
+			return false, errors.New("filter: expression must be a string literal")
 		}
 
 		// Return `true` if none of the headers (<key>: <value>) are equal to the string literal.
@@ -47,7 +47,7 @@ func MatchHTTPHeaders(op TokenType, expr Expression, headers http.Header) (bool,
 	case TokOpRe:
 		re, ok := expr.(RegexpLiteral)
 		if !ok {
-			return false, errors.New("search: expression must be a regular expression")
+			return false, errors.New("filter: expression must be a regular expression")
 		}
 
 		// Return `true` if at least one header (<key>: <value>) matches the regular expression.
@@ -63,7 +63,7 @@ func MatchHTTPHeaders(op TokenType, expr Expression, headers http.Header) (bool,
 	case TokOpNotRe:
 		re, ok := expr.(RegexpLiteral)
 		if !ok {
-			return false, errors.New("search: expression must be a regular expression")
+			return false, errors.New("filter: expression must be a regular expression")
 		}
 
 		// Return `true` if none of the headers (<key>: <value>) match the regular expression.
@@ -77,6 +77,6 @@ func MatchHTTPHeaders(op TokenType, expr Expression, headers http.Header) (bool,
 
 		return true, nil
 	default:
-		return false, fmt.Errorf("search: unsupported operator %q", op.String())
+		return false, fmt.Errorf("filter: unsupported operator %q", op.String())
 	}
 }