feat: user query (#3075)

* user queries

* user query

* user query

* user tests

* remove old code

* user metadata

* cleanup

* fix merge

* cleanup

* cleanup

* fixes

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

@@ -16,23 +16,17 @@ import (
 	"github.com/caos/zitadel/internal/domain"
 	"github.com/caos/zitadel/internal/errors"
 	v1 "github.com/caos/zitadel/internal/eventstore/v1"
-	"github.com/caos/zitadel/internal/eventstore/v1/models"
 	"github.com/caos/zitadel/internal/i18n"
-	mgmt_view "github.com/caos/zitadel/internal/management/repository/eventsourcing/view"
 	org_model "github.com/caos/zitadel/internal/org/model"
 	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 	org_view "github.com/caos/zitadel/internal/org/repository/view"
 	"github.com/caos/zitadel/internal/query"
-	usr_model "github.com/caos/zitadel/internal/user/model"
-	"github.com/caos/zitadel/internal/user/repository/view"
-	usr_es_model "github.com/caos/zitadel/internal/user/repository/view/model"
 )
 
 type OrgRepository struct {
 	Query                               *query.Queries
 	SearchLimit                         uint64
 	Eventstore                          v1.Eventstore
-	View                                *mgmt_view.View
 	Roles                               []string
 	SystemDefaults                      systemdefaults.SystemDefaults
 	PrefixAvatarURL                     string
@@ -64,15 +58,15 @@ func (repo *OrgRepository) OrgChanges(ctx context.Context, id string, lastSequen
 	for _, change := range changes.Changes {
 		change.ModifierName = change.ModifierId
 		change.ModifierLoginName = change.ModifierId
-		user, _ := repo.userByID(ctx, change.ModifierId)
+		user, _ := repo.Query.GetUserByID(ctx, change.ModifierId)
 		if user != nil {
 			change.ModifierLoginName = user.PreferredLoginName
-			if user.HumanView != nil {
-				change.ModifierName = user.HumanView.DisplayName
-				change.ModifierAvatarURL = user.HumanView.AvatarURL
+			if user.Human != nil {
+				change.ModifierName = user.Human.DisplayName
+				change.ModifierAvatarURL = domain.AvatarURL(repo.PrefixAvatarURL, user.ResourceOwner, user.Human.AvatarKey)
 			}
-			if user.MachineView != nil {
-				change.ModifierName = user.MachineView.Name
+			if user.Machine != nil {
+				change.ModifierName = user.Machine.Name
 			}
 		}
 	}
@@ -134,40 +128,3 @@ func (repo *OrgRepository) getOrgChanges(ctx context.Context, orgID string, last
 		LastSequence: lastSequence,
 	}, nil
 }
-
-func (repo *OrgRepository) userByID(ctx context.Context, id string) (*usr_model.UserView, error) {
-	user, viewErr := repo.View.UserByID(id)
-	if viewErr != nil && !errors.IsNotFound(viewErr) {
-		return nil, viewErr
-	}
-	if errors.IsNotFound(viewErr) {
-		user = new(usr_es_model.UserView)
-	}
-	events, esErr := repo.getUserEvents(ctx, id, user.Sequence)
-	if errors.IsNotFound(viewErr) && len(events) == 0 {
-		return nil, errors.ThrowNotFound(nil, "EVENT-3nF8s", "Errors.User.NotFound")
-	}
-	if esErr != nil {
-		logging.Log("EVENT-PSoc3").WithError(esErr).Debug("error retrieving new events")
-		return usr_es_model.UserToModel(user, repo.PrefixAvatarURL), nil
-	}
-	userCopy := *user
-	for _, event := range events {
-		if err := userCopy.AppendEvent(event); err != nil {
-			return usr_es_model.UserToModel(user, repo.PrefixAvatarURL), nil
-		}
-	}
-	if userCopy.State == int32(usr_es_model.UserStateDeleted) {
-		return nil, errors.ThrowNotFound(nil, "EVENT-3n8Fs", "Errors.User.NotFound")
-	}
-	return usr_es_model.UserToModel(&userCopy, repo.PrefixAvatarURL), nil
-}
-
-func (r *OrgRepository) getUserEvents(ctx context.Context, userID string, sequence uint64) ([]*models.Event, error) {
-	query, err := view.UserByIDQuery(userID, sequence)
-	if err != nil {
-		return nil, err
-	}
-
-	return r.Eventstore.FilterEvents(ctx, query)
-}

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

@@ -1,9 +0,0 @@
-package eventstore
-
-const (
-	projectReadPerm            = "project.read"
-	orgMemberReadPerm          = "org.member.read"
-	iamMemberReadPerm          = "iam.member.read"
-	projectMemberReadPerm      = "project.member.read"
-	projectGrantMemberReadPerm = "project.grant.member.read"
-)

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

@@ -10,22 +10,17 @@ import (
 	"github.com/golang/protobuf/ptypes"
 
 	"github.com/caos/zitadel/internal/api/authz"
+	"github.com/caos/zitadel/internal/domain"
 	caos_errs "github.com/caos/zitadel/internal/errors"
 	v1 "github.com/caos/zitadel/internal/eventstore/v1"
 	"github.com/caos/zitadel/internal/eventstore/v1/models"
-	"github.com/caos/zitadel/internal/management/repository/eventsourcing/view"
 	proj_model "github.com/caos/zitadel/internal/project/model"
 	proj_view "github.com/caos/zitadel/internal/project/repository/view"
 	"github.com/caos/zitadel/internal/query"
-	usr_model "github.com/caos/zitadel/internal/user/model"
-	usr_view "github.com/caos/zitadel/internal/user/repository/view"
-	usr_es_model "github.com/caos/zitadel/internal/user/repository/view/model"
 )
 
 type ProjectRepo struct {
 	v1.Eventstore
-	SearchLimit     uint64
-	View            *view.View
 	Roles           []string
 	IAMID           string
 	PrefixAvatarURL string
@@ -40,15 +35,15 @@ func (repo *ProjectRepo) ProjectChanges(ctx context.Context, id string, lastSequ
 	for _, change := range changes.Changes {
 		change.ModifierName = change.ModifierId
 		change.ModifierLoginName = change.ModifierId
-		user, _ := repo.userByID(ctx, change.ModifierId)
+		user, _ := repo.Query.GetUserByID(ctx, change.ModifierId)
 		if user != nil {
 			change.ModifierLoginName = user.PreferredLoginName
-			if user.HumanView != nil {
-				change.ModifierName = user.HumanView.DisplayName
-				change.ModifierAvatarURL = user.HumanView.AvatarURL
+			if user.Human != nil {
+				change.ModifierName = user.Human.DisplayName
+				change.ModifierAvatarURL = domain.AvatarURL(repo.PrefixAvatarURL, user.ResourceOwner, user.Human.AvatarKey)
 			}
-			if user.MachineView != nil {
-				change.ModifierName = user.MachineView.Name
+			if user.Machine != nil {
+				change.ModifierName = user.Machine.Name
 			}
 		}
 	}
@@ -63,15 +58,15 @@ func (repo *ProjectRepo) ApplicationChanges(ctx context.Context, projectID strin
 	for _, change := range changes.Changes {
 		change.ModifierName = change.ModifierId
 		change.ModifierLoginName = change.ModifierId
-		user, _ := repo.userByID(ctx, change.ModifierId)
+		user, _ := repo.Query.GetUserByID(ctx, change.ModifierId)
 		if user != nil {
 			change.ModifierLoginName = user.PreferredLoginName
-			if user.HumanView != nil {
-				change.ModifierName = user.HumanView.DisplayName
-				change.ModifierAvatarURL = user.HumanView.AvatarURL
+			if user.Human != nil {
+				change.ModifierName = user.Human.DisplayName
+				change.ModifierAvatarURL = domain.AvatarURL(repo.PrefixAvatarURL, user.ResourceOwner, user.Human.AvatarKey)
 			}
-			if user.MachineView != nil {
-				change.ModifierName = user.MachineView.Name
+			if user.Machine != nil {
+				change.ModifierName = user.Machine.Name
 			}
 		}
 	}
@@ -106,42 +101,6 @@ func (repo *ProjectRepo) GetProjectGrantMemberRoles() []string {
 	return roles
 }
 
-func (repo *ProjectRepo) userByID(ctx context.Context, id string) (*usr_model.UserView, error) {
-	user, viewErr := repo.View.UserByID(id)
-	if viewErr != nil && !caos_errs.IsNotFound(viewErr) {
-		return nil, viewErr
-	}
-	if caos_errs.IsNotFound(viewErr) {
-		user = new(usr_es_model.UserView)
-	}
-	events, esErr := repo.getUserEvents(ctx, id, user.Sequence)
-	if caos_errs.IsNotFound(viewErr) && len(events) == 0 {
-		return nil, caos_errs.ThrowNotFound(nil, "EVENT-4n8Fs", "Errors.User.NotFound")
-	}
-	if esErr != nil {
-		logging.Log("EVENT-PSoc3").WithError(esErr).Debug("error retrieving new events")
-		return usr_es_model.UserToModel(user, repo.PrefixAvatarURL), nil
-	}
-	userCopy := *user
-	for _, event := range events {
-		if err := userCopy.AppendEvent(event); err != nil {
-			return usr_es_model.UserToModel(user, repo.PrefixAvatarURL), nil
-		}
-	}
-	if userCopy.State == int32(usr_model.UserStateDeleted) {
-		return nil, caos_errs.ThrowNotFound(nil, "EVENT-2m0Fs", "Errors.User.NotFound")
-	}
-	return usr_es_model.UserToModel(&userCopy, repo.PrefixAvatarURL), nil
-}
-
-func (r *ProjectRepo) getUserEvents(ctx context.Context, userID string, sequence uint64) ([]*models.Event, error) {
-	query, err := usr_view.UserByIDQuery(userID, sequence)
-	if err != nil {
-		return nil, err
-	}
-	return r.Eventstore.FilterEvents(ctx, query)
-}
-
 func (repo *ProjectRepo) getProjectChanges(ctx context.Context, id string, lastSequence uint64, limit uint64, sortAscending bool, retention time.Duration) (*proj_model.ProjectChanges, error) {
 	query := proj_view.ChangesQuery(id, lastSequence, limit, sortAscending, retention)
 

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

@@ -7,117 +7,24 @@ import (
 	"github.com/caos/logging"
 	"github.com/golang/protobuf/ptypes"
 
-	"github.com/caos/zitadel/internal/api/authz"
+	"github.com/caos/zitadel/internal/query"
+
 	"github.com/caos/zitadel/internal/config/systemdefaults"
 	"github.com/caos/zitadel/internal/domain"
 	"github.com/caos/zitadel/internal/errors"
 	v1 "github.com/caos/zitadel/internal/eventstore/v1"
 	"github.com/caos/zitadel/internal/eventstore/v1/models"
-	iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
-	"github.com/caos/zitadel/internal/management/repository/eventsourcing/view"
 	usr_model "github.com/caos/zitadel/internal/user/model"
 	usr_view "github.com/caos/zitadel/internal/user/repository/view"
-	"github.com/caos/zitadel/internal/user/repository/view/model"
-	"github.com/caos/zitadel/internal/view/repository"
 )
 
 type UserRepo struct {
 	v1.Eventstore
-	SearchLimit     uint64
-	View            *view.View
+	Query           *query.Queries
 	SystemDefaults  systemdefaults.SystemDefaults
 	PrefixAvatarURL string
 }
 
-func (repo *UserRepo) UserByID(ctx context.Context, id string) (*usr_model.UserView, error) {
-	user, viewErr := repo.View.UserByID(id)
-	if viewErr != nil && !errors.IsNotFound(viewErr) {
-		return nil, viewErr
-	}
-	if errors.IsNotFound(viewErr) {
-		user = new(model.UserView)
-	}
-
-	events, esErr := repo.getUserEvents(ctx, id, user.Sequence)
-	if errors.IsNotFound(viewErr) && len(events) == 0 {
-		return nil, errors.ThrowNotFound(nil, "EVENT-Lsoj7", "Errors.User.NotFound")
-	}
-	if esErr != nil {
-		logging.Log("EVENT-PSoc3").WithError(esErr).Debug("error retrieving new events")
-		return model.UserToModel(user, repo.PrefixAvatarURL), nil
-	}
-	userCopy := *user
-	for _, event := range events {
-		if err := userCopy.AppendEvent(event); err != nil {
-			return model.UserToModel(user, repo.PrefixAvatarURL), nil
-		}
-	}
-	if userCopy.State == int32(usr_model.UserStateDeleted) {
-		return nil, errors.ThrowNotFound(nil, "EVENT-4Fm9s", "Errors.User.NotFound")
-	}
-	return model.UserToModel(&userCopy, repo.PrefixAvatarURL), nil
-}
-
-func (repo *UserRepo) UserByIDAndResourceOwner(ctx context.Context, id, resourceOwner string) (*usr_model.UserView, error) {
-	user, viewErr := repo.View.UserByIDAndResourceOwner(id, resourceOwner)
-	if viewErr != nil && !errors.IsNotFound(viewErr) {
-		return nil, viewErr
-	}
-	if errors.IsNotFound(viewErr) {
-		user = new(model.UserView)
-	}
-
-	events, esErr := repo.getUserEvents(ctx, id, user.Sequence)
-	if errors.IsNotFound(viewErr) && len(events) == 0 {
-		return nil, errors.ThrowNotFound(nil, "EVENT-Lsoj7", "Errors.User.NotFound")
-	}
-	if esErr != nil {
-		logging.Log("EVENT-PSoc3").WithError(esErr).Debug("error retrieving new events")
-		return model.UserToModel(user, repo.PrefixAvatarURL), nil
-	}
-	userCopy := *user
-	for _, event := range events {
-		if err := userCopy.AppendEvent(event); err != nil {
-			return model.UserToModel(user, repo.PrefixAvatarURL), nil
-		}
-	}
-	if userCopy.State == int32(usr_model.UserStateDeleted) || userCopy.ResourceOwner != resourceOwner {
-		return nil, errors.ThrowNotFound(nil, "EVENT-4Fm9s", "Errors.User.NotFound")
-	}
-	return model.UserToModel(&userCopy, repo.PrefixAvatarURL), nil
-}
-
-func (repo *UserRepo) SearchUsers(ctx context.Context, request *usr_model.UserSearchRequest, ensureLimit bool) (*usr_model.UserSearchResponse, error) {
-	if ensureLimit {
-		err := request.EnsureLimit(repo.SearchLimit)
-
-		if err != nil {
-			return nil, err
-		}
-	}
-	sequence, sequenceErr := repo.View.GetLatestUserSequence()
-	logging.Log("EVENT-Lcn7d").OnError(sequenceErr).Warn("could not read latest user sequence")
-	users, count, err := repo.View.SearchUsers(request)
-	if err != nil {
-		return nil, err
-	}
-	result := &usr_model.UserSearchResponse{
-		Offset:      request.Offset,
-		Limit:       request.Limit,
-		TotalResult: count,
-		Result:      model.UsersToModel(users, repo.PrefixAvatarURL),
-	}
-	if sequenceErr == nil {
-		result.Sequence = sequence.CurrentSequence
-		result.Timestamp = sequence.LastSuccessfulSpoolerRun
-	}
-	return result, nil
-}
-
-func (repo *UserRepo) UserIDsByDomain(ctx context.Context, domain string) ([]string, error) {
-	return repo.View.UserIDsByDomain(domain)
-}
-
 func (repo *UserRepo) UserChanges(ctx context.Context, id string, lastSequence uint64, limit uint64, sortAscending bool, retention time.Duration) (*usr_model.UserChanges, error) {
 	changes, err := repo.getUserChanges(ctx, id, lastSequence, limit, sortAscending, retention)
 	if err != nil {
@@ -126,111 +33,21 @@ func (repo *UserRepo) UserChanges(ctx context.Context, id string, lastSequence u
 	for _, change := range changes.Changes {
 		change.ModifierName = change.ModifierID
 		change.ModifierLoginName = change.ModifierID
-		user, _ := repo.UserByID(ctx, change.ModifierID)
+		user, _ := repo.Query.GetUserByID(ctx, change.ModifierID)
 		if user != nil {
 			change.ModifierLoginName = user.PreferredLoginName
-			if user.HumanView != nil {
-				change.ModifierName = user.HumanView.DisplayName
-				change.ModifierAvatarURL = user.HumanView.AvatarURL
+			if user.Human != nil {
+				change.ModifierName = user.Human.DisplayName
+				change.ModifierAvatarURL = domain.AvatarURL(repo.PrefixAvatarURL, user.ResourceOwner, user.Human.AvatarKey)
 			}
-			if user.MachineView != nil {
-				change.ModifierName = user.MachineView.Name
+			if user.Machine != nil {
+				change.ModifierName = user.Machine.Name
 			}
 		}
 	}
 	return changes, nil
 }
 
-func (repo *UserRepo) GetUserByLoginNameGlobal(ctx context.Context, loginName string) (*usr_model.UserView, error) {
-	user, err := repo.View.GetGlobalUserByLoginName(loginName)
-	if err != nil {
-		return nil, err
-	}
-	return model.UserToModel(user, repo.PrefixAvatarURL), nil
-}
-
-func (repo *UserRepo) IsUserUnique(ctx context.Context, userName, email, orgID string) (bool, error) {
-	return repo.View.IsUserUnique(userName, email, orgID)
-}
-
-func (repo *UserRepo) GetMetadataByKey(ctx context.Context, userID, resourceOwner, key string) (*domain.Metadata, error) {
-	data, err := repo.View.MetadataByKeyAndResourceOwner(userID, resourceOwner, key)
-	if err != nil {
-		return nil, err
-	}
-	return iam_model.MetadataViewToDomain(data), nil
-}
-
-func (repo *UserRepo) SearchMetadata(ctx context.Context, userID, resourceOwner string, req *domain.MetadataSearchRequest) (*domain.MetadataSearchResponse, error) {
-	err := req.EnsureLimit(repo.SearchLimit)
-	if err != nil {
-		return nil, err
-	}
-	sequence, sequenceErr := repo.View.GetLatestUserSequence()
-	logging.Log("EVENT-m0ds3").OnError(sequenceErr).Warn("could not read latest user sequence")
-	req.AppendAggregateIDQuery(userID)
-	req.AppendResourceOwnerQuery(resourceOwner)
-	metadata, count, err := repo.View.SearchMetadata(req)
-	if err != nil {
-		return nil, err
-	}
-	result := &domain.MetadataSearchResponse{
-		Offset:      req.Offset,
-		Limit:       req.Limit,
-		TotalResult: count,
-		Result:      iam_model.MetadataViewsToDomain(metadata),
-	}
-	if sequenceErr == nil {
-		result.Sequence = sequence.CurrentSequence
-		result.Timestamp = sequence.LastSuccessfulSpoolerRun
-	}
-	return result, nil
-}
-
-func (repo *UserRepo) ProfileByID(ctx context.Context, userID string) (*usr_model.Profile, error) {
-	user, err := repo.UserByID(ctx, userID)
-	if err != nil {
-		return nil, err
-	}
-	if user.HumanView == nil {
-		return nil, errors.ThrowPreconditionFailed(nil, "EVENT-gDFC2", "Errors.User.NotHuman")
-	}
-	return user.GetProfile()
-}
-
-func (repo *UserRepo) EmailByID(ctx context.Context, userID string) (*usr_model.Email, error) {
-	user, err := repo.UserByID(ctx, userID)
-	if err != nil {
-		return nil, err
-	}
-	if user.HumanView == nil {
-		return nil, errors.ThrowPreconditionFailed(nil, "EVENT-pt7HY", "Errors.User.NotHuman")
-	}
-	return user.GetEmail()
-}
-
-func (repo *UserRepo) PhoneByID(ctx context.Context, userID string) (*usr_model.Phone, error) {
-	user, err := repo.UserByID(ctx, userID)
-	if err != nil {
-		return nil, err
-	}
-	if user.HumanView == nil {
-		return nil, errors.ThrowPreconditionFailed(nil, "EVENT-hliQl", "Errors.User.NotHuman")
-	}
-	return user.GetPhone()
-}
-
-func (repo *UserRepo) AddressByID(ctx context.Context, userID string) (*usr_model.Address, error) {
-	user, err := repo.UserByID(ctx, userID)
-	if err != nil {
-		return nil, err
-	}
-	if user.HumanView == nil {
-		return nil, errors.ThrowPreconditionFailed(nil, "EVENT-LQh4I", "Errors.User.NotHuman")
-	}
-	return user.GetAddress()
-}
-
 func (r *UserRepo) getUserChanges(ctx context.Context, userID string, lastSequence uint64, limit uint64, sortAscending bool, retention time.Duration) (*usr_model.UserChanges, error) {
 	query := usr_view.ChangesQuery(userID, lastSequence, limit, sortAscending, retention)
 
@@ -282,47 +99,3 @@ func (r *UserRepo) getUserEvents(ctx context.Context, userID string, sequence ui
 	}
 	return r.Eventstore.FilterEvents(ctx, query)
 }
-
-func handleSearchUserMembershipsPermissions(ctx context.Context, request *usr_model.UserMembershipSearchRequest, sequence *repository.CurrentSequence) *usr_model.UserMembershipSearchResponse {
-	permissions := authz.GetAllPermissionsFromCtx(ctx)
-	iamPerm := authz.HasGlobalExplicitPermission(permissions, iamMemberReadPerm)
-	orgPerm := authz.HasGlobalExplicitPermission(permissions, orgMemberReadPerm)
-	projectPerm := authz.HasGlobalExplicitPermission(permissions, projectMemberReadPerm)
-	projectGrantPerm := authz.HasGlobalExplicitPermission(permissions, projectGrantMemberReadPerm)
-	if iamPerm && orgPerm && projectPerm && projectGrantPerm {
-		return nil
-	}
-	if !iamPerm {
-		request.Queries = append(request.Queries, &usr_model.UserMembershipSearchQuery{Key: usr_model.UserMembershipSearchKeyMemberType, Method: domain.SearchMethodNotEquals, Value: usr_model.MemberTypeIam})
-	}
-	if !orgPerm {
-		request.Queries = append(request.Queries, &usr_model.UserMembershipSearchQuery{Key: usr_model.UserMembershipSearchKeyMemberType, Method: domain.SearchMethodNotEquals, Value: usr_model.MemberTypeOrganisation})
-	}
-
-	ids := authz.GetExplicitPermissionCtxIDs(permissions, projectMemberReadPerm)
-	ids = append(ids, authz.GetExplicitPermissionCtxIDs(permissions, projectGrantMemberReadPerm)...)
-	if _, q := request.GetSearchQuery(usr_model.UserMembershipSearchKeyObjectID); q != nil {
-		containsID := false
-		for _, id := range ids {
-			if id == q.Value {
-				containsID = true
-				break
-			}
-		}
-		if !containsID {
-			result := &usr_model.UserMembershipSearchResponse{
-				Offset:      request.Offset,
-				Limit:       request.Limit,
-				TotalResult: uint64(0),
-				Result:      []*usr_model.UserMembershipView{},
-			}
-			if sequence != nil {
-				result.Sequence = sequence.CurrentSequence
-				result.Timestamp = sequence.LastSuccessfulSpoolerRun
-			}
-			return result
-		}
-	}
-	request.Queries = append(request.Queries, &usr_model.UserMembershipSearchQuery{Key: usr_model.UserMembershipSearchKeyObjectID, Method: domain.SearchMethodIsOneOf, Value: ids})
-	return nil
-}

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

@@ -1,61 +0,0 @@
-package handler
-
-import (
-	"time"
-
-	v1 "github.com/caos/zitadel/internal/eventstore/v1"
-	"github.com/caos/zitadel/internal/static"
-
-	"github.com/caos/zitadel/internal/config/systemdefaults"
-	"github.com/caos/zitadel/internal/config/types"
-	"github.com/caos/zitadel/internal/eventstore/v1/query"
-	"github.com/caos/zitadel/internal/management/repository/eventsourcing/view"
-)
-
-type Configs map[string]*Config
-
-type Config struct {
-	MinimumCycleDuration types.Duration
-}
-
-type handler struct {
-	view                *view.View
-	bulkLimit           uint64
-	cycleDuration       time.Duration
-	errorCountUntilSkip uint64
-
-	es v1.Eventstore
-}
-
-func (h *handler) Eventstore() v1.Eventstore {
-	return h.es
-}
-
-func Register(configs Configs, bulkLimit, errorCount uint64, view *view.View, es v1.Eventstore, defaults systemdefaults.SystemDefaults, staticStorage static.Storage) []query.Handler {
-	return []query.Handler{
-		newUser(handler{view, bulkLimit, configs.cycleDuration("User"), errorCount, es},
-			defaults.IamID),
-		newMetadata(
-			handler{view, bulkLimit, configs.cycleDuration("Metadata"), errorCount, es}),
-	}
-}
-
-func (configs Configs) cycleDuration(viewModel string) time.Duration {
-	c, ok := configs[viewModel]
-	if !ok {
-		return 3 * time.Minute
-	}
-	return c.MinimumCycleDuration.Duration
-}
-
-func (h *handler) MinimumCycleDuration() time.Duration {
-	return h.cycleDuration
-}
-
-func (h *handler) LockDuration() time.Duration {
-	return h.cycleDuration / 3
-}
-
-func (h *handler) QueryLimit() uint64 {
-	return h.bulkLimit
-}

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

@@ -1,126 +0,0 @@
-package handler
-
-import (
-	"github.com/caos/logging"
-
-	caos_errs "github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v1"
-	es_models "github.com/caos/zitadel/internal/eventstore/v1/models"
-	"github.com/caos/zitadel/internal/eventstore/v1/query"
-	"github.com/caos/zitadel/internal/eventstore/v1/spooler"
-	iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
-	usr_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
-)
-
-type Metadata struct {
-	handler
-	subscription *v1.Subscription
-}
-
-func newMetadata(handler handler) *Metadata {
-	h := &Metadata{
-		handler: handler,
-	}
-
-	h.subscribe()
-
-	return h
-}
-
-func (m *Metadata) subscribe() {
-	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
-	go func() {
-		for event := range m.subscription.Events {
-			query.ReduceEvent(m, event)
-		}
-	}()
-}
-
-const (
-	metadataTable = "management.metadata"
-)
-
-func (m *Metadata) ViewModel() string {
-	return metadataTable
-}
-
-func (m *Metadata) Subscription() *v1.Subscription {
-	return m.subscription
-}
-
-func (_ *Metadata) AggregateTypes() []es_models.AggregateType {
-	return []es_models.AggregateType{usr_model.UserAggregate}
-}
-
-func (p *Metadata) CurrentSequence() (uint64, error) {
-	sequence, err := p.view.GetLatestMetadataSequence()
-	if err != nil {
-		return 0, err
-	}
-	return sequence.CurrentSequence, nil
-}
-
-func (m *Metadata) EventQuery() (*es_models.SearchQuery, error) {
-	sequence, err := m.view.GetLatestMetadataSequence()
-	if err != nil {
-		return nil, err
-	}
-	return es_models.NewSearchQuery().
-		AggregateTypeFilter(m.AggregateTypes()...).
-		LatestSequenceFilter(sequence.CurrentSequence), nil
-}
-
-func (m *Metadata) Reduce(event *es_models.Event) (err error) {
-	switch event.AggregateType {
-	case usr_model.UserAggregate:
-		err = m.processMetadata(event)
-	}
-	return err
-}
-
-func (m *Metadata) processMetadata(event *es_models.Event) (err error) {
-	metadata := new(iam_model.MetadataView)
-	switch event.Type {
-	case usr_model.UserMetadataSet:
-		err = metadata.SetData(event)
-		if err != nil {
-			return err
-		}
-		metadata, err = m.view.MetadataByKey(event.AggregateID, metadata.Key)
-		if err != nil && !caos_errs.IsNotFound(err) {
-			return err
-		}
-		if caos_errs.IsNotFound(err) {
-			err = nil
-			metadata = new(iam_model.MetadataView)
-			metadata.CreationDate = event.CreationDate
-		}
-		err = metadata.AppendEvent(event)
-	case usr_model.UserMetadataRemoved:
-		data := new(iam_model.MetadataView)
-		err = data.SetData(event)
-		if err != nil {
-			return err
-		}
-		return m.view.DeleteMetadata(event.AggregateID, data.Key, event)
-	case usr_model.UserMetadataRemovedAll:
-		return m.view.DeleteMetadataByAggregateID(event.AggregateID, event)
-	case usr_model.UserRemoved:
-		return m.view.DeleteMetadataByAggregateID(event.AggregateID, event)
-	default:
-		return m.view.ProcessedMetadataSequence(event)
-	}
-	if err != nil {
-		return err
-	}
-	return m.view.PutMetadata(metadata, event)
-}
-
-func (m *Metadata) OnError(event *es_models.Event, err error) error {
-	logging.LogWithFields("SPOOL-3m912", "id", event.AggregateID).WithError(err).Warn("something went wrong in custom text handler")
-	return spooler.HandleError(event, err, m.view.GetLatestMetadataFailedEvent, m.view.ProcessedMetadataFailedEvent, m.view.ProcessedMetadataSequence, m.errorCountUntilSkip)
-}
-
-func (o *Metadata) OnSuccess() error {
-	return spooler.HandleSuccess(o.view.UpdateMetadataSpoolerRunTimestamp)
-}

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

@@ -1,311 +0,0 @@
-package handler
-
-import (
-	"context"
-
-	"github.com/caos/logging"
-
-	"github.com/caos/zitadel/internal/domain"
-	caos_errs "github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v1"
-	es_models "github.com/caos/zitadel/internal/eventstore/v1/models"
-	"github.com/caos/zitadel/internal/eventstore/v1/query"
-	es_sdk "github.com/caos/zitadel/internal/eventstore/v1/sdk"
-	"github.com/caos/zitadel/internal/eventstore/v1/spooler"
-	iam_model "github.com/caos/zitadel/internal/iam/model"
-	"github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
-	iam_view "github.com/caos/zitadel/internal/iam/repository/view"
-	org_model "github.com/caos/zitadel/internal/org/model"
-	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
-	"github.com/caos/zitadel/internal/org/repository/view"
-	user_repo "github.com/caos/zitadel/internal/repository/user"
-	es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
-	view_model "github.com/caos/zitadel/internal/user/repository/view/model"
-)
-
-const (
-	userTable = "management.users"
-)
-
-type User struct {
-	handler
-	iamID        string
-	subscription *v1.Subscription
-}
-
-func newUser(
-	handler handler,
-	iamID string,
-) *User {
-	h := &User{
-		handler: handler,
-		iamID:   iamID,
-	}
-
-	h.subscribe()
-
-	return h
-}
-
-func (m *User) subscribe() {
-	m.subscription = m.es.Subscribe(m.AggregateTypes()...)
-	go func() {
-		for event := range m.subscription.Events {
-			query.ReduceEvent(m, event)
-		}
-	}()
-}
-
-func (u *User) ViewModel() string {
-	return userTable
-}
-
-func (u *User) Subscription() *v1.Subscription {
-	return u.subscription
-}
-
-func (_ *User) AggregateTypes() []es_models.AggregateType {
-	return []es_models.AggregateType{es_model.UserAggregate, org_es_model.OrgAggregate}
-}
-
-func (u *User) CurrentSequence() (uint64, error) {
-	sequence, err := u.view.GetLatestUserSequence()
-	if err != nil {
-		return 0, err
-	}
-	return sequence.CurrentSequence, nil
-}
-
-func (u *User) EventQuery() (*es_models.SearchQuery, error) {
-	sequence, err := u.view.GetLatestUserSequence()
-	if err != nil {
-		return nil, err
-	}
-	return es_models.NewSearchQuery().
-		AggregateTypeFilter(u.AggregateTypes()...).
-		LatestSequenceFilter(sequence.CurrentSequence), nil
-}
-
-func (u *User) Reduce(event *es_models.Event) (err error) {
-	switch event.AggregateType {
-	case es_model.UserAggregate:
-		return u.ProcessUser(event)
-	case org_es_model.OrgAggregate:
-		return u.ProcessOrg(event)
-	default:
-		return nil
-	}
-}
-
-func (u *User) ProcessUser(event *es_models.Event) (err error) {
-	user := new(view_model.UserView)
-	switch event.Type {
-	case es_model.UserAdded,
-		es_model.UserRegistered,
-		es_model.HumanRegistered,
-		es_model.MachineAdded,
-		es_model.HumanAdded:
-		err = user.AppendEvent(event)
-		if err != nil {
-			return err
-		}
-		err = u.fillLoginNames(user)
-	case es_model.UserProfileChanged,
-		es_model.UserEmailChanged,
-		es_model.UserEmailVerified,
-		es_model.UserPhoneChanged,
-		es_model.UserPhoneVerified,
-		es_model.UserPhoneRemoved,
-		es_model.UserAddressChanged,
-		es_model.UserDeactivated,
-		es_model.UserReactivated,
-		es_model.UserLocked,
-		es_model.UserUnlocked,
-		es_model.MFAOTPAdded,
-		es_model.MFAOTPVerified,
-		es_model.MFAOTPRemoved,
-		es_model.HumanProfileChanged,
-		es_model.HumanEmailChanged,
-		es_model.HumanEmailVerified,
-		es_model.HumanAvatarAdded,
-		es_model.HumanAvatarRemoved,
-		es_model.HumanPhoneChanged,
-		es_model.HumanPhoneVerified,
-		es_model.HumanPhoneRemoved,
-		es_model.HumanAddressChanged,
-		es_model.HumanMFAOTPAdded,
-		es_model.HumanMFAOTPVerified,
-		es_model.HumanMFAOTPRemoved,
-		es_model.HumanMFAU2FTokenAdded,
-		es_model.HumanMFAU2FTokenVerified,
-		es_model.HumanMFAU2FTokenRemoved,
-		es_model.HumanPasswordlessTokenAdded,
-		es_model.HumanPasswordlessTokenVerified,
-		es_model.HumanPasswordlessTokenRemoved,
-		es_model.MachineChanged,
-		es_models.EventType(user_repo.HumanPasswordlessInitCodeAddedType),
-		es_models.EventType(user_repo.HumanPasswordlessInitCodeRequestedType):
-		user, err = u.view.UserByID(event.AggregateID)
-		if err != nil {
-			return err
-		}
-		err = user.AppendEvent(event)
-	case es_model.DomainClaimed,
-		es_model.UserUserNameChanged:
-		user, err = u.view.UserByID(event.AggregateID)
-		if err != nil {
-			return err
-		}
-		err = user.AppendEvent(event)
-		if err != nil {
-			return err
-		}
-		err = u.fillLoginNames(user)
-	case es_model.UserRemoved:
-		return u.view.DeleteUser(event.AggregateID, event)
-	default:
-		return u.view.ProcessedUserSequence(event)
-	}
-	if err != nil {
-		return err
-	}
-	return u.view.PutUser(user, event)
-}
-
-func (u *User) ProcessOrg(event *es_models.Event) (err error) {
-	switch event.Type {
-	case org_es_model.OrgDomainVerified,
-		org_es_model.OrgDomainRemoved,
-		org_es_model.OrgIAMPolicyAdded,
-		org_es_model.OrgIAMPolicyChanged,
-		org_es_model.OrgIAMPolicyRemoved:
-		return u.fillLoginNamesOnOrgUsers(event)
-	case org_es_model.OrgDomainPrimarySet:
-		return u.fillPreferredLoginNamesOnOrgUsers(event)
-	default:
-		return u.view.ProcessedUserSequence(event)
-	}
-}
-
-func (u *User) fillLoginNamesOnOrgUsers(event *es_models.Event) error {
-	org, err := u.getOrgByID(context.Background(), event.ResourceOwner)
-	if err != nil {
-		return err
-	}
-	policy := org.OrgIamPolicy
-	if policy == nil {
-		policy, err = u.getDefaultOrgIAMPolicy(context.Background())
-		if err != nil {
-			return err
-		}
-	}
-	users, err := u.view.UsersByOrgID(event.AggregateID)
-	if err != nil {
-		return err
-	}
-	for _, user := range users {
-		user.SetLoginNames(policy, org.Domains)
-	}
-	return u.view.PutUsers(users, event)
-}
-
-func (u *User) fillPreferredLoginNamesOnOrgUsers(event *es_models.Event) error {
-	org, err := u.getOrgByID(context.Background(), event.ResourceOwner)
-	if err != nil {
-		return err
-	}
-	policy := org.OrgIamPolicy
-	if policy == nil {
-		policy, err = u.getDefaultOrgIAMPolicy(context.Background())
-		if err != nil {
-			return err
-		}
-	}
-	if !policy.UserLoginMustBeDomain {
-		return u.view.ProcessedUserSequence(event)
-	}
-	users, err := u.view.UsersByOrgID(event.AggregateID)
-	if err != nil {
-		return err
-	}
-	for _, user := range users {
-		user.PreferredLoginName = user.GenerateLoginName(org.GetPrimaryDomain().Domain, policy.UserLoginMustBeDomain)
-	}
-	return u.view.PutUsers(users, event)
-}
-
-func (u *User) fillLoginNames(user *view_model.UserView) (err error) {
-	org, err := u.getOrgByID(context.Background(), user.ResourceOwner)
-	if err != nil {
-		return err
-	}
-	policy := org.OrgIamPolicy
-	if policy == nil {
-		policy, err = u.getDefaultOrgIAMPolicy(context.TODO())
-		if err != nil {
-			return err
-		}
-	}
-	user.SetLoginNames(policy, org.Domains)
-	user.PreferredLoginName = user.GenerateLoginName(org.GetPrimaryDomain().Domain, policy.UserLoginMustBeDomain)
-	return nil
-}
-
-func (u *User) OnError(event *es_models.Event, err error) error {
-	logging.LogWithFields("SPOOL-is8wa", "id", event.AggregateID).WithError(err).Warn("something went wrong in user handler")
-	return spooler.HandleError(event, err, u.view.GetLatestUserFailedEvent, u.view.ProcessedUserFailedEvent, u.view.ProcessedUserSequence, u.errorCountUntilSkip)
-}
-
-func (u *User) OnSuccess() error {
-	return spooler.HandleSuccess(u.view.UpdateUserSpoolerRunTimestamp)
-}
-
-func (u *User) getOrgByID(ctx context.Context, orgID string) (*org_model.Org, error) {
-	query, err := view.OrgByIDQuery(orgID, 0)
-	if err != nil {
-		return nil, err
-	}
-
-	esOrg := &org_es_model.Org{
-		ObjectRoot: es_models.ObjectRoot{
-			AggregateID: orgID,
-		},
-	}
-	err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, esOrg.AppendEvents, query)
-	if err != nil && !caos_errs.IsNotFound(err) {
-		return nil, err
-	}
-	if esOrg.Sequence == 0 {
-		return nil, caos_errs.ThrowNotFound(nil, "EVENT-kVLb2", "Errors.Org.NotFound")
-	}
-
-	return org_es_model.OrgToModel(esOrg), nil
-}
-
-func (u *User) getIAMByID(ctx context.Context) (*iam_model.IAM, error) {
-	query, err := iam_view.IAMByIDQuery(domain.IAMID, 0)
-	if err != nil {
-		return nil, err
-	}
-	iam := &model.IAM{
-		ObjectRoot: es_models.ObjectRoot{
-			AggregateID: domain.IAMID,
-		},
-	}
-	err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, iam.AppendEvents, query)
-	if err != nil && caos_errs.IsNotFound(err) && iam.Sequence == 0 {
-		return nil, err
-	}
-	return model.IAMToModel(iam), nil
-}
-
-func (u *User) getDefaultOrgIAMPolicy(ctx context.Context) (*iam_model.OrgIAMPolicy, error) {
-	existingIAM, err := u.getIAMByID(ctx)
-	if err != nil {
-		return nil, err
-	}
-	if existingIAM.DefaultOrgIAMPolicy == nil {
-		return nil, caos_errs.ThrowNotFound(nil, "EVENT-2Fj8s", "Errors.IAM.OrgIAMPolicy.NotExisting")
-	}
-	return existingIAM.DefaultOrgIAMPolicy, nil
-}

internal/management/repository/eventsourcing/repository.go

@@ -7,10 +7,7 @@ import (
 	sd "github.com/caos/zitadel/internal/config/systemdefaults"
 	"github.com/caos/zitadel/internal/config/types"
 	v1 "github.com/caos/zitadel/internal/eventstore/v1"
-	es_spol "github.com/caos/zitadel/internal/eventstore/v1/spooler"
 	"github.com/caos/zitadel/internal/management/repository/eventsourcing/eventstore"
-	"github.com/caos/zitadel/internal/management/repository/eventsourcing/spooler"
-	mgmt_view "github.com/caos/zitadel/internal/management/repository/eventsourcing/view"
 	"github.com/caos/zitadel/internal/query"
 	"github.com/caos/zitadel/internal/static"
 )
@@ -21,16 +18,13 @@ type Config struct {
 	APIDomain   string
 	Eventstore  v1.Config
 	View        types.SQL
-	Spooler     spooler.SpoolerConfig
 }
 
 type EsRepository struct {
-	spooler *es_spol.Spooler
 	eventstore.OrgRepository
 	eventstore.ProjectRepo
 	eventstore.UserRepo
 	eventstore.IAMRepository
-	view *mgmt_view.View
 }
 
 func Start(conf Config, systemDefaults sd.SystemDefaults, roles []string, queries *query.Queries, staticStorage static.Storage) (*EsRepository, error) {
@@ -40,16 +34,6 @@ func Start(conf Config, systemDefaults sd.SystemDefaults, roles []string, querie
 		return nil, err
 	}
 
-	sqlClient, err := conf.View.Start()
-	if err != nil {
-		return nil, err
-	}
-	view, err := mgmt_view.StartView(sqlClient)
-	if err != nil {
-		return nil, err
-	}
-
-	spool := spooler.StartSpooler(conf.Spooler, es, view, sqlClient, systemDefaults, staticStorage)
 	assetsAPI := conf.APIDomain + "/assets/v1/"
 
 	statikLoginFS, err := fs.NewWithNamespace("login")
@@ -59,11 +43,9 @@ func Start(conf Config, systemDefaults sd.SystemDefaults, roles []string, querie
 	logging.Log("CONFI-7usEW").OnError(err).Panic("unable to start notification statik dir")
 
 	return &EsRepository{
-		spooler: spool,
 		OrgRepository: eventstore.OrgRepository{
 			SearchLimit:                         conf.SearchLimit,
 			Eventstore:                          es,
-			View:                                view,
 			Roles:                               roles,
 			SystemDefaults:                      systemDefaults,
 			PrefixAvatarURL:                     assetsAPI,
@@ -73,13 +55,8 @@ func Start(conf Config, systemDefaults sd.SystemDefaults, roles []string, querie
 			NotificationTranslationFileContents: make(map[string][]byte),
 			Query:                               queries,
 		},
-		ProjectRepo:   eventstore.ProjectRepo{es, conf.SearchLimit, view, roles, systemDefaults.IamID, assetsAPI, queries},
-		UserRepo:      eventstore.UserRepo{es, conf.SearchLimit, view, systemDefaults, assetsAPI},
+		ProjectRepo:   eventstore.ProjectRepo{es, roles, systemDefaults.IamID, assetsAPI, queries},
+		UserRepo:      eventstore.UserRepo{es, queries, systemDefaults, assetsAPI},
 		IAMRepository: eventstore.IAMRepository{IAMV2Query: queries},
-		view:          view,
 	}, nil
 }
-
-func (repo *EsRepository) Health() error {
-	return repo.view.Health()
-}

internal/management/repository/eventsourcing/spooler/lock.go

@@ -1,19 +0,0 @@
-package spooler
-
-import (
-	"database/sql"
-	es_locker "github.com/caos/zitadel/internal/eventstore/v1/locker"
-	"time"
-)
-
-const (
-	lockTable = "management.locks"
-)
-
-type locker struct {
-	dbClient *sql.DB
-}
-
-func (l *locker) Renew(lockerID, viewModel string, waitTime time.Duration) error {
-	return es_locker.Renew(l.dbClient, lockTable, lockerID, viewModel, waitTime)
-}

internal/management/repository/eventsourcing/spooler/spooler.go

@@ -1,31 +0,0 @@
-package spooler
-
-import (
-	"database/sql"
-	"github.com/caos/zitadel/internal/config/systemdefaults"
-	"github.com/caos/zitadel/internal/eventstore/v1"
-	"github.com/caos/zitadel/internal/static"
-
-	"github.com/caos/zitadel/internal/eventstore/v1/spooler"
-	"github.com/caos/zitadel/internal/management/repository/eventsourcing/handler"
-	"github.com/caos/zitadel/internal/management/repository/eventsourcing/view"
-)
-
-type SpoolerConfig struct {
-	BulkLimit             uint64
-	FailureCountUntilSkip uint64
-	ConcurrentWorkers     int
-	Handlers              handler.Configs
-}
-
-func StartSpooler(c SpoolerConfig, es v1.Eventstore, view *view.View, sql *sql.DB, defaults systemdefaults.SystemDefaults, staticStorage static.Storage) *spooler.Spooler {
-	spoolerConfig := spooler.Config{
-		Eventstore:        es,
-		Locker:            &locker{dbClient: sql},
-		ConcurrentWorkers: c.ConcurrentWorkers,
-		ViewHandlers:      handler.Register(c.Handlers, c.BulkLimit, c.FailureCountUntilSkip, view, es, defaults, staticStorage),
-	}
-	spool := spoolerConfig.New()
-	spool.Start()
-	return spool
-}

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

@@ -1,17 +0,0 @@
-package view
-
-import (
-	"github.com/caos/zitadel/internal/view/repository"
-)
-
-const (
-	errTable = "management.failed_events"
-)
-
-func (v *View) saveFailedEvent(failedEvent *repository.FailedEvent) error {
-	return repository.SaveFailedEvent(v.Db, errTable, failedEvent)
-}
-
-func (v *View) latestFailedEvent(viewName string, sequence uint64) (*repository.FailedEvent, error) {
-	return repository.LatestFailedEvent(v.Db, errTable, viewName, sequence)
-}

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

@@ -1,73 +0,0 @@
-package view
-
-import (
-	"github.com/caos/zitadel/internal/domain"
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v1/models"
-	"github.com/caos/zitadel/internal/iam/repository/view"
-	"github.com/caos/zitadel/internal/iam/repository/view/model"
-	global_view "github.com/caos/zitadel/internal/view/repository"
-)
-
-const (
-	metadataTable = "management.metadata"
-)
-
-func (v *View) MetadataByKey(aggregateID, key string) (*model.MetadataView, error) {
-	return view.MetadataByKey(v.Db, metadataTable, aggregateID, key)
-}
-
-func (v *View) MetadataByKeyAndResourceOwner(aggregateID, resourceOwner, key string) (*model.MetadataView, error) {
-	return view.MetadataByKeyAndResourceOwner(v.Db, metadataTable, aggregateID, resourceOwner, key)
-}
-
-func (v *View) MetadataListByAggregateID(aggregateID string) ([]*model.MetadataView, error) {
-	return view.GetMetadataList(v.Db, metadataTable, aggregateID)
-}
-
-func (v *View) SearchMetadata(request *domain.MetadataSearchRequest) ([]*model.MetadataView, uint64, error) {
-	return view.SearchMetadata(v.Db, metadataTable, request)
-}
-
-func (v *View) PutMetadata(template *model.MetadataView, event *models.Event) error {
-	err := view.PutMetadata(v.Db, metadataTable, template)
-	if err != nil {
-		return err
-	}
-	return v.ProcessedMetadataSequence(event)
-}
-
-func (v *View) DeleteMetadata(aggregateID, key string, event *models.Event) error {
-	err := view.DeleteMetadata(v.Db, metadataTable, aggregateID, key)
-	if err != nil && !errors.IsNotFound(err) {
-		return err
-	}
-	return v.ProcessedMetadataSequence(event)
-}
-
-func (v *View) DeleteMetadataByAggregateID(aggregateID string, event *models.Event) error {
-	err := view.DeleteMetadataByAggregateID(v.Db, metadataTable, aggregateID)
-	if err != nil && !errors.IsNotFound(err) {
-		return err
-	}
-	return v.ProcessedMetadataSequence(event)
-}
-func (v *View) GetLatestMetadataSequence() (*global_view.CurrentSequence, error) {
-	return v.latestSequence(metadataTable)
-}
-
-func (v *View) ProcessedMetadataSequence(event *models.Event) error {
-	return v.saveCurrentSequence(metadataTable, event)
-}
-
-func (v *View) UpdateMetadataSpoolerRunTimestamp() error {
-	return v.updateSpoolerRunSequence(metadataTable)
-}
-
-func (v *View) GetLatestMetadataFailedEvent(sequence uint64) (*global_view.FailedEvent, error) {
-	return v.latestFailedEvent(metadataTable, sequence)
-}
-
-func (v *View) ProcessedMetadataFailedEvent(failedEvent *global_view.FailedEvent) error {
-	return v.saveFailedEvent(failedEvent)
-}

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

@@ -1,32 +0,0 @@
-package view
-
-import (
-	"time"
-
-	"github.com/caos/zitadel/internal/eventstore/v1/models"
-	"github.com/caos/zitadel/internal/view/repository"
-)
-
-const (
-	sequencesTable = "management.current_sequences"
-)
-
-func (v *View) saveCurrentSequence(viewName string, event *models.Event) error {
-	return repository.SaveCurrentSequence(v.Db, sequencesTable, viewName, event.Sequence, event.CreationDate)
-}
-
-func (v *View) latestSequence(viewName string) (*repository.CurrentSequence, error) {
-	return repository.LatestSequence(v.Db, sequencesTable, viewName)
-}
-
-func (v *View) updateSpoolerRunSequence(viewName string) error {
-	currentSequence, err := repository.LatestSequence(v.Db, sequencesTable, viewName)
-	if err != nil {
-		return err
-	}
-	if currentSequence.ViewName == "" {
-		currentSequence.ViewName = viewName
-	}
-	currentSequence.LastSuccessfulSpoolerRun = time.Now()
-	return repository.UpdateCurrentSequence(v.Db, sequencesTable, currentSequence)
-}

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

@@ -1,90 +0,0 @@
-package view
-
-import (
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v1/models"
-	usr_model "github.com/caos/zitadel/internal/user/model"
-	"github.com/caos/zitadel/internal/user/repository/view"
-	"github.com/caos/zitadel/internal/user/repository/view/model"
-	"github.com/caos/zitadel/internal/view/repository"
-)
-
-const (
-	userTable = "management.users"
-)
-
-func (v *View) UserByID(userID string) (*model.UserView, error) {
-	return view.UserByID(v.Db, userTable, userID)
-}
-
-func (v *View) UserByIDAndResourceOwner(userID, resourceOwner string) (*model.UserView, error) {
-	return view.UserByIDAndResourceOwner(v.Db, userTable, userID, resourceOwner)
-}
-
-func (v *View) SearchUsers(request *usr_model.UserSearchRequest) ([]*model.UserView, uint64, error) {
-	return view.SearchUsers(v.Db, userTable, request)
-}
-
-func (v *View) GetGlobalUserByLoginName(loginName string) (*model.UserView, error) {
-	return view.GetGlobalUserByLoginName(v.Db, userTable, loginName)
-}
-
-func (v *View) UsersByOrgID(orgID string) ([]*model.UserView, error) {
-	return view.UsersByOrgID(v.Db, userTable, orgID)
-}
-
-func (v *View) UserIDsByDomain(domain string) ([]string, error) {
-	return view.UserIDsByDomain(v.Db, userTable, domain)
-}
-
-func (v *View) IsUserUnique(userName, email, orgID string) (bool, error) {
-	return view.IsUserUnique(v.Db, userTable, userName, email, orgID)
-}
-
-func (v *View) UserMFAs(userID string) ([]*usr_model.MultiFactor, error) {
-	return view.UserMFAs(v.Db, userTable, userID)
-}
-
-func (v *View) PutUsers(user []*model.UserView, event *models.Event) error {
-	err := view.PutUsers(v.Db, userTable, user...)
-	if err != nil {
-		return err
-	}
-	return v.ProcessedUserSequence(event)
-}
-
-func (v *View) PutUser(user *model.UserView, event *models.Event) error {
-	err := view.PutUser(v.Db, userTable, user)
-	if err != nil {
-		return err
-	}
-	return v.ProcessedUserSequence(event)
-}
-
-func (v *View) DeleteUser(userID string, event *models.Event) error {
-	err := view.DeleteUser(v.Db, userTable, userID)
-	if err != nil && !errors.IsNotFound(err) {
-		return err
-	}
-	return v.ProcessedUserSequence(event)
-}
-
-func (v *View) GetLatestUserSequence() (*repository.CurrentSequence, error) {
-	return v.latestSequence(userTable)
-}
-
-func (v *View) ProcessedUserSequence(event *models.Event) error {
-	return v.saveCurrentSequence(userTable, event)
-}
-
-func (v *View) UpdateUserSpoolerRunTimestamp() error {
-	return v.updateSpoolerRunSequence(userTable)
-}
-
-func (v *View) GetLatestUserFailedEvent(sequence uint64) (*repository.FailedEvent, error) {
-	return v.latestFailedEvent(userTable, sequence)
-}
-
-func (v *View) ProcessedUserFailedEvent(failedEvent *repository.FailedEvent) error {
-	return v.saveFailedEvent(failedEvent)
-}

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

@@ -1,25 +0,0 @@
-package view
-
-import (
-	"database/sql"
-
-	"github.com/jinzhu/gorm"
-)
-
-type View struct {
-	Db *gorm.DB
-}
-
-func StartView(sqlClient *sql.DB) (*View, error) {
-	gorm, err := gorm.Open("postgres", sqlClient)
-	if err != nil {
-		return nil, err
-	}
-	return &View{
-		Db: gorm,
-	}, nil
-}
-
-func (v *View) Health() (err error) {
-	return v.Db.DB().Ping()
-}

internal/management/repository/repository.go

@@ -1,7 +1,6 @@
 package repository
 
 type Repository interface {
-	Health() error
 	ProjectRepository
 	OrgRepository
 	UserRepository

internal/management/repository/user.go

@@ -4,29 +4,9 @@ import (
 	"context"
 	"time"
 
-	"github.com/caos/zitadel/internal/domain"
 	"github.com/caos/zitadel/internal/user/model"
 )
 
 type UserRepository interface {
-	UserByID(ctx context.Context, id string) (*model.UserView, error)
-	UserByIDAndResourceOwner(ctx context.Context, id, resourceOwner string) (*model.UserView, error)
-	SearchUsers(ctx context.Context, request *model.UserSearchRequest, ensureLimit bool) (*model.UserSearchResponse, error)
-	UserIDsByDomain(ctx context.Context, domain string) ([]string, error)
-
-	GetUserByLoginNameGlobal(ctx context.Context, email string) (*model.UserView, error)
-	IsUserUnique(ctx context.Context, userName, email, orgID string) (bool, error)
-
-	GetMetadataByKey(ctx context.Context, userID, resourceOwner, key string) (*domain.Metadata, error)
-	SearchMetadata(ctx context.Context, userID, resourceOwner string, req *domain.MetadataSearchRequest) (*domain.MetadataSearchResponse, error)
-
 	UserChanges(ctx context.Context, id string, lastSequence uint64, limit uint64, sortAscending bool, retention time.Duration) (*model.UserChanges, error)
-
-	ProfileByID(ctx context.Context, userID string) (*model.Profile, error)
-
-	EmailByID(ctx context.Context, userID string) (*model.Email, error)
-
-	PhoneByID(ctx context.Context, userID string) (*model.Phone, error)
-
-	AddressByID(ctx context.Context, userID string) (*model.Address, error)
 }