Skip to content

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

refactor(qb): user group filter (#17857)

p0nye417d7bae034
diff --git a/backend/api/v1/group_service.go b/backend/api/v1/group_service.go
index 67fd2291db..aa3bddaa35 100644
--- a/backend/api/v1/group_service.go
+++ b/backend/api/v1/group_service.go
@@ -2,15 +2,9 @@ package v1
import (
"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.Requ
return 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 = filterQ
groups, err := s.store.ListGroups(ctx, find)
if err != nil {
diff --git a/backend/store/group.go b/backend/store/group.go
index 0f6aedb8e6..85537deb7a 100644
--- a/backend/store/group.go
+++ b/backend/store/group.go
@@ -3,7 +3,12 @@ package store
import (
"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 *string
ProjectID *string
- Filter *ListResourceFilter
+ FilterQ *qb.Query
Limit *int
Offset *int
@@ -109,8 +114,8 @@ func (*Store) listGroupImpl(ctx context.Context, txn *sql.Tx, find *FindGroupMes
from.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.go
new file mode 100644
index 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)
+}