feat(group): add user groups query-side and projection implementation (#10758)

# Which Problems Are Solved

This is the second PR related to the backend implementation of
GroupService to manage user groups.
The first [PR](https://github.com/zitadel/zitadel/pull/10455) implements
the Command-side.
This PR implements the query side. 

# How the Problems Are Solved
* Query-side implementation to search/list groups by 
    * a list of Group IDs
    * by the Group name
    * by the Organization ID

# Additional Changes
N/A

# Additional Context
- Follow-up for PR #10455

---------

Co-authored-by: Livio Spring <[email protected]>
This commit is contained in:
Gayathri Vijayan
2025-10-07 12:53:25 +00:00
committed by GitHub
co-authored by Livio Spring
parent e25b21a6a4
commit 8e766132b0
7 changed files with 1452 additions and 20 deletions
+230 -2
View File
@@ -2,11 +2,63 @@ package query
import (
"context"
"database/sql"
"errors"
"time"
sq "github.com/Masterminds/squirrel"
"github.com/zitadel/zitadel/internal/api/authz"
"github.com/zitadel/zitadel/internal/domain"
"github.com/zitadel/zitadel/internal/query/projection"
"github.com/zitadel/zitadel/internal/telemetry/tracing"
"github.com/zitadel/zitadel/internal/zerrors"
)
var (
groupsTable = table{
name: projection.GroupProjectionTable,
instanceIDCol: projection.GroupColumnInstanceID,
}
GroupColumnID = Column{
name: projection.GroupColumnID,
table: groupsTable,
}
GroupColumnName = Column{
name: projection.GroupColumnName,
table: groupsTable,
}
GroupColumnDescription = Column{
name: projection.GroupColumnDescription,
table: groupsTable,
}
GroupColumnResourceOwner = Column{
name: projection.GroupColumnResourceOwner,
table: groupsTable,
}
GroupColumnCreationDate = Column{
name: projection.GroupColumnCreationDate,
table: groupsTable,
}
GroupColumnChangeDate = Column{
name: projection.GroupColumnChangeDate,
table: groupsTable,
}
GroupColumnInstanceID = Column{
name: projection.GroupColumnInstanceID,
table: groupsTable,
}
GroupColumnSequence = Column{
name: projection.GroupColumnSequence,
table: groupsTable,
}
GroupColumnState = Column{
name: projection.GroupColumnState,
table: groupsTable,
}
)
type Groups struct {
SearchResponse
Groups []*Group
@@ -19,9 +71,185 @@ type Group struct {
CreationDate time.Time
ChangeDate time.Time
ResourceOwner string
InstanceID string
State domain.GroupState
Sequence uint64
}
type GroupSearchQuery struct {
SearchRequest
Queries []SearchQuery
}
func (q *Queries) GetGroupByID(ctx context.Context, id string) (group *Group, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
// todo: add permission check
stmt, scan := prepareGroupQuery()
eq := sq.Eq{
GroupColumnID.identifier(): id,
GroupColumnInstanceID.identifier(): authz.GetInstance(ctx).InstanceID(),
}
query, args, err := stmt.Where(eq).ToSql()
if err != nil {
return nil, zerrors.ThrowInternal(err, "QUERY-8bde1", "Errors.Query.SQLStatement")
}
err = q.client.QueryRowContext(ctx, func(row *sql.Row) error {
group, err = scan(row)
return err
}, query, args...)
return group, err
}
// SearchGroups returns the list of groups that match the search criteria
func (q *Queries) SearchGroups(ctx context.Context) (*Groups, error) {
return nil, zerrors.ThrowUnimplemented(nil, "QUERY-grpfli", "Not implemented")
func (q *Queries) SearchGroups(ctx context.Context, queries *GroupSearchQuery) (_ *Groups, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
// todo: add permission check
groups, err := q.searchGroups(ctx, queries)
if err != nil {
return nil, err
}
return groups, nil
}
func NewGroupNameSearchQuery(value string, comparison TextComparison) (SearchQuery, error) {
return NewTextQuery(GroupColumnName, value, comparison)
}
func NewGroupIDsSearchQuery(ids []string) (SearchQuery, error) {
list := make([]interface{}, len(ids))
for i, value := range ids {
list[i] = value
}
return NewListQuery(GroupColumnID, list, ListIn)
}
func NewGroupOrganizationIdSearchQuery(id string) (SearchQuery, error) {
return NewTextQuery(GroupColumnResourceOwner, id, TextEquals)
}
func prepareGroupQuery() (sq.SelectBuilder, func(*sql.Row) (*Group, error)) {
return sq.Select(
GroupColumnID.identifier(),
GroupColumnName.identifier(),
GroupColumnDescription.identifier(),
GroupColumnCreationDate.identifier(),
GroupColumnChangeDate.identifier(),
GroupColumnResourceOwner.identifier(),
GroupColumnInstanceID.identifier(),
GroupColumnSequence.identifier(),
GroupColumnState.identifier()).
From(groupsTable.identifier()).
PlaceholderFormat(sq.Dollar),
func(row *sql.Row) (*Group, error) {
group := new(Group)
err := row.Scan(
&group.ID,
&group.Name,
&group.Description,
&group.CreationDate,
&group.ChangeDate,
&group.ResourceOwner,
&group.InstanceID,
&group.Sequence,
&group.State,
)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, zerrors.ThrowNotFound(err, "QUERY-SG4WbR", "Errors.Group.NotFound")
}
return nil, zerrors.ThrowInternal(err, "QUERY-6yHJEz", "Errors.Internal")
}
return group, nil
}
}
func (q *Queries) searchGroups(ctx context.Context, queries *GroupSearchQuery) (groups *Groups, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
query, scan := prepareGroupsQuery()
eq := sq.And{
sq.Eq{
GroupColumnInstanceID.identifier(): authz.GetInstance(ctx).InstanceID(),
},
}
stmt, args, err := queries.toQuery(query).Where(eq).ToSql()
if err != nil {
return nil, zerrors.ThrowInvalidArgument(err, "QUERY-FpBnrv", "Errors.Query.InvalidRequest")
}
err = q.client.QueryContext(ctx, func(rows *sql.Rows) error {
groups, err = scan(rows)
return err
}, stmt, args...)
if err != nil {
return nil, zerrors.ThrowInternal(err, "QUERY-vnQf5N", "Errors.Internal")
}
groups.State, err = q.latestState(ctx, groupsTable)
return groups, err
}
func prepareGroupsQuery() (sq.SelectBuilder, func(*sql.Rows) (*Groups, error)) {
return sq.Select(
GroupColumnID.identifier(),
GroupColumnName.identifier(),
GroupColumnDescription.identifier(),
GroupColumnCreationDate.identifier(),
GroupColumnChangeDate.identifier(),
GroupColumnResourceOwner.identifier(),
GroupColumnInstanceID.identifier(),
GroupColumnSequence.identifier(),
GroupColumnState.identifier(),
countColumn.identifier()).
From(groupsTable.identifier()).
PlaceholderFormat(sq.Dollar),
func(rows *sql.Rows) (*Groups, error) {
groups := make([]*Group, 0)
var count uint64
for rows.Next() {
group := new(Group)
err := rows.Scan(
&group.ID,
&group.Name,
&group.Description,
&group.CreationDate,
&group.ChangeDate,
&group.ResourceOwner,
&group.InstanceID,
&group.Sequence,
&group.State,
&count,
)
if err != nil {
return nil, err
}
groups = append(groups, group)
}
if err := rows.Close(); err != nil {
return nil, zerrors.ThrowInternal(err, "QUERY-ndNVod", "Errors.Query.CloseRows")
}
return &Groups{
Groups: groups,
SearchResponse: SearchResponse{
Count: count,
},
}, nil
}
}
func (q *GroupSearchQuery) toQuery(query sq.SelectBuilder) sq.SelectBuilder {
query = q.SearchRequest.toQuery(query)
for _, q := range q.Queries {
query = q.toQuery(query)
}
return query
}
+305
View File
@@ -0,0 +1,305 @@
package query
import (
"database/sql"
"database/sql/driver"
"errors"
"fmt"
"regexp"
"testing"
"github.com/zitadel/zitadel/internal/domain"
"github.com/zitadel/zitadel/internal/zerrors"
)
var (
prepareGroupsStmt = `SELECT projections.groups1.id,` +
` projections.groups1.name,` +
` projections.groups1.description,` +
` projections.groups1.creation_date,` +
` projections.groups1.change_date,` +
` projections.groups1.resource_owner,` +
` projections.groups1.instance_id,` +
` projections.groups1.sequence,` +
` projections.groups1.state,` +
` COUNT(*) OVER ()` +
` FROM projections.groups1`
prepareGroupsColumns = []string{
"id",
"name",
"description",
"creation_date",
"change_date",
"resource_owner",
"instance_id",
"sequence",
"state",
"count",
}
prepareGroupStmt = `SELECT projections.groups1.id,` +
` projections.groups1.name,` +
` projections.groups1.description,` +
` projections.groups1.creation_date,` +
` projections.groups1.change_date,` +
` projections.groups1.resource_owner,` +
` projections.groups1.instance_id,` +
` projections.groups1.sequence,` +
` projections.groups1.state` +
` FROM projections.groups1`
prepareGroupColumns = []string{
"id",
"name",
"description",
"creation_date",
"change_date",
"resource_owner",
"instance_id",
"sequence",
"state",
}
)
func Test_GroupPrepares(t *testing.T) {
type want struct {
sqlExpectations sqlExpectation
err checkErr
}
tests := []struct {
name string
prepare interface{}
want want
object interface{}
}{
{
name: "prepareGroupsQuery, no result",
prepare: prepareGroupsQuery,
want: want{
sqlExpectations: mockQueries(
regexp.QuoteMeta(prepareGroupsStmt),
nil,
nil,
),
},
object: &Groups{Groups: []*Group{}},
},
{
name: "prepareGroupsQuery, one result",
prepare: prepareGroupsQuery,
want: want{
sqlExpectations: mockQueries(
regexp.QuoteMeta(prepareGroupsStmt),
prepareGroupsColumns,
[][]driver.Value{
{
"9090",
"group1",
"my new group",
testNow,
testNow,
"org1",
"instance1",
1,
domain.GroupStateActive,
},
},
),
},
object: &Groups{
SearchResponse: SearchResponse{
Count: 1,
},
Groups: []*Group{
{
ID: "9090",
Name: "group1",
Description: "my new group",
CreationDate: testNow,
ChangeDate: testNow,
ResourceOwner: "org1",
InstanceID: "instance1",
Sequence: 1,
State: domain.GroupStateActive,
},
},
},
},
{
name: "prepareGroupsQuery, multiple results",
prepare: prepareGroupsQuery,
want: want{
sqlExpectations: mockQueries(
regexp.QuoteMeta(prepareGroupsStmt),
prepareGroupsColumns,
[][]driver.Value{
{
"9091",
"group1",
"my first group",
testNow,
testNow,
"org1",
"instance1",
1,
domain.GroupStateActive,
},
{
"9092",
"group2",
"my second group",
testNow,
testNow,
"org1",
"instance1",
1,
domain.GroupStateActive,
},
},
),
},
object: &Groups{
SearchResponse: SearchResponse{
Count: 2,
},
Groups: []*Group{
{
ID: "9091",
Name: "group1",
Description: "my first group",
CreationDate: testNow,
ChangeDate: testNow,
ResourceOwner: "org1",
InstanceID: "instance1",
Sequence: 1,
State: domain.GroupStateActive,
},
{
ID: "9092",
Name: "group2",
Description: "my second group",
CreationDate: testNow,
ChangeDate: testNow,
ResourceOwner: "org1",
InstanceID: "instance1",
Sequence: 1,
State: domain.GroupStateActive,
},
},
},
},
{
name: "prepareGroupsQuery, sql err",
prepare: prepareGroupsQuery,
want: want{
sqlExpectations: mockQueryErr(
regexp.QuoteMeta(prepareGroupsStmt),
sql.ErrConnDone,
),
err: func(err error) (error, bool) {
if !errors.Is(err, sql.ErrConnDone) {
return fmt.Errorf("err should be sql.ErrConnDone got: %w", err), false
}
return nil, true
},
},
object: (*Groups)(nil),
},
{
name: "prepareGroupsQuery, no result",
prepare: prepareGroupsQuery,
want: want{
sqlExpectations: mockQueriesScanErr(
regexp.QuoteMeta(prepareGroupsStmt),
nil,
nil,
),
err: func(err error) (error, bool) {
if !zerrors.IsNotFound(err) {
return fmt.Errorf("err should be zitadel.NotFoundError got: %w", err), false
}
return nil, true
},
},
object: &Groups{
SearchResponse: SearchResponse{
Count: 0,
},
Groups: []*Group{},
},
},
{
name: "prepareGroupQuery, no result",
prepare: prepareGroupQuery,
want: want{
sqlExpectations: mockQueriesScanErr(
prepareGroupStmt,
nil,
nil,
),
err: func(err error) (error, bool) {
if !zerrors.IsNotFound(err) {
return fmt.Errorf("err should be zitadel.NotFoundError got: %w", err), false
}
return nil, true
},
},
object: (*Group)(nil),
},
{
name: "prepareGroupQuery, sql err",
prepare: prepareGroupQuery,
want: want{
sqlExpectations: mockQueryErr(
regexp.QuoteMeta(prepareGroupStmt),
sql.ErrConnDone,
),
err: func(err error) (error, bool) {
if !errors.Is(err, sql.ErrConnDone) {
return fmt.Errorf("err should be sql.ErrConnDone got: %w", err), false
}
return nil, true
},
},
object: (*Group)(nil),
},
{
name: "prepareGroupQuery, found",
prepare: prepareGroupQuery,
want: want{
sqlExpectations: mockQuery(
regexp.QuoteMeta(prepareGroupStmt),
prepareGroupColumns,
[]driver.Value{
"9090",
"group1",
"my new group",
testNow,
testNow,
"org1",
"instance1",
1,
domain.GroupStateActive,
},
),
},
object: &Group{
ID: "9090",
Name: "group1",
Description: "my new group",
CreationDate: testNow,
ChangeDate: testNow,
ResourceOwner: "org1",
InstanceID: "instance1",
Sequence: 1,
State: domain.GroupStateActive,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
assertPrepare(t, tt.prepare, tt.object, tt.want.sqlExpectations, tt.want.err)
})
}
}
+179
View File
@@ -0,0 +1,179 @@
package projection
import (
"context"
"github.com/zitadel/zitadel/internal/domain"
"github.com/zitadel/zitadel/internal/eventstore"
old_handler "github.com/zitadel/zitadel/internal/eventstore/handler"
"github.com/zitadel/zitadel/internal/eventstore/handler/v2"
"github.com/zitadel/zitadel/internal/repository/group"
"github.com/zitadel/zitadel/internal/repository/instance"
"github.com/zitadel/zitadel/internal/repository/org"
)
const (
GroupProjectionTable = "projections.groups1"
GroupColumnID = "id"
GroupColumnName = "name"
GroupColumnResourceOwner = "resource_owner"
GroupColumnInstanceID = "instance_id"
GroupColumnCreationDate = "creation_date"
GroupColumnChangeDate = "change_date"
GroupColumnSequence = "sequence"
GroupColumnState = "state"
GroupColumnDescription = "description"
)
type groupProjection struct{}
func (g *groupProjection) Name() string {
return GroupProjectionTable
}
func newGroupProjection(ctx context.Context, config handler.Config) *handler.Handler {
return handler.NewHandler(ctx, &config, new(groupProjection))
}
func (g *groupProjection) Init() *old_handler.Check {
return handler.NewTableCheck(
handler.NewTable([]*handler.InitColumn{
handler.NewColumn(GroupColumnID, handler.ColumnTypeText),
handler.NewColumn(GroupColumnName, handler.ColumnTypeText),
handler.NewColumn(GroupColumnResourceOwner, handler.ColumnTypeText),
handler.NewColumn(GroupColumnInstanceID, handler.ColumnTypeText),
handler.NewColumn(GroupColumnDescription, handler.ColumnTypeText),
handler.NewColumn(GroupColumnCreationDate, handler.ColumnTypeTimestamp),
handler.NewColumn(GroupColumnChangeDate, handler.ColumnTypeTimestamp),
handler.NewColumn(GroupColumnSequence, handler.ColumnTypeInt64),
handler.NewColumn(GroupColumnState, handler.ColumnTypeEnum),
},
handler.NewPrimaryKey(GroupColumnInstanceID, GroupColumnID),
handler.WithIndex(handler.NewIndex("resource_owner", []string{GroupColumnResourceOwner})),
),
)
}
func (g *groupProjection) Reducers() []handler.AggregateReducer {
return []handler.AggregateReducer{
{
Aggregate: group.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: group.GroupAddedEventType,
Reduce: g.reduceGroupAdded,
},
{
Event: group.GroupChangedEventType,
Reduce: g.reduceGroupChanged,
},
{
Event: group.GroupRemovedEventType,
Reduce: g.reduceGroupRemoved,
},
},
},
{
Aggregate: group.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: org.OrgRemovedEventType,
Reduce: g.reduceOwnerRemoved,
},
},
},
{
Aggregate: instance.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: instance.InstanceRemovedEventType,
Reduce: reduceInstanceRemovedHelper(GroupColumnInstanceID),
},
},
},
}
}
func (g *groupProjection) reduceGroupAdded(event eventstore.Event) (*handler.Statement, error) {
e, err := assertEvent[*group.GroupAddedEvent](event)
if err != nil {
return nil, err
}
return handler.NewCreateStatement(
e,
[]handler.Column{
handler.NewCol(GroupColumnID, e.Aggregate().ID),
handler.NewCol(GroupColumnName, e.Name),
handler.NewCol(GroupColumnResourceOwner, e.Aggregate().ResourceOwner),
handler.NewCol(GroupColumnInstanceID, e.Aggregate().InstanceID),
handler.NewCol(GroupColumnDescription, e.Description),
handler.NewCol(GroupColumnCreationDate, e.CreationDate()),
handler.NewCol(GroupColumnChangeDate, e.CreationDate()),
handler.NewCol(GroupColumnSequence, e.Sequence()),
handler.NewCol(GroupColumnState, domain.GroupStateActive),
},
), nil
}
func (g *groupProjection) reduceGroupChanged(event eventstore.Event) (*handler.Statement, error) {
e, err := assertEvent[*group.GroupChangedEvent](event)
if err != nil {
return nil, err
}
columns := make([]handler.Column, 0, 4)
if e.Name != nil {
columns = append(columns, handler.NewCol(GroupColumnName, *e.Name))
}
if e.Description != nil {
columns = append(columns, handler.NewCol(GroupColumnDescription, *e.Description))
}
if len(columns) == 0 {
return handler.NewNoOpStatement(e), nil
}
columns = append(
columns,
handler.NewCol(GroupColumnChangeDate, e.CreationDate()),
handler.NewCol(GroupColumnSequence, e.Sequence()),
)
return handler.NewUpdateStatement(
e,
columns,
[]handler.Condition{
handler.NewCond(GroupColumnID, e.Aggregate().ID),
handler.NewCond(GroupColumnInstanceID, e.Aggregate().InstanceID),
},
), nil
}
func (g *groupProjection) reduceGroupRemoved(event eventstore.Event) (*handler.Statement, error) {
e, err := assertEvent[*group.GroupRemovedEvent](event)
if err != nil {
return nil, err
}
return handler.NewDeleteStatement(
e,
[]handler.Condition{
handler.NewCond(GroupColumnID, e.Aggregate().ID),
handler.NewCond(GroupColumnInstanceID, e.Aggregate().InstanceID),
},
), nil
}
func (g *groupProjection) reduceOwnerRemoved(event eventstore.Event) (*handler.Statement, error) {
e, err := assertEvent[*org.OrgRemovedEvent](event)
if err != nil {
return nil, err
}
return handler.NewDeleteStatement(
e,
[]handler.Condition{
handler.NewCond(GroupColumnInstanceID, e.Aggregate().InstanceID),
handler.NewCond(GroupColumnResourceOwner, e.Aggregate().ID),
},
), nil
}
+5
View File
@@ -102,6 +102,8 @@ var (
InstanceDomainFields *handler.FieldHandler
MembershipFields *handler.FieldHandler
PermissionFields *handler.FieldHandler
GroupProjection *handler.Handler
)
type projection interface {
@@ -207,6 +209,8 @@ func Create(ctx context.Context, sqlClient *database.DB, es handler.EventStore,
PermissionFields = newFillPermissionFields(applyCustomConfig(projectionConfig, config.Customizations[fieldsPermission]))
// Don't forget to add the new field handler to [ProjectInstanceFields]
GroupProjection = newGroupProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["groups"]))
InstanceRelationalProjection = newInstanceRelationalProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["instances_relational"]))
OrganizationRelationalProjection = newOrgRelationalProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["organizations_relational"]))
InstanceDomainRelationalProjection = newInstanceDomainRelationalProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["instance_domains_relational"]))
@@ -396,6 +400,7 @@ func newProjectionsList() {
DebugEventsProjection,
HostedLoginTranslationProjection,
OrganizationSettingsProjection,
GroupProjection,
InstanceRelationalProjection,
OrganizationRelationalProjection,