feat: org queries (#136)

* search orgs

* org by domain

* member spooler

* member

* get roles

* tests

* types duration

* use default func for renew

* correct database

* reorder migrations

* delete unused consts

* move get roles to internal

* use prepared org by domain

* implement org in other objects

* add eventstores

internal/management/repository/eventsourcing/eventstore/org.go

@@ -2,14 +2,20 @@ package eventstore
 
 import (
 	"context"
+	"strings"
 
 	"github.com/caos/zitadel/internal/errors"
+	mgmt_view "github.com/caos/zitadel/internal/management/repository/eventsourcing/view"
 	org_model "github.com/caos/zitadel/internal/org/model"
 	org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
+	"github.com/caos/zitadel/internal/org/repository/view"
 )
 
 type OrgRepository struct {
+	SearchLimit uint64
 	*org_es.OrgEventstore
+	View  *mgmt_view.View
+	Roles []string
 }
 
 func (repo *OrgRepository) OrgByID(ctx context.Context, id string) (*org_model.Org, error) {
@@ -17,8 +23,12 @@ func (repo *OrgRepository) OrgByID(ctx context.Context, id string) (*org_model.O
 	return repo.OrgEventstore.OrgByID(ctx, org)
 }
 
-func (repo *OrgRepository) OrgByDomainGlobal(ctx context.Context, domain string) (*org_model.Org, error) {
-	return nil, errors.ThrowUnimplemented(nil, "EVENT-GQoS8", "not implemented")
+func (repo *OrgRepository) OrgByDomainGlobal(ctx context.Context, domain string) (*org_model.OrgView, error) {
+	org, err := repo.View.OrgByDomain(domain)
+	if err != nil {
+		return nil, err
+	}
+	return view.OrgToModel(org), nil
 }
 
 func (repo *OrgRepository) UpdateOrg(ctx context.Context, org *org_model.Org) (*org_model.Org, error) {
@@ -50,3 +60,27 @@ func (repo *OrgRepository) RemoveOrgMember(ctx context.Context, orgID, userID st
 	member := org_model.NewOrgMember(orgID, userID)
 	return repo.OrgEventstore.RemoveOrgMember(ctx, member)
 }
+
+func (repo *OrgRepository) SearchOrgMembers(ctx context.Context, request *org_model.OrgMemberSearchRequest) (*org_model.OrgMemberSearchResponse, error) {
+	request.EnsureLimit(repo.SearchLimit)
+	members, count, err := repo.View.SearchOrgMembers(request)
+	if err != nil {
+		return nil, err
+	}
+	return &org_model.OrgMemberSearchResponse{
+		Offset:      request.Offset,
+		Limit:       request.Limit,
+		TotalResult: uint64(count),
+		Result:      view.OrgMembersToModel(members),
+	}, nil
+}
+
+func (repo *OrgRepository) GetOrgMemberRoles() []string {
+	roles := make([]string, 0)
+	for _, roleMap := range repo.Roles {
+		if strings.HasPrefix(roleMap, "ORG") {
+			roles = append(roles, roleMap)
+		}
+	}
+	return roles
+}

internal/management/repository/eventsourcing/eventstore/org_member.go

@@ -1,30 +0,0 @@
-package eventstore
-
-import (
-	"context"
-
-	org_model "github.com/caos/zitadel/internal/org/model"
-	org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
-)
-
-type OrgMemberRepository struct {
-	*org_es.OrgEventstore
-}
-
-func (repo *OrgMemberRepository) OrgMemberByID(ctx context.Context, orgID, userID string) (member *org_model.OrgMember, err error) {
-	member = org_model.NewOrgMember(orgID, userID)
-	return repo.OrgEventstore.OrgMemberByIDs(ctx, member)
-}
-
-func (repo *OrgMemberRepository) AddOrgMember(ctx context.Context, member *org_model.OrgMember) (*org_model.OrgMember, error) {
-	return repo.OrgEventstore.AddOrgMember(ctx, member)
-}
-
-func (repo *OrgMemberRepository) ChangeOrgMember(ctx context.Context, member *org_model.OrgMember) (*org_model.OrgMember, error) {
-	return repo.OrgEventstore.ChangeOrgMember(ctx, member)
-}
-
-func (repo *OrgMemberRepository) RemoveOrgMember(ctx context.Context, orgID, userID string) error {
-	member := org_model.NewOrgMember(orgID, userID)
-	return repo.OrgEventstore.RemoveOrgMember(ctx, member)
-}

internal/management/repository/eventsourcing/eventstore/project.go

@@ -2,6 +2,8 @@ package eventstore
 
 import (
 	"context"
+	"strings"
+
 	"github.com/caos/zitadel/internal/management/repository/eventsourcing/view"
 	"github.com/caos/zitadel/internal/project/repository/view/model"
 
@@ -13,6 +15,7 @@ type ProjectRepo struct {
 	SearchLimit   uint64
 	ProjectEvents *proj_event.ProjectEventstore
 	View          *view.View
+	Roles         []string
 }
 
 func (repo *ProjectRepo) ProjectByID(ctx context.Context, id string) (project *proj_model.Project, err error) {
@@ -212,3 +215,23 @@ func (repo *ProjectRepo) SearchProjectGrantMembers(ctx context.Context, request
 		Result:      model.ProjectGrantMembersToModel(members),
 	}, nil
 }
+
+func (repo *ProjectRepo) GetProjectMemberRoles() []string {
+	roles := make([]string, 0)
+	for _, roleMap := range repo.Roles {
+		if strings.HasPrefix(roleMap, "PROJECT") && !strings.HasPrefix(roleMap, "PROJECT_GRANT") {
+			roles = append(roles, roleMap)
+		}
+	}
+	return roles
+}
+
+func (repo *ProjectRepo) GetProjectGrantMemberRoles() []string {
+	roles := make([]string, 0)
+	for _, roleMap := range repo.Roles {
+		if strings.HasPrefix(roleMap, "PROJECT_GRANT") {
+			roles = append(roles, roleMap)
+		}
+	}
+	return roles
+}

internal/management/repository/eventsourcing/handler/granted_project.go

@@ -9,8 +9,9 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
-	"github.com/caos/zitadel/internal/project/model"
-	"github.com/caos/zitadel/internal/project/repository/eventsourcing"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	org_event "github.com/caos/zitadel/internal/org/repository/eventsourcing"
+	proj_model "github.com/caos/zitadel/internal/project/model"
 	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
 	es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
 	view_model "github.com/caos/zitadel/internal/project/repository/view/model"
@@ -20,6 +21,7 @@ type GrantedProject struct {
 	handler
 	eventstore    eventstore.Eventstore
 	projectEvents *proj_event.ProjectEventstore
+	orgEvents     *org_event.OrgEventstore
 }
 
 const (
@@ -37,7 +39,7 @@ func (p *GrantedProject) EventQuery() (*models.SearchQuery, error) {
 	if err != nil {
 		return nil, err
 	}
-	return eventsourcing.ProjectQuery(sequence), nil
+	return proj_event.ProjectQuery(sequence), nil
 }
 
 func (p *GrantedProject) Process(event *models.Event) (err error) {
@@ -71,7 +73,12 @@ func (p *GrantedProject) Process(event *models.Event) (err error) {
 			return err
 		}
 		grantedProject.Name = project.Name
-		//TODO: read org
+
+		org, err := p.orgEvents.OrgByID(context.TODO(), org_model.NewOrg(grantedProject.OrgID))
+		if err != nil {
+			return err
+		}
+		p.fillOrgData(grantedProject, org)
 	case es_model.ProjectGrantChanged:
 		grant := new(view_model.ProjectGrant)
 		err := grant.SetData(event)
@@ -99,11 +106,12 @@ func (p *GrantedProject) Process(event *models.Event) (err error) {
 	return p.view.PutGrantedProject(grantedProject)
 }
 
-func (p *GrantedProject) getOrg(orgID string) {
-	//TODO: Get Org
+func (p *GrantedProject) fillOrgData(grantedProject *view_model.GrantedProjectView, org *org_model.Org) {
+	grantedProject.OrgDomain = org.Domain
+	grantedProject.OrgName = org.Name
 }
 
-func (p *GrantedProject) getProject(projectID string) (*model.Project, error) {
+func (p *GrantedProject) getProject(projectID string) (*proj_model.Project, error) {
 	return p.projectEvents.ProjectByID(context.Background(), projectID)
 }
 

internal/management/repository/eventsourcing/handler/handler.go

@@ -1,13 +1,15 @@
 package handler
 
 import (
+	"time"
+
 	"github.com/caos/zitadel/internal/config/types"
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	"github.com/caos/zitadel/internal/management/repository/eventsourcing/view"
+	org_event "github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
 	usr_event "github.com/caos/zitadel/internal/user/repository/eventsourcing"
-	"time"
 )
 
 type Configs map[string]*Config
@@ -26,17 +28,20 @@ type handler struct {
 type EventstoreRepos struct {
 	ProjectEvents *proj_event.ProjectEventstore
 	UserEvents    *usr_event.UserEventstore
+	OrgEvents     *org_event.OrgEventstore
 }
 
 func Register(configs Configs, bulkLimit, errorCount uint64, view *view.View, eventstore eventstore.Eventstore, repos EventstoreRepos) []spooler.Handler {
 	return []spooler.Handler{
-		&GrantedProject{handler: handler{view, bulkLimit, configs.cycleDuration("GrantedProject"), errorCount}, eventstore: eventstore, projectEvents: repos.ProjectEvents},
+		&GrantedProject{handler: handler{view, bulkLimit, configs.cycleDuration("GrantedProject"), errorCount}, eventstore: eventstore, projectEvents: repos.ProjectEvents, orgEvents: repos.OrgEvents},
 		&ProjectRole{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectRole"), errorCount}, projectEvents: repos.ProjectEvents},
 		&ProjectMember{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectMember"), errorCount}, userEvents: repos.UserEvents},
 		&ProjectGrantMember{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectGrantMember"), errorCount}, userEvents: repos.UserEvents},
-		&Application{handler: handler{view, bulkLimit, configs.cycleDuration("Application"), errorCount}},
-		&User{handler: handler{view, bulkLimit, configs.cycleDuration("User"), errorCount}},
-		&UserGrant{handler: handler{view, bulkLimit, configs.cycleDuration("UserGrant"), errorCount}, projectEvents: repos.ProjectEvents, userEvents: repos.UserEvents},
+		&Application{handler: handler{view, bulkLimit, configs.cycleDuration("Application"), errorCount}, projectEvents: repos.ProjectEvents},
+		&User{handler: handler{view, bulkLimit, configs.cycleDuration("User"), errorCount}, eventstore: eventstore},
+		&UserGrant{handler: handler{view, bulkLimit, configs.cycleDuration("UserGrant"), errorCount}, projectEvents: repos.ProjectEvents, userEvents: repos.UserEvents, orgEvents: repos.OrgEvents},
+		&Org{handler: handler{view, bulkLimit, configs.cycleDuration("Org"), errorCount}},
+		&OrgMember{handler: handler{view, bulkLimit, configs.cycleDuration("OrgMember"), errorCount}, userEvents: repos.UserEvents},
 	}
 }
 

internal/management/repository/eventsourcing/handler/org.go

@@ -0,0 +1,65 @@
+package handler
+
+import (
+	"time"
+
+	"github.com/caos/logging"
+	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/spooler"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	"github.com/caos/zitadel/internal/org/repository/eventsourcing"
+	"github.com/caos/zitadel/internal/org/repository/view"
+)
+
+type Org struct {
+	handler
+}
+
+const (
+	orgTable = "management.orgs"
+)
+
+func (o *Org) MinimumCycleDuration() time.Duration { return o.cycleDuration }
+
+func (o *Org) ViewModel() string {
+	return orgTable
+}
+
+func (o *Org) EventQuery() (*es_models.SearchQuery, error) {
+	sequence, err := o.view.GetLatestOrgSequence()
+	if err != nil {
+		return nil, err
+	}
+	return eventsourcing.OrgQuery(sequence), nil
+}
+
+func (o *Org) Process(event *es_models.Event) error {
+	org := new(view.OrgView)
+
+	switch event.Type {
+	case org_model.OrgAdded:
+		org.AppendEvent(event)
+	case org_model.OrgChanged:
+		err := org.SetData(event)
+		if err != nil {
+			return err
+		}
+		org, err = o.view.OrgByID(org.ID)
+		if err != nil {
+			return err
+		}
+		err = org.AppendEvent(event)
+		if err != nil {
+			return err
+		}
+	default:
+		return o.view.ProcessedOrgSequence(event.Sequence)
+	}
+
+	return o.view.PutOrg(org)
+}
+
+func (o *Org) OnError(event *es_models.Event, spoolerErr error) error {
+	logging.LogWithFields("SPOOL-ls9ew", "id", event.AggregateID).WithError(spoolerErr).Warn("something went wrong in project app handler")
+	return spooler.HandleError(event, spoolerErr, o.view.GetLatestOrgFailedEvent, o.view.ProcessedOrgFailedEvent, o.view.ProcessedOrgSequence, o.errorCountUntilSkip)
+}

internal/management/repository/eventsourcing/handler/org_member.go

@@ -0,0 +1,127 @@
+package handler
+
+import (
+	"context"
+	"time"
+
+	"github.com/caos/logging"
+	"github.com/caos/zitadel/internal/eventstore/models"
+	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/eventstore/spooler"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	view_model "github.com/caos/zitadel/internal/org/repository/view"
+	usr_model "github.com/caos/zitadel/internal/user/model"
+	usr_event "github.com/caos/zitadel/internal/user/repository/eventsourcing"
+	usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
+)
+
+type OrgMember struct {
+	handler
+	userEvents *usr_event.UserEventstore
+}
+
+const (
+	orgMemberTable = "management.org_members"
+)
+
+func (m *OrgMember) MinimumCycleDuration() time.Duration { return m.cycleDuration }
+
+func (m *OrgMember) ViewModel() string {
+	return orgMemberTable
+}
+
+func (m *OrgMember) EventQuery() (*models.SearchQuery, error) {
+	sequence, err := m.view.GetLatestOrgMemberSequence()
+	if err != nil {
+		return nil, err
+	}
+	return es_models.NewSearchQuery().
+		AggregateTypeFilter(org_model.OrgAggregate, usr_es_model.UserAggregate).
+		LatestSequenceFilter(sequence), nil
+}
+
+func (m *OrgMember) Process(event *models.Event) (err error) {
+	switch event.AggregateType {
+	case org_model.OrgAggregate:
+		err = m.processOrgMember(event)
+	case usr_es_model.UserAggregate:
+		err = m.processUser(event)
+	}
+	return err
+}
+
+func (m *OrgMember) processOrgMember(event *models.Event) (err error) {
+	member := new(view_model.OrgMemberView)
+	switch event.Type {
+	case org_model.OrgMemberAdded:
+		member.AppendEvent(event)
+		m.fillData(member)
+	case org_model.OrgMemberChanged:
+		err := member.SetData(event)
+		if err != nil {
+			return err
+		}
+		member, err = m.view.OrgMemberByIDs(event.AggregateID, member.UserID)
+		if err != nil {
+			return err
+		}
+		member.AppendEvent(event)
+	case org_model.OrgMemberRemoved:
+		err := member.SetData(event)
+		if err != nil {
+			return err
+		}
+		return m.view.DeleteOrgMember(event.AggregateID, member.UserID, event.Sequence)
+	default:
+		return m.view.ProcessedOrgMemberSequence(event.Sequence)
+	}
+	if err != nil {
+		return err
+	}
+	return m.view.PutOrgMember(member, member.Sequence)
+}
+
+func (m *OrgMember) processUser(event *models.Event) (err error) {
+	switch event.Type {
+	case usr_es_model.UserProfileChanged,
+		usr_es_model.UserEmailChanged:
+		members, err := m.view.OrgMembersByUserID(event.AggregateID)
+		if err != nil {
+			return err
+		}
+		user, err := m.userEvents.UserByID(context.Background(), event.AggregateID)
+		if err != nil {
+			return err
+		}
+		for _, member := range members {
+			m.fillUserData(member, user)
+			err = m.view.PutOrgMember(member, event.Sequence)
+			if err != nil {
+				return err
+			}
+		}
+	default:
+		return m.view.ProcessedOrgMemberSequence(event.Sequence)
+	}
+	return nil
+}
+
+func (m *OrgMember) fillData(member *view_model.OrgMemberView) (err error) {
+	user, err := m.userEvents.UserByID(context.Background(), member.UserID)
+	if err != nil {
+		return err
+	}
+	m.fillUserData(member, user)
+	return nil
+}
+
+func (m *OrgMember) fillUserData(member *view_model.OrgMemberView, user *usr_model.User) {
+	member.UserName = user.UserName
+	member.FirstName = user.FirstName
+	member.LastName = user.LastName
+	member.Email = user.EmailAddress
+}
+func (m *OrgMember) OnError(event *models.Event, err error) error {
+	logging.LogWithFields("SPOOL-u73es", "id", event.AggregateID).WithError(err).Warn("something went wrong in orgmember handler")
+	return spooler.HandleError(event, err, m.view.GetLatestOrgMemberFailedEvent, m.view.ProcessedOrgMemberFailedEvent, m.view.ProcessedOrgMemberSequence, m.errorCountUntilSkip)
+}

internal/management/repository/eventsourcing/handler/user_grant.go

@@ -2,7 +2,11 @@ package handler
 
 import (
 	"context"
+	"time"
+
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	org_events "github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	proj_model "github.com/caos/zitadel/internal/project/model"
 	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
 	proj_es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
@@ -10,7 +14,6 @@ import (
 	usr_events "github.com/caos/zitadel/internal/user/repository/eventsourcing"
 	usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 	grant_es_model "github.com/caos/zitadel/internal/usergrant/repository/eventsourcing/model"
-	"time"
 
 	"github.com/caos/logging"
 
@@ -25,6 +28,7 @@ type UserGrant struct {
 	eventstore    eventstore.Eventstore
 	projectEvents *proj_event.ProjectEventstore
 	userEvents    *usr_events.UserEventstore
+	orgEvents     *org_events.OrgEventstore
 }
 
 const (
@@ -67,7 +71,7 @@ func (u *UserGrant) processUserGrant(event *models.Event) (err error) {
 		if err != nil {
 			return err
 		}
-		err = u.fillData(grant)
+		err = u.fillData(grant, event.ResourceOwner)
 	case grant_es_model.UserGrantChanged,
 		grant_es_model.UserGrantDeactivated,
 		grant_es_model.UserGrantReactivated:
@@ -133,7 +137,7 @@ func (u *UserGrant) processProject(event *models.Event) (err error) {
 	return nil
 }
 
-func (u *UserGrant) fillData(grant *view_model.UserGrantView) (err error) {
+func (u *UserGrant) fillData(grant *view_model.UserGrantView, resourceOwner string) (err error) {
 	user, err := u.userEvents.UserByID(context.Background(), grant.UserID)
 	if err != nil {
 		return err
@@ -144,7 +148,12 @@ func (u *UserGrant) fillData(grant *view_model.UserGrantView) (err error) {
 		return err
 	}
 	u.fillProjectData(grant, project)
-	u.fillOrgData(grant)
+
+	org, err := u.orgEvents.OrgByID(context.TODO(), org_model.NewOrg(resourceOwner))
+	if err != nil {
+		return err
+	}
+	u.fillOrgData(grant, org)
 	return nil
 }
 
@@ -159,8 +168,9 @@ func (u *UserGrant) fillProjectData(grant *view_model.UserGrantView, project *pr
 	grant.ProjectName = project.Name
 }
 
-func (u *UserGrant) fillOrgData(grant *view_model.UserGrantView) {
-	//TODO: get ORG
+func (u *UserGrant) fillOrgData(grant *view_model.UserGrantView, org *org_model.Org) {
+	grant.OrgDomain = org.Domain
+	grant.OrgName = org.Name
 }
 
 func (u *UserGrant) OnError(event *models.Event, err error) error {

internal/management/repository/eventsourcing/org.go

@@ -1,52 +0,0 @@
-package eventsourcing
-
-import (
-	"context"
-
-	"github.com/caos/zitadel/internal/errors"
-	org_model "github.com/caos/zitadel/internal/org/model"
-	org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
-)
-
-type OrgRepository struct {
-	*org_es.OrgEventstore
-}
-
-func (repo *OrgRepository) OrgByID(ctx context.Context, id string) (*org_model.Org, error) {
-	org := org_model.NewOrg(id)
-	return repo.OrgEventstore.OrgByID(ctx, org)
-}
-
-func (repo *OrgRepository) OrgByDomainGlobal(ctx context.Context, domain string) (*org_model.Org, error) {
-	return nil, errors.ThrowUnimplemented(nil, "EVENT-GQoS8", "not implemented")
-}
-
-func (repo *OrgRepository) UpdateOrg(ctx context.Context, org *org_model.Org) (*org_model.Org, error) {
-	return nil, errors.ThrowUnimplemented(nil, "EVENT-RkurR", "not implemented")
-}
-
-func (repo *OrgRepository) DeactivateOrg(ctx context.Context, id string) (*org_model.Org, error) {
-	return repo.OrgEventstore.DeactivateOrg(ctx, id)
-}
-
-func (repo *OrgRepository) ReactivateOrg(ctx context.Context, id string) (*org_model.Org, error) {
-	return repo.OrgEventstore.ReactivateOrg(ctx, id)
-}
-
-func (repo *OrgRepository) OrgMemberByID(ctx context.Context, orgID, userID string) (member *org_model.OrgMember, err error) {
-	member = org_model.NewOrgMember(orgID, userID)
-	return repo.OrgEventstore.OrgMemberByIDs(ctx, member)
-}
-
-func (repo *OrgRepository) AddOrgMember(ctx context.Context, member *org_model.OrgMember) (*org_model.OrgMember, error) {
-	return repo.OrgEventstore.AddOrgMember(ctx, member)
-}
-
-func (repo *OrgRepository) ChangeOrgMember(ctx context.Context, member *org_model.OrgMember) (*org_model.OrgMember, error) {
-	return repo.OrgEventstore.ChangeOrgMember(ctx, member)
-}
-
-func (repo *OrgRepository) RemoveOrgMember(ctx context.Context, orgID, userID string) error {
-	member := org_model.NewOrgMember(orgID, userID)
-	return repo.OrgEventstore.RemoveOrgMember(ctx, member)
-}

internal/management/repository/eventsourcing/repository.go

@@ -34,7 +34,7 @@ type EsRepository struct {
 	eventstore.PolicyRepo
 }
 
-func Start(conf Config, systemDefaults sd.SystemDefaults) (*EsRepository, error) {
+func Start(conf Config, systemDefaults sd.SystemDefaults, roles []string) (*EsRepository, error) {
 	es, err := es_int.Start(conf.Eventstore)
 	if err != nil {
 		return nil, err
@@ -79,13 +79,13 @@ func Start(conf Config, systemDefaults sd.SystemDefaults) (*EsRepository, error)
 	}
 	org := es_org.StartOrg(es_org.OrgConfig{Eventstore: es})
 
-	eventstoreRepos := handler.EventstoreRepos{ProjectEvents: project, UserEvents: user}
+	eventstoreRepos := handler.EventstoreRepos{ProjectEvents: project, UserEvents: user, OrgEvents: org}
 	spool := spooler.StartSpooler(conf.Spooler, es, view, sqlClient, eventstoreRepos)
 
 	return &EsRepository{
 		spooler:       spool,
-		OrgRepository: eventstore.OrgRepository{org},
-		ProjectRepo:   eventstore.ProjectRepo{conf.SearchLimit, project, view},
+		OrgRepository: eventstore.OrgRepository{conf.SearchLimit, org, view, roles},
+		ProjectRepo:   eventstore.ProjectRepo{conf.SearchLimit, project, view, roles},
 		UserRepo:      eventstore.UserRepo{conf.SearchLimit, user, view},
 		UserGrantRepo: eventstore.UserGrantRepo{conf.SearchLimit, usergrant, view},
 		PolicyRepo:    eventstore.PolicyRepo{policy},

internal/management/repository/eventsourcing/view/org.go

@@ -0,0 +1,42 @@
+package view
+
+import (
+	org_view "github.com/caos/zitadel/internal/org/repository/view"
+	"github.com/caos/zitadel/internal/view"
+)
+
+const (
+	orgTable = "management.orgs"
+)
+
+func (v *View) OrgByID(orgID string) (*org_view.OrgView, error) {
+	return org_view.OrgByID(v.Db, orgTable, orgID)
+}
+
+func (v *View) OrgByDomain(domain string) (*org_view.OrgView, error) {
+	return org_view.GetGlobalOrgByDomain(v.Db, orgTable, domain)
+}
+
+func (v *View) PutOrg(org *org_view.OrgView) error {
+	err := org_view.PutOrg(v.Db, orgTable, org)
+	if err != nil {
+		return err
+	}
+	return v.ProcessedOrgSequence(org.Sequence)
+}
+
+func (v *View) GetLatestOrgFailedEvent(sequence uint64) (*view.FailedEvent, error) {
+	return v.latestFailedEvent(orgTable, sequence)
+}
+
+func (v *View) ProcessedOrgFailedEvent(failedEvent *view.FailedEvent) error {
+	return v.saveFailedEvent(failedEvent)
+}
+
+func (v *View) GetLatestOrgSequence() (uint64, error) {
+	return v.latestSequence(orgTable)
+}
+
+func (v *View) ProcessedOrgSequence(eventSequence uint64) error {
+	return v.saveCurrentSequence(orgTable, eventSequence)
+}

internal/management/repository/eventsourcing/view/org_member.go

@@ -0,0 +1,55 @@
+package view
+
+import (
+	org_model "github.com/caos/zitadel/internal/org/model"
+	"github.com/caos/zitadel/internal/org/repository/view"
+	global_view "github.com/caos/zitadel/internal/view"
+)
+
+const (
+	orgMemberTable = "management.org_members"
+)
+
+func (v *View) OrgMemberByIDs(orgID, userID string) (*view.OrgMemberView, error) {
+	return view.OrgMemberByIDs(v.Db, orgMemberTable, orgID, userID)
+}
+
+func (v *View) SearchOrgMembers(request *org_model.OrgMemberSearchRequest) ([]*view.OrgMemberView, int, error) {
+	return view.SearchOrgMembers(v.Db, orgMemberTable, request)
+}
+
+func (v *View) OrgMembersByUserID(userID string) ([]*view.OrgMemberView, error) {
+	return view.OrgMembersByUserID(v.Db, orgMemberTable, userID)
+}
+
+func (v *View) PutOrgMember(org *view.OrgMemberView, sequence uint64) error {
+	err := view.PutOrgMember(v.Db, orgMemberTable, org)
+	if err != nil {
+		return err
+	}
+	return v.ProcessedOrgMemberSequence(sequence)
+}
+
+func (v *View) DeleteOrgMember(orgID, userID string, eventSequence uint64) error {
+	err := view.DeleteOrgMember(v.Db, orgMemberTable, orgID, userID)
+	if err != nil {
+		return nil
+	}
+	return v.ProcessedOrgMemberSequence(eventSequence)
+}
+
+func (v *View) GetLatestOrgMemberSequence() (uint64, error) {
+	return v.latestSequence(orgMemberTable)
+}
+
+func (v *View) ProcessedOrgMemberSequence(eventSequence uint64) error {
+	return v.saveCurrentSequence(orgMemberTable, eventSequence)
+}
+
+func (v *View) GetLatestOrgMemberFailedEvent(sequence uint64) (*global_view.FailedEvent, error) {
+	return v.latestFailedEvent(orgMemberTable, sequence)
+}
+
+func (v *View) ProcessedOrgMemberFailedEvent(failedEvent *global_view.FailedEvent) error {
+	return v.saveFailedEvent(failedEvent)
+}

internal/management/repository/org.go

@@ -8,14 +8,15 @@ import (
 
 type OrgRepository interface {
 	OrgByID(ctx context.Context, id string) (*org_model.Org, error)
-	OrgByDomainGlobal(ctx context.Context, domain string) (*org_model.Org, error)
+	OrgByDomainGlobal(ctx context.Context, domain string) (*org_model.OrgView, error)
 	UpdateOrg(ctx context.Context, org *org_model.Org) (*org_model.Org, error)
 	DeactivateOrg(ctx context.Context, id string) (*org_model.Org, error)
 	ReactivateOrg(ctx context.Context, id string) (*org_model.Org, error)
-}
 
-type OrgMemberRepository interface {
+	SearchOrgMembers(ctx context.Context, request *org_model.OrgMemberSearchRequest) (*org_model.OrgMemberSearchResponse, error)
 	AddOrgMember(ctx context.Context, member *org_model.OrgMember) (*org_model.OrgMember, error)
 	ChangeOrgMember(ctx context.Context, member *org_model.OrgMember) (*org_model.OrgMember, error)
 	RemoveOrgMember(ctx context.Context, orgID, userID string) error
+
+	GetOrgMemberRoles() []string
 }

internal/management/repository/project.go

@@ -2,6 +2,7 @@ package repository
 
 import (
 	"context"
+
 	"github.com/caos/zitadel/internal/project/model"
 )
 
@@ -18,6 +19,7 @@ type ProjectRepository interface {
 	ChangeProjectMember(ctx context.Context, member *model.ProjectMember) (*model.ProjectMember, error)
 	RemoveProjectMember(ctx context.Context, projectID, userID string) error
 	SearchProjectMembers(ctx context.Context, request *model.ProjectMemberSearchRequest) (*model.ProjectMemberSearchResponse, error)
+	GetProjectMemberRoles() []string
 
 	AddProjectRole(ctx context.Context, role *model.ProjectRole) (*model.ProjectRole, error)
 	ChangeProjectRole(ctx context.Context, role *model.ProjectRole) (*model.ProjectRole, error)
@@ -46,4 +48,5 @@ type ProjectRepository interface {
 	AddProjectGrantMember(ctx context.Context, member *model.ProjectGrantMember) (*model.ProjectGrantMember, error)
 	ChangeProjectGrantMember(ctx context.Context, member *model.ProjectGrantMember) (*model.ProjectGrantMember, error)
 	RemoveProjectGrantMember(ctx context.Context, projectID, grantID, userID string) error
+	GetProjectGrantMemberRoles() []string
 }

internal/management/repository/repository.go

@@ -5,7 +5,6 @@ type Repository interface {
 	ProjectRepository
 	PolicyRepository
 	OrgRepository
-	OrgMemberRepository
 	UserRepository
 	UserGrantRepository
 }