Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

refactor: parse CEL filter in store with qb (#17831)

p0ny10fdd89892c8
diff --git a/backend/api/v1/audit_log_service.go b/backend/api/v1/audit_log_service.go
index 118961a56a..8f3d293923 100644
--- a/backend/api/v1/audit_log_service.go
+++ b/backend/api/v1/audit_log_service.go
@@ -3,18 +3,14 @@ package v1
import (
"context"
"fmt"
- "strings"
"time"
"connectrpc.com/connect"
- "google.golang.org/protobuf/types/known/timestamppb"
-
- "github.com/google/cel-go/cel"
- celast "github.com/google/cel-go/common/ast"
- celoperators "github.com/google/cel-go/common/operators"
"github.com/pkg/errors"
+ "google.golang.org/protobuf/types/known/timestamppb"
"github.com/bytebase/bytebase/backend/common"
+ "github.com/bytebase/bytebase/backend/common/qb"
"github.com/bytebase/bytebase/backend/component/iam"
"github.com/bytebase/bytebase/backend/enterprise"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -42,20 +38,20 @@ func (s *AuditLogService) SearchAuditLogs(ctx context.Context, request *connect.
if err := s.licenseService.IsFeatureEnabled(v1pb.PlanFeature_FEATURE_AUDIT_LOG); err != nil {
return nil, connect.NewError(connect.CodePermissionDenied, err)
}
- filter, err := s.getSearchAuditLogsFilter(ctx, request.Msg.Filter)
+ filterQ, err := store.GetSearchAuditLogsFilter(ctx, s.store, request.Msg.Filter)
if err != nil {
- return nil, err
+ return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
// Apply retention-based filtering based on the plan
retentionCutoff := s.licenseService.GetAuditLogRetentionCutoff()
if retentionCutoff != nil {
- filter = s.applyRetentionFilter(filter, retentionCutoff)
+ filterQ = applyRetentionFilter(filterQ, retentionCutoff)
}
orderByKeys, err := getSearchAuditLogsOrderByKeys(request.Msg.OrderBy)
if err != nil {
- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to get order by keys"))
+ return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
offset, err := parseLimitAndOffset(&pageSize{
@@ -76,19 +72,19 @@ func (s *AuditLogService) SearchAuditLogs(ctx context.Context, request *connect.
Project: project,
Limit: &limitPlusOne,
Offset: &offset.offset,
- Filter: filter,
+ FilterQ: filterQ,
OrderByKeys: orderByKeys,
}
auditLogs, err := s.store.SearchAuditLogs(ctx, auditLogFind)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get audit logs"))
+ return nil, connect.NewError(connect.CodeInternal, err)
}
var nextPageToken string
if len(auditLogs) == limitPlusOne {
auditLogs = auditLogs[:offset.limit]
if nextPageToken, err = offset.getNextPageToken(); err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get next page token"))
+ return nil, connect.NewError(connect.CodeInternal, err)
}
}
@@ -226,95 +222,6 @@ func convertToAuditLogSeverity(s storepb.AuditLog_Severity) v1pb.AuditLog_Severi
}
}
-func (s *AuditLogService) getSearchAuditLogsFilter(ctx context.Context, filter string) (*store.ListResourceFilter, error) {
- if filter == "" {
- return nil, nil
- }
-
- e, err := cel.NewEnv()
- if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.New("failed to create cel env"))
- }
- ast, iss := e.Parse(filter)
- if iss != nil {
- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to parse filter %v, error: %v", filter, iss.String()))
- }
-
- var getFilter func(expr celast.Expr) (string, error)
- var positionalArgs []any
-
- getFilter = func(expr celast.Expr) (string, error) {
- switch expr.Kind() {
- case celast.CallKind:
- functionName := expr.AsCall().FunctionName()
- switch functionName {
- case celoperators.LogicalOr:
- return getSubConditionFromExpr(expr, getFilter, "OR")
- case celoperators.LogicalAnd:
- return getSubConditionFromExpr(expr, getFilter, "AND")
- case celoperators.Equals:
- variable, rawValue := getVariableAndValueFromExpr(expr)
- value, ok := rawValue.(string)
- if !ok {
- return "", errors.Errorf("expect string, got %T, hint: filter literals should be string", rawValue)
- }
- switch variable {
- case "resource", "method", "user", "severity":
- default:
- return "", errors.Errorf("unknown variable %s", variable)
- }
- if variable == "user" {
- // Convert user email to user id.
- // e.g. users/[email protected] -> users/101
- user, err := s.getUserByIdentifier(ctx, value)
- if err != nil {
- return "", err
- }
- value = fmt.Sprintf("%s%d", common.UserNamePrefix, user.ID)
- }
- positionalArgs = append(positionalArgs, value)
- return fmt.Sprintf("payload->>'%s'=$%d", variable, len(positionalArgs)), nil
-
- case celoperators.GreaterEquals, celoperators.LessEquals:
- variable, rawValue := getVariableAndValueFromExpr(expr)
- value, ok := rawValue.(string)
- if !ok {
- return "", errors.Errorf("expect string, got %T, hint: filter literals should be string", rawValue)
- }
- if variable != "create_time" {
- return "", errors.Errorf(`">=" and "<=" are only supported for "create_time"`)
- }
-
- t, err := time.Parse(time.RFC3339, value)
- if err != nil {
- return "", errors.Errorf("failed to parse time %v, error: %v", value, err)
- }
- positionalArgs = append(positionalArgs, t)
- if functionName == celoperators.GreaterEquals {
- return fmt.Sprintf("created_at >= $%d", len(positionalArgs)), nil
- }
- return fmt.Sprintf("created_at <= $%d", len(positionalArgs)), nil
-
- default:
- return "", errors.Errorf("unexpected function %v", functionName)
- }
-
- default:
- return "", errors.Errorf("unexpected expr kind %v", expr.Kind())
- }
- }
-
- where, err := getFilter(ast.NativeRep().Expr())
- if err != nil {
- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to get filter"))
- }
-
- return &store.ListResourceFilter{
- Args: positionalArgs,
- Where: "(" + where + ")",
- }, nil
-}
-
func getSearchAuditLogsOrderByKeys(orderBy string) ([]store.OrderByKey, error) {
keys, err := parseOrderBy(orderBy)
if err != nil {
@@ -343,37 +250,20 @@ func getSearchAuditLogsOrderByKeys(orderBy string) ([]store.OrderByKey, error) {
return orderByKeys, nil
}
-func (s *AuditLogService) getUserByIdentifier(ctx context.Context, identifier string) (*store.UserMessage, error) {
- email := strings.TrimPrefix(identifier, "users/")
- if email == "" {
- return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("invalid empty creator identifier"))
- }
- user, err := s.store.GetUserByEmail(ctx, email)
- if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, `failed to find user "%s"`, email))
- }
- if user == nil {
- return nil, errors.Errorf("cannot found user %s", email)
- }
- return user, nil
-}
-
// applyRetentionFilter merges retention-based filtering with user-provided filters.
-func (*AuditLogService) applyRetentionFilter(userFilter *store.ListResourceFilter, cutoff *time.Time) *store.ListResourceFilter {
+func applyRetentionFilter(userFilterQ *qb.Query, cutoff *time.Time) *qb.Query {
if cutoff == nil {
- return userFilter
+ return userFilterQ
}
- if userFilter == nil {
- return &store.ListResourceFilter{
- Where: "(created_at >= $1)",
- Args: []any{*cutoff},
- }
+ retentionQ := qb.Q().Space("created_at >= ?", *cutoff)
+ if userFilterQ == nil {
+ return qb.Q().Space("(?)", retentionQ)
}
// Combine with existing filter using AND
- return &store.ListResourceFilter{
- Where: fmt.Sprintf("(%s) AND (created_at >= $%d)", userFilter.Where, len(userFilter.Args)+1),
- Args: append(userFilter.Args, *cutoff),
- }
+ q := qb.Q()
+ q.Space("?", userFilterQ)
+ q.And("?", retentionQ)
+ return qb.Q().Space("(?)", q)
}
diff --git a/backend/api/v1/audit_log_service_test.go b/backend/api/v1/audit_log_service_test.go
index 94c30baacc..1751c693ff 100644
--- a/backend/api/v1/audit_log_service_test.go
+++ b/backend/api/v1/audit_log_service_test.go
@@ -7,68 +7,60 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
+ "github.com/bytebase/bytebase/backend/common/qb"
v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
- "github.com/bytebase/bytebase/backend/store"
)
func TestApplyRetentionFilter(t *testing.T) {
- s := &AuditLogService{}
now := time.Now()
sevenDaysAgo := now.AddDate(0, 0, -7)
tests := []struct {
- name string
- userFilter *store.ListResourceFilter
- cutoff *time.Time
- wantFilter *store.ListResourceFilter
- description string
+ name string
+ userFilterQ *qb.Query
+ cutoff *time.Time
+ wantSQLPattern []string // Pattern to match in SQL
+ description string
}{
{
- name: "No retention cutoff (Enterprise plan)",
- userFilter: &store.ListResourceFilter{
- Where: "(payload->>'method'=$1)",
- Args: []any{"/bytebase.v1.SQLService/Query"},
- },
- cutoff: nil,
- wantFilter: &store.ListResourceFilter{
- Where: "(payload->>'method'=$1)",
- Args: []any{"/bytebase.v1.SQLService/Query"},
+ name: "No retention cutoff (Enterprise plan)",
+ userFilterQ: qb.Q().Space("payload->>'method' = ?", "/bytebase.v1.SQLService/Query"),
+ cutoff: nil,
+ wantSQLPattern: []string{
+ "payload->>'method' = $1",
},
description: "Should return user filter unchanged when no cutoff",
},
{
- name: "Apply retention to empty filter (Team plan)",
- userFilter: nil,
- cutoff: &sevenDaysAgo,
- wantFilter: &store.ListResourceFilter{
- Where: "(created_at >= $1)",
- Args: []any{sevenDaysAgo},
+ name: "Apply retention to empty filter (Team plan)",
+ userFilterQ: nil,
+ cutoff: &sevenDaysAgo,
+ wantSQLPattern: []string{
+ "created_at >= $1",
},
description: "Should create retention filter when no user filter",
},
{
- name: "Merge retention with existing filter (Team plan)",
- userFilter: &store.ListResourceFilter{
- Where: "(payload->>'method'=$1)",
- Args: []any{"/bytebase.v1.SQLService/Query"},
- },
- cutoff: &sevenDaysAgo,
- wantFilter: &store.ListResourceFilter{
- Where: "((payload->>'method'=$1)) AND (created_at >= $2)",
- Args: []any{"/bytebase.v1.SQLService/Query", sevenDaysAgo},
+ name: "Merge retention with existing filter (Team plan)",
+ userFilterQ: qb.Q().Space("payload->>'method' = ?", "/bytebase.v1.SQLService/Query"),
+ cutoff: &sevenDaysAgo,
+ wantSQLPattern: []string{
+ "payload->>'method' = $1",
+ "AND",
+ "created_at >= $2",
},
description: "Should combine user filter with retention filter using AND",
},
{
- name: "Complex filter with retention",
- userFilter: &store.ListResourceFilter{
- Where: "(payload->>'method'=$1 AND payload->>'severity'=$2)",
- Args: []any{"/bytebase.v1.SQLService/Query", "ERROR"},
- },
- cutoff: &sevenDaysAgo,
- wantFilter: &store.ListResourceFilter{
- Where: "((payload->>'method'=$1 AND payload->>'severity'=$2)) AND (created_at >= $3)",
- Args: []any{"/bytebase.v1.SQLService/Query", "ERROR", sevenDaysAgo},
+ name: "Complex filter with retention",
+ userFilterQ: qb.Q().Space("payload->>'method' = ?", "/bytebase.v1.SQLService/Query").And("payload->>'severity' = ?", "ERROR"),
+ cutoff: &sevenDaysAgo,
+ wantSQLPattern: []string{
+ "payload->>'method' = $1",
+ "AND",
+ "payload->>'severity' = $2",
+ "AND",
+ "created_at >= $3",
},
description: "Should handle complex filters with multiple conditions",
},
@@ -76,22 +68,30 @@ func TestApplyRetentionFilter(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- got := s.applyRetentionFilter(tt.userFilter, tt.cutoff)
+ got := applyRetentionFilter(tt.userFilterQ, tt.cutoff)
require.NotNil(t, got, tt.description)
- assert.Equal(t, tt.wantFilter.Where, got.Where, "WHERE clause should match")
- assert.Equal(t, len(tt.wantFilter.Args), len(got.Args), "Number of args should match")
-
- // For time comparisons, we just check the type and rough equality
- for i, arg := range tt.wantFilter.Args {
- if timeArg, ok := arg.(time.Time); ok {
- gotTimeArg, ok := got.Args[i].(time.Time)
- require.True(t, ok, "Argument %d should be a time.Time", i)
- assert.WithinDuration(t, timeArg, gotTimeArg, time.Second, "Time arguments should be within 1 second")
- } else {
- assert.Equal(t, arg, got.Args[i], "Argument %d should match", i)
+
+ sql, args, err := got.ToSQL()
+ require.NoError(t, err)
+
+ // Check that all expected patterns are in the SQL
+ for _, pattern := range tt.wantSQLPattern {
+ assert.Contains(t, sql, pattern, "SQL should contain expected pattern: %s", pattern)
+ }
+
+ // For time comparisons in args, we just check the type
+ hasTimeArg := false
+ for _, arg := range args {
+ if _, ok := arg.(time.Time); ok {
+ hasTimeArg = true
+ break
}
}
+
+ if tt.cutoff != nil {
+ assert.True(t, hasTimeArg, "Should have time argument when cutoff is set")
+ }
})
}
}
diff --git a/backend/store/audit_log.go b/backend/store/audit_log.go
index cf1afb5262..3a172aba2b 100644
--- a/backend/store/audit_log.go
+++ b/backend/store/audit_log.go
@@ -6,9 +6,11 @@ import (
"strings"
"time"
- "google.golang.org/protobuf/encoding/protojson"
-
+ "github.com/google/cel-go/cel"
+ celast "github.com/google/cel-go/common/ast"
+ celoperators "github.com/google/cel-go/common/operators"
"github.com/pkg/errors"
+ "google.golang.org/protobuf/encoding/protojson"
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/qb"
@@ -32,7 +34,7 @@ type AuditLog struct {
type AuditLogFind struct {
Project *string
- Filter *ListResourceFilter
+ FilterQ *qb.Query
Limit *int
Offset *int
OrderByKeys []OrderByKey
@@ -66,9 +68,8 @@ func (s *Store) SearchAuditLogs(ctx context.Context, find *AuditLogFind) ([]*Aud
WHERE TRUE
`)
- if v := find.Filter; v != nil {
- // Convert $1, $2, etc. to ? for qb
- q.And(ConvertDollarPlaceholders(v.Where), v.Args...)
+ if filterQ := find.FilterQ; filterQ != nil {
+ q.And("?", filterQ)
}
if v := find.Project; v != nil {
q.And("payload->>'parent' = ?", *v)
@@ -129,3 +130,107 @@ func (s *Store) SearchAuditLogs(ctx context.Context, find *AuditLogFind) ([]*Aud
return logs, nil
}
+
+func GetSearchAuditLogsFilter(ctx context.Context, s *Store, filter string) (*qb.Query, error) {
+ if filter == "" {
+ return nil, nil
+ }
+
+ e, err := cel.NewEnv()
+ if err != nil {
+ return nil, errors.New("failed to create cel env")
+ }
+ ast, iss := e.Parse(filter)
+ if iss != nil {
+ return nil, errors.Errorf("failed to parse filter %v, error: %v", filter, iss.String())
+ }
+
+ var getFilter func(expr celast.Expr) (*qb.Query, error)
+
+ getFilter = func(expr celast.Expr) (*qb.Query, error) {
+ q := qb.Q()
+ switch expr.Kind() {
+ case celast.CallKind:
+ functionName := expr.AsCall().FunctionName()
+ switch functionName {
+ case celoperators.LogicalOr:
+ for _, arg := range expr.AsCall().Args() {
+ qq, err := getFilter(arg)
+ if err != nil {
+ return nil, err
+ }
+ q.Or("?", qq)
+ }
+ return qb.Q().Space("(?)", q), nil
+ case celoperators.LogicalAnd:
+ for _, arg := range expr.AsCall().Args() {
+ qq, err := getFilter(arg)
+ if err != nil {
+ return nil, err
+ }
+ q.And("?", qq)
+ }
+ return qb.Q().Space("(?)", q), nil
+ case celoperators.Equals:
+ variable, rawValue := getVariableAndValueFromExpr(expr)
+ value, ok := rawValue.(string)
+ if !ok {
+ return nil, errors.Errorf("expect string, got %T, hint: filter literals should be string", rawValue)
+ }
+ switch variable {
+ case "resource", "method", "user", "severity":
+ default:
+ return nil, errors.Errorf("unknown variable %s", variable)
+ }
+ if variable == "user" {
+ // Convert user email to user id.
+ // e.g. users/[email protected] -> users/101
+ email := strings.TrimPrefix(value, "users/")
+ if email == "" {
+ return nil, errors.New("invalid empty creator identifier")
+ }
+ user, err := s.GetUserByEmail(ctx, email)
+ if err != nil {
+ return nil, errors.Wrapf(err, `failed to find user "%s"`, email)
+ }
+ if user == nil {
+ return nil, errors.Errorf("cannot found user %s", email)
+ }
+ value = fmt.Sprintf("%s%d", common.UserNamePrefix, user.ID)
+ }
+ return qb.Q().Space(fmt.Sprintf("payload->>'%s' = ?", variable), value), nil
+
+ case celoperators.GreaterEquals, celoperators.LessEquals:
+ variable, rawValue := getVariableAndValueFromExpr(expr)
+ value, ok := rawValue.(string)
+ if !ok {
+ return nil, errors.Errorf("expect string, got %T, hint: filter literals should be string", rawValue)
+ }
+ if variable != "create_time" {
+ return nil, errors.Errorf(`">=" and "<=" are only supported for "create_time"`)
+ }
+
+ t, err := time.Parse(time.RFC3339, value)
+ if err != nil {
+ return nil, errors.Errorf("failed to parse time %v, error: %v", value, err)
+ }
+ if functionName == celoperators.GreaterEquals {
+ return qb.Q().Space("created_at >= ?", t), nil
+ }
+ return qb.Q().Space("created_at <= ?", t), nil
+
+ default:
+ return nil, errors.Errorf("unexpected function %v", functionName)
+ }
+
+ default:
+ return nil, errors.Errorf("unexpected expr kind %v", expr.Kind())
+ }
+ }
+
+ q, err := getFilter(ast.NativeRep().Expr())
+ if err != nil {
+ return nil, err
+ }
+ return qb.Q().Space("(?)", q), nil
+}
diff --git a/backend/store/audit_log_filter_test.go b/backend/store/audit_log_filter_test.go
new file mode 100644
index 0000000000..15b3066379
--- /dev/null
+++ b/backend/store/audit_log_filter_test.go
@@ -0,0 +1,234 @@
+package store
+
+import (
+ "context"
+ "testing"
+ "time"
+
+ "github.com/stretchr/testify/require"
+)
+
+func mustParseTime(t *testing.T, s string) time.Time {
+ t.Helper()
+ parsedTime, err := time.Parse(time.RFC3339, s)
+ require.NoError(t, err)
+ return parsedTime
+}
+
+func TestGetSearchAuditLogsFilter_WithoutUserLookup(t *testing.T) {
+ // Note: This test skips user filter tests since they require database access
+ // User filter functionality is tested in integration tests
+
+ tests := []struct {
+ name string
+ filter string
+ wantSQL string
+ wantArgs []any
+ wantErr bool
+ errContains string
+ }{
+ {
+ name: "empty filter",
+ filter: "",
+ wantSQL: "",
+ wantArgs: nil,
+ wantErr: false,
+ },
+ {
+ name: "resource filter",
+ filter: `resource == "projects/test-project"`,
+ wantSQL: "(payload->>'resource' = $1)",
+ wantArgs: []any{"projects/test-project"},
+ wantErr: false,
+ },
+ {
+ name: "method filter",
+ filter: `method == "bytebase.v1.ProjectService.GetProject"`,
+ wantSQL: "(payload->>'method' = $1)",
+ wantArgs: []any{"bytebase.v1.ProjectService.GetProject"},
+ wantErr: false,
+ },
+ {
+ name: "severity filter",
+ filter: `severity == "INFO"`,
+ wantSQL: "(payload->>'severity' = $1)",
+ wantArgs: []any{"INFO"},
+ wantErr: false,
+ },
+ {
+ name: "create_time greater than or equal",
+ filter: `create_time >= "2024-01-01T00:00:00Z"`,
+ wantSQL: "(created_at >= $1)",
+ wantArgs: []any{mustParseTime(t, "2024-01-01T00:00:00Z")},
+ wantErr: false,
+ },
+ {
+ name: "create_time less than or equal",
+ filter: `create_time <= "2024-12-31T23:59:59Z"`,
+ wantSQL: "(created_at <= $1)",
+ wantArgs: []any{mustParseTime(t, "2024-12-31T23:59:59Z")},
+ wantErr: false,
+ },
+ {
+ name: "AND condition with resource and method",
+ filter: `resource == "projects/test-project" && method == "bytebase.v1.ProjectService.GetProject"`,
+ wantSQL: "((payload->>'resource' = $1 AND payload->>'method' = $2))",
+ wantArgs: []any{"projects/test-project", "bytebase.v1.ProjectService.GetProject"},
+ wantErr: false,
+ },
+ {
+ name: "AND condition with three filters",
+ filter: `resource == "projects/test" && method == "bytebase.v1.ProjectService.GetProject" && severity == "INFO"`,
+ wantSQL: "(((payload->>'resource' = $1 AND payload->>'method' = $2) AND payload->>'severity' = $3))",
+ wantArgs: []any{"projects/test", "bytebase.v1.ProjectService.GetProject", "INFO"},
+ wantErr: false,
+ },
+ {
+ name: "OR condition with resource",
+ filter: `resource == "projects/project1" || resource == "projects/project2"`,
+ wantSQL: "((payload->>'resource' = $1 OR payload->>'resource' = $2))",
+ wantArgs: []any{"projects/project1", "projects/project2"},
+ wantErr: false,
+ },
+ {
+ name: "OR condition with severity",
+ filter: `severity == "INFO" || severity == "WARNING"`,
+ wantSQL: "((payload->>'severity' = $1 OR payload->>'severity' = $2))",
+ wantArgs: []any{"INFO", "WARNING"},
+ wantErr: false,
+ },
+ {
+ name: "complex nested AND/OR",
+ filter: `(resource == "projects/p1" || resource == "projects/p2") && severity == "INFO"`,
+ wantSQL: "(((payload->>'resource' = $1 OR payload->>'resource' = $2) AND payload->>'severity' = $3))",
+ wantArgs: []any{"projects/p1", "projects/p2", "INFO"},
+ wantErr: false,
+ },
+ {
+ name: "time range filter",
+ filter: `create_time >= "2024-01-01T00:00:00Z" && create_time <= "2024-12-31T23:59:59Z"`,
+ wantSQL: "((created_at >= $1 AND created_at <= $2))",
+ wantArgs: []any{mustParseTime(t, "2024-01-01T00:00:00Z"), mustParseTime(t, "2024-12-31T23:59:59Z")},
+ wantErr: false,
+ },
+ {
+ name: "invalid filter syntax",
+ filter: `invalid syntax {{`,
+ wantErr: true,
+ errContains: "failed to parse filter",
+ },
+ {
+ name: "unsupported variable",
+ filter: `unsupported == "value"`,
+ wantErr: true,
+ errContains: "unknown variable",
+ },
+ {
+ name: "invalid time format",
+ filter: `create_time >= "invalid-time"`,
+ wantErr: true,
+ errContains: "failed to parse time",
+ },
+ {
+ name: "time comparison on wrong field",
+ filter: `resource >= "2024-01-01T00:00:00Z"`,
+ wantErr: true,
+ errContains: `">=" and "<=" are only supported for "create_time"`,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ // Create a mock store for testing without database
+ // For tests that don't require user lookup, we use context.TODO()
+ s := &Store{}
+ q, err := GetSearchAuditLogsFilter(context.TODO(), s, tt.filter)
+
+ if tt.wantErr {
+ require.Error(t, err)
+ if tt.errContains != "" {
+ require.ErrorContains(t, err, tt.errContains)
+ }
+ return
+ }
+
+ require.NoError(t, err)
+
+ if tt.filter == "" {
+ require.Nil(t, q)
+ return
+ }
+
+ require.NotNil(t, q)
+
+ sql, args, err := q.ToSQL()
+ require.NoError(t, err)
+ require.Equal(t, tt.wantSQL, sql)
+ if tt.wantArgs != nil {
+ require.Equal(t, tt.wantArgs, args)
+ }
+ })
+ }
+}
+
+func TestGetSearchAuditLogsFilter_EdgeCases(t *testing.T) {
+ tests := []struct {
+ name string
+ filter string
+ description string
+ wantSQL string
+ wantArgs []any
+ wantErr bool
+ errContains string
+ }{
+ {
+ name: "resource with special characters",
+ filter: `resource == "projects/test-project/databases/test_db"`,
+ description: "resource with special characters should be handled correctly",
+ wantSQL: "(payload->>'resource' = $1)",
+ wantArgs: []any{"projects/test-project/databases/test_db"},
+ wantErr: false,
+ },
+ {
+ name: "multiple OR conditions",
+ filter: `severity == "INFO" || severity == "WARNING" || severity == "ERROR"`,
+ description: "multiple OR conditions should be chained",
+ wantSQL: "(((payload->>'severity' = $1 OR payload->>'severity' = $2) OR payload->>'severity' = $3))",
+ wantArgs: []any{"INFO", "WARNING", "ERROR"},
+ wantErr: false,
+ },
+ {
+ name: "complex filter with all supported fields",
+ filter: `resource == "projects/test" && method == "bytebase.v1.ProjectService.GetProject" && severity == "INFO" && create_time >= "2024-01-01T00:00:00Z"`,
+ description: "combination of all supported filter types",
+ wantSQL: "(((payload->>'resource' = $1 AND payload->>'method' = $2) AND (payload->>'severity' = $3 AND created_at >= $4)))",
+ wantArgs: []any{"projects/test", "bytebase.v1.ProjectService.GetProject", "INFO", mustParseTime(t, "2024-01-01T00:00:00Z")},
+ wantErr: false,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ s := &Store{}
+ q, err := GetSearchAuditLogsFilter(context.TODO(), s, tt.filter)
+
+ if tt.wantErr {
+ require.Error(t, err, tt.description)
+ if tt.errContains != "" {
+ require.ErrorContains(t, err, tt.errContains)
+ }
+ return
+ }
+
+ require.NoError(t, err, tt.description)
+ require.NotNil(t, q)
+
+ sql, args, err := q.ToSQL()
+ require.NoError(t, err)
+ require.Equal(t, tt.wantSQL, sql, tt.description)
+ if tt.wantArgs != nil {
+ require.Equal(t, tt.wantArgs, args, tt.description)
+ }
+ })
+ }
+}