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(qb): user group filter (#17857)
p0nye417d7bae034
diff --git a/backend/api/v1/group_service.go b/backend/api/v1/group_service.goindex 67fd2291db..aa3bddaa35 100644--- a/backend/api/v1/group_service.go+++ b/backend/api/v1/group_service.go@@ -2,15 +2,9 @@ package v1import ("context"- "fmt""log/slog"- "strings""connectrpc.com/connect"- "github.com/google/cel-go/cel"- celast "github.com/google/cel-go/common/ast"- celoperators "github.com/google/cel-go/common/operators"- celoverloads "github.com/google/cel-go/common/overloads""github.com/pkg/errors""google.golang.org/protobuf/types/known/emptypb"@@ -74,98 +68,6 @@ func (s *GroupService) BatchGetGroups(ctx context.Context, request *connect.Requreturn connect.NewResponse(response), nil}-func parseListGroupFilter(find *store.FindGroupMessage, filter string) error {- if filter == "" {- return nil- }- e, err := cel.NewEnv()- if err != nil {- return connect.NewError(connect.CodeInternal, errors.New("failed to create cel env"))- }- ast, iss := e.Parse(filter)- if iss != nil {- return 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-- parseToSQL := func(variable, value any) (string, error) {- switch variable {- case "title":- positionalArgs = append(positionalArgs, value.(string))- return fmt.Sprintf("name = $%d", len(positionalArgs)), nil- case "email":- positionalArgs = append(positionalArgs, value.(string))- return fmt.Sprintf("email = $%d", len(positionalArgs)), nil- case "project":- projectID, err := common.GetProjectID(value.(string))- if err != nil {- return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid project filter %q", value))- }- find.ProjectID = &projectID- return "TRUE", nil- default:- return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unsupport variable %q", variable))- }- }-- 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, value := getVariableAndValueFromExpr(expr)- return parseToSQL(variable, value)- case celoverloads.Matches:- variable := expr.AsCall().Target().AsIdent()- args := expr.AsCall().Args()- if len(args) != 1 {- return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf(`invalid args for %q`, variable))- }- value := args[0].AsLiteral().Value()- strValue, ok := value.(string)- if !ok {- return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("expect string, got %T, hint: filter literals should be string", value))- }- if strValue == "" {- return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf(`empty value for %q`, variable))- }-- switch variable {- case "title":- return "LOWER(name) LIKE '%" + strings.ToLower(strValue) + "%'", nil- case "email":- return "LOWER(email) LIKE '%" + strings.ToLower(strValue) + "%'", nil- default:- return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unsupport variable %q", variable))- }- default:- return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unexpected function %v", functionName))- }- default:- return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unexpected expr kind %v", expr.Kind()))- }- }-- where, err := getFilter(ast.NativeRep().Expr())- if err != nil {- return err- }-- find.Filter = &store.ListResourceFilter{- Args: positionalArgs,- Where: "(" + where + ")",- }-- return nil-}-// ListGroups lists all groups.func (s *GroupService) ListGroups(ctx context.Context, request *connect.Request[v1pb.ListGroupsRequest]) (*connect.Response[v1pb.ListGroupsResponse], error) {offset, err := parseLimitAndOffset(&pageSize{@@ -182,9 +84,11 @@ func (s *GroupService) ListGroups(ctx context.Context, request *connect.Request[Limit: &limitPlusOne,Offset: &offset.offset,}- if err := parseListGroupFilter(find, request.Msg.Filter); err != nil {- return nil, err+ filterQ, err := store.GetListGroupFilter(find, request.Msg.Filter)+ if err != nil {+ return nil, connect.NewError(connect.CodeInvalidArgument, err)}+ find.FilterQ = filterQgroups, err := s.store.ListGroups(ctx, find)if err != nil {diff --git a/backend/store/group.go b/backend/store/group.goindex 0f6aedb8e6..85537deb7a 100644--- a/backend/store/group.go+++ b/backend/store/group.go@@ -3,7 +3,12 @@ package storeimport ("context""database/sql"+ "strings"+ "github.com/google/cel-go/cel"+ celast "github.com/google/cel-go/common/ast"+ celoperators "github.com/google/cel-go/common/operators"+ celoverloads "github.com/google/cel-go/common/overloads""github.com/pkg/errors""google.golang.org/protobuf/encoding/protojson"@@ -16,7 +21,7 @@ import (type FindGroupMessage struct {Email *stringProjectID *string- Filter *ListResourceFilter+ FilterQ *qb.QueryLimit *intOffset *int@@ -109,8 +114,8 @@ func (*Store) listGroupImpl(ctx context.Context, txn *sql.Tx, find *FindGroupMesfrom.Space(`INNER JOIN project_members ON (CONCAT('groups/', user_group.email) = ANY(project_members.members) OR ? = ANY(project_members.members))`, common.AllUsers)}- if filter := find.Filter; filter != nil {- where.And(ConvertDollarPlaceholders(filter.Where), filter.Args...)+ if filterQ := find.FilterQ; filterQ != nil {+ where.And("?", filterQ)}if v := find.Email; v != nil {where.And("email = ?", *v)@@ -309,3 +314,102 @@ func (s *Store) DeleteGroup(ctx context.Context, email string) error {s.groupCache.Remove(email)return nil}++func GetListGroupFilter(find *FindGroupMessage, 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)++ parseToSQL := func(variable, value any) (*qb.Query, error) {+ switch variable {+ case "title":+ return qb.Q().Space("name = ?", value.(string)), nil+ case "email":+ return qb.Q().Space("email = ?", value.(string)), nil+ case "project":+ projectID, err := common.GetProjectID(value.(string))+ if err != nil {+ return nil, errors.Errorf("invalid project filter %q", value)+ }+ find.ProjectID = &projectID+ return qb.Q().Space("TRUE"), nil+ default:+ return nil, errors.Errorf("unsupport variable %q", variable)+ }+ }++ 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, value := getVariableAndValueFromExpr(expr)+ return parseToSQL(variable, value)+ case celoverloads.Matches:+ variable := expr.AsCall().Target().AsIdent()+ args := expr.AsCall().Args()+ if len(args) != 1 {+ return nil, errors.Errorf(`invalid args for %q`, variable)+ }+ value := args[0].AsLiteral().Value()+ strValue, ok := value.(string)+ if !ok {+ return nil, errors.Errorf("expect string, got %T, hint: filter literals should be string", value)+ }+ if strValue == "" {+ return nil, errors.Errorf(`empty value for %q`, variable)+ }++ switch variable {+ case "title":+ return qb.Q().Space("LOWER(name) LIKE ?", "%"+strings.ToLower(strValue)+"%"), nil+ case "email":+ return qb.Q().Space("LOWER(email) LIKE ?", "%"+strings.ToLower(strValue)+"%"), nil+ default:+ return nil, errors.Errorf("unsupport variable %q", variable)+ }+ 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/group_filter_test.go b/backend/store/group_filter_test.gonew file mode 100644index 0000000000..f2bc4d7845--- /dev/null+++ b/backend/store/group_filter_test.go@@ -0,0 +1,138 @@+package store++import (+ "testing"++ "github.com/stretchr/testify/require"+)++func TestGetListGroupFilter(t *testing.T) {+ tests := []struct {+ name string+ filter string+ wantSQL string+ wantArgs []any+ wantErr bool+ errContains string+ }{+ {+ name: "empty filter",+ filter: "",+ wantSQL: "",+ wantArgs: nil,+ wantErr: false,+ },+ {+ name: "title filter",+ filter: `title == "Developers"`,+ wantSQL: "(name = $1)",+ wantArgs: []any{"Developers"},+ wantErr: false,+ },+ {+ name: "email filter",+ filter: `email == "[email protected]"`,+ wantSQL: "(email = $1)",+ wantArgs: []any{"[email protected]"},+ wantErr: false,+ },+ {+ name: "title matches",+ filter: `title.matches("dev")`,+ wantSQL: "(LOWER(name) LIKE $1)",+ wantArgs: []any{"%dev%"},+ wantErr: false,+ },+ {+ name: "email matches",+ filter: `email.matches("example")`,+ wantSQL: "(LOWER(email) LIKE $1)",+ wantArgs: []any{"%example%"},+ wantErr: false,+ },+ {+ name: "AND condition with title and email",+ filter: `title == "Developers" && email == "[email protected]"`,+ wantSQL: "((name = $1 AND email = $2))",+ wantArgs: []any{"Developers", "[email protected]"},+ wantErr: false,+ },+ {+ name: "OR condition with title",+ filter: `title == "Developers" || title == "Admins"`,+ wantSQL: "((name = $1 OR name = $2))",+ wantArgs: []any{"Developers", "Admins"},+ wantErr: false,+ },+ {+ name: "complex nested AND/OR",+ filter: `(title == "Developers" || title == "Admins") && email.matches("example")`,+ wantSQL: "(((name = $1 OR name = $2) AND LOWER(email) LIKE $3))",+ wantArgs: []any{"Developers", "Admins", "%example%"},+ 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: "unsupport variable",+ },+ {+ name: "empty matches value",+ filter: `title.matches("")`,+ wantErr: true,+ errContains: "empty value",+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ find := &FindGroupMessage{}+ q, err := GetListGroupFilter(find, 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)+ require.Equal(t, tt.wantArgs, args)+ })+ }+}++func TestGetListGroupFilterProject(t *testing.T) {+ // Test project filter separately since it modifies the find struct+ find := &FindGroupMessage{}+ q, err := GetListGroupFilter(find, `project == "projects/test-project"`)++ require.NoError(t, err)+ require.NotNil(t, q)++ sql, args, err := q.ToSQL()+ require.NoError(t, err)+ require.Equal(t, "(TRUE)", sql)+ require.Empty(t, args)+ require.NotNil(t, find.ProjectID)+ require.Equal(t, "test-project", *find.ProjectID)+}