Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
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.goindex 118961a56a..8f3d293923 100644--- a/backend/api/v1/audit_log_service.go+++ b/backend/api/v1/audit_log_service.go@@ -3,18 +3,14 @@ package v1import ("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 planretentionCutoff := 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 stringif 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.goindex 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.goindex 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.QueryLimit *intOffset *intOrderByKeys []OrderByKey@@ -66,9 +68,8 @@ func (s *Store) SearchAuditLogs(ctx context.Context, find *AuditLogFind) ([]*AudWHERE 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) ([]*Audreturn 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.gonew file mode 100644index 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)+ }+ })+ }+}