feat(eventstore): increase parallel write capabilities (#5940)

This implementation increases parallel write capabilities of the eventstore.
Please have a look at the technical advisories: [05](https://zitadel.com/docs/support/advisory/a10005) and  [06](https://zitadel.com/docs/support/advisory/a10006).
The implementation of eventstore.push is rewritten and stored events are migrated to a new table `eventstore.events2`.
If you are using cockroach: make sure that the database user of ZITADEL has `VIEWACTIVITY` grant. This is used to query events.

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

@@ -3,18 +3,15 @@ package handler
 import (
 	"context"
 
-	"github.com/zitadel/logging"
-
+	"github.com/zitadel/zitadel/internal/api/authz"
+	auth_view "github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
 	"github.com/zitadel/zitadel/internal/errors"
 	"github.com/zitadel/zitadel/internal/eventstore"
-	v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
+	"github.com/zitadel/zitadel/internal/eventstore/handler/v2"
 	es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
-	"github.com/zitadel/zitadel/internal/eventstore/v1/query"
-	es_sdk "github.com/zitadel/zitadel/internal/eventstore/v1/sdk"
-	"github.com/zitadel/zitadel/internal/eventstore/v1/spooler"
 	org_model "github.com/zitadel/zitadel/internal/org/model"
 	org_es_model "github.com/zitadel/zitadel/internal/org/repository/eventsourcing/model"
-	"github.com/zitadel/zitadel/internal/org/repository/view"
+	org_view "github.com/zitadel/zitadel/internal/org/repository/view"
 	query2 "github.com/zitadel/zitadel/internal/query"
 	"github.com/zitadel/zitadel/internal/repository/instance"
 	"github.com/zitadel/zitadel/internal/repository/org"
@@ -28,202 +25,405 @@ const (
 )
 
 type User struct {
-	handler
-	subscription *v1.Subscription
-	queries      *query2.Queries
+	view    *auth_view.View
+	queries *query2.Queries
+	es      handler.EventStore
 }
 
+var _ handler.Projection = (*User)(nil)
+
 func newUser(
 	ctx context.Context,
-	handler handler,
+	config handler.Config,
+	view *auth_view.View,
 	queries *query2.Queries,
-) *User {
-	h := &User{
-		handler: handler,
-		queries: queries,
-	}
-
-	h.subscribe(ctx)
-
-	return h
+) *handler.Handler {
+	return handler.NewHandler(
+		ctx,
+		&config,
+		&User{
+			view:    view,
+			queries: queries,
+			es:      config.Eventstore,
+		},
+	)
 }
 
-func (u *User) subscribe(ctx context.Context) {
-	u.subscription = u.es.Subscribe(u.AggregateTypes()...)
-	go func() {
-		for event := range u.subscription.Events {
-			query.ReduceEvent(ctx, u, event)
-		}
-	}()
-}
-
-func (u *User) ViewModel() string {
+func (*User) Name() string {
 	return userTable
 }
-
-func (u *User) Subscription() *v1.Subscription {
-	return u.subscription
-}
-func (_ *User) AggregateTypes() []es_models.AggregateType {
-	return []es_models.AggregateType{user_repo.AggregateType, org.AggregateType, instance.AggregateType}
-}
-
-func (u *User) CurrentSequence(ctx context.Context, instanceID string) (uint64, error) {
-	sequence, err := u.view.GetLatestUserSequence(ctx, instanceID)
-	if err != nil {
-		return 0, err
-	}
-	return sequence.CurrentSequence, nil
-}
-
-func (u *User) EventQuery(ctx context.Context, instanceIDs []string) (*es_models.SearchQuery, error) {
-	sequences, err := u.view.GetLatestUserSequences(ctx, instanceIDs)
-	if err != nil {
-		return nil, err
-	}
-	return newSearchQuery(sequences, u.AggregateTypes(), instanceIDs), nil
-}
-
-func (u *User) Reduce(event *es_models.Event) (err error) {
-	switch event.AggregateType {
-	case user_repo.AggregateType:
-		return u.ProcessUser(event)
-	case org.AggregateType:
-		return u.ProcessOrg(event)
-	case instance.AggregateType:
-		return u.ProcessInstance(event)
-	default:
-		return nil
+func (u *User) Reducers() []handler.AggregateReducer {
+	return []handler.AggregateReducer{
+		{
+			Aggregate: user_repo.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  user_repo.HumanOTPSMSAddedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanOTPSMSRemovedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanOTPEmailAddedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanOTPEmailRemovedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.MachineAddedEventType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanAddedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1AddedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1RegisteredType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanRegisteredType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1ProfileChangedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1EmailChangedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1EmailVerifiedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1PhoneChangedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1PhoneVerifiedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1PhoneRemovedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1AddressChangedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserDeactivatedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserReactivatedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserLockedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserUnlockedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1MFAOTPAddedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1MFAOTPVerifiedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1MFAOTPRemovedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1MFAInitSkippedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1PasswordChangedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanProfileChangedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanEmailChangedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanEmailVerifiedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanAvatarAddedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanAvatarRemovedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanPhoneChangedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanPhoneVerifiedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanPhoneRemovedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanAddressChangedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanMFAOTPAddedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanMFAOTPVerifiedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanMFAOTPRemovedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanU2FTokenAddedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanU2FTokenVerifiedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanU2FTokenRemovedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanPasswordlessTokenAddedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanPasswordlessTokenVerifiedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanPasswordlessTokenRemovedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanMFAInitSkippedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.MachineChangedEventType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanPasswordChangedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanInitialCodeAddedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1InitialCodeAddedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserV1InitializedCheckSucceededType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanInitializedCheckSucceededType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanPasswordlessInitCodeAddedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.HumanPasswordlessInitCodeRequestedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserDomainClaimedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserUserNameChangedType,
+					Reduce: u.ProcessUser,
+				},
+				{
+					Event:  user_repo.UserRemovedType,
+					Reduce: u.ProcessUser,
+				},
+			},
+		},
+		{
+			Aggregate: org.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  org.OrgDomainVerifiedEventType,
+					Reduce: u.ProcessOrg,
+				},
+				{
+					Event:  org.OrgDomainRemovedEventType,
+					Reduce: u.ProcessOrg,
+				},
+				{
+					Event:  org.DomainPolicyAddedEventType,
+					Reduce: u.ProcessOrg,
+				},
+				{
+					Event:  org.DomainPolicyChangedEventType,
+					Reduce: u.ProcessOrg,
+				},
+				{
+					Event:  org.DomainPolicyRemovedEventType,
+					Reduce: u.ProcessOrg,
+				},
+				{
+					Event:  org.OrgDomainPrimarySetEventType,
+					Reduce: u.ProcessOrg,
+				},
+				{
+					Event:  org.OrgRemovedEventType,
+					Reduce: u.ProcessOrg,
+				},
+			},
+		},
+		{
+			Aggregate: instance.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  instance.InstanceRemovedEventType,
+					Reduce: u.ProcessInstance,
+				},
+			},
+		},
 	}
 }
 
-func (u *User) ProcessUser(event *es_models.Event) (err error) {
-	user := new(view_model.UserView)
-	switch eventstore.EventType(event.Type) {
-	case user_repo.UserV1AddedType,
-		user_repo.MachineAddedEventType,
-		user_repo.HumanAddedType,
-		user_repo.UserV1RegisteredType,
-		user_repo.HumanRegisteredType:
-		err = user.AppendEvent(event)
-		if err != nil {
-			return err
-		}
-		err = u.fillLoginNames(user)
-	case user_repo.UserV1ProfileChangedType,
-		user_repo.UserV1EmailChangedType,
-		user_repo.UserV1EmailVerifiedType,
-		user_repo.UserV1PhoneChangedType,
-		user_repo.UserV1PhoneVerifiedType,
-		user_repo.UserV1PhoneRemovedType,
-		user_repo.UserV1AddressChangedType,
-		user_repo.UserDeactivatedType,
-		user_repo.UserReactivatedType,
-		user_repo.UserLockedType,
-		user_repo.UserUnlockedType,
-		user_repo.UserV1MFAOTPAddedType,
-		user_repo.UserV1MFAOTPVerifiedType,
-		user_repo.UserV1MFAOTPRemovedType,
-		user_repo.UserV1MFAInitSkippedType,
-		user_repo.UserV1PasswordChangedType,
-		user_repo.HumanProfileChangedType,
-		user_repo.HumanEmailChangedType,
-		user_repo.HumanEmailVerifiedType,
-		user_repo.HumanAvatarAddedType,
-		user_repo.HumanAvatarRemovedType,
-		user_repo.HumanPhoneChangedType,
-		user_repo.HumanPhoneVerifiedType,
-		user_repo.HumanPhoneRemovedType,
-		user_repo.HumanAddressChangedType,
-		user_repo.HumanMFAOTPAddedType,
-		user_repo.HumanMFAOTPVerifiedType,
-		user_repo.HumanMFAOTPRemovedType,
-		user_repo.HumanOTPSMSAddedType,
-		user_repo.HumanOTPSMSRemovedType,
-		user_repo.HumanOTPEmailAddedType,
-		user_repo.HumanOTPEmailRemovedType,
-		user_repo.HumanU2FTokenAddedType,
-		user_repo.HumanU2FTokenVerifiedType,
-		user_repo.HumanU2FTokenRemovedType,
-		user_repo.HumanPasswordlessTokenAddedType,
-		user_repo.HumanPasswordlessTokenVerifiedType,
-		user_repo.HumanPasswordlessTokenRemovedType,
-		user_repo.HumanMFAInitSkippedType,
-		user_repo.MachineChangedEventType,
-		user_repo.HumanPasswordChangedType,
-		user_repo.HumanInitialCodeAddedType,
-		user_repo.UserV1InitialCodeAddedType,
-		user_repo.UserV1InitializedCheckSucceededType,
-		user_repo.HumanInitializedCheckSucceededType,
-		user_repo.HumanPasswordlessInitCodeAddedType,
-		user_repo.HumanPasswordlessInitCodeRequestedType:
-		user, err = u.view.UserByID(event.AggregateID, event.InstanceID)
-		if err != nil {
-			if !errors.IsNotFound(err) {
-				return err
-			}
-			logging.WithFields(
-				"instance", event.InstanceID,
-				"userID", event.AggregateID,
-				"eventType", event.Type,
-			).Info("user not found in view")
-			query, err := usr_view.UserByIDQuery(event.AggregateID, event.InstanceID, 0, user.EventTypes())
+//nolint:gocognit
+func (u *User) ProcessUser(event eventstore.Event) (_ *handler.Statement, err error) {
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		user := new(view_model.UserView)
+		switch event.Type() {
+		case user_repo.UserV1AddedType,
+			user_repo.MachineAddedEventType,
+			user_repo.HumanAddedType,
+			user_repo.UserV1RegisteredType,
+			user_repo.HumanRegisteredType:
+			err = user.AppendEvent(event)
 			if err != nil {
 				return err
 			}
-			events, err := u.es.FilterEvents(context.Background(), query)
+			err = u.fillLoginNames(user)
+		case user_repo.UserV1ProfileChangedType,
+			user_repo.UserV1EmailChangedType,
+			user_repo.UserV1EmailVerifiedType,
+			user_repo.UserV1PhoneChangedType,
+			user_repo.UserV1PhoneVerifiedType,
+			user_repo.UserV1PhoneRemovedType,
+			user_repo.UserV1AddressChangedType,
+			user_repo.UserDeactivatedType,
+			user_repo.UserReactivatedType,
+			user_repo.UserLockedType,
+			user_repo.UserUnlockedType,
+			user_repo.UserV1MFAOTPAddedType,
+			user_repo.UserV1MFAOTPVerifiedType,
+			user_repo.UserV1MFAOTPRemovedType,
+			user_repo.UserV1MFAInitSkippedType,
+			user_repo.UserV1PasswordChangedType,
+			user_repo.HumanProfileChangedType,
+			user_repo.HumanEmailChangedType,
+			user_repo.HumanEmailVerifiedType,
+			user_repo.HumanAvatarAddedType,
+			user_repo.HumanAvatarRemovedType,
+			user_repo.HumanPhoneChangedType,
+			user_repo.HumanPhoneVerifiedType,
+			user_repo.HumanPhoneRemovedType,
+			user_repo.HumanAddressChangedType,
+			user_repo.HumanMFAOTPAddedType,
+			user_repo.HumanMFAOTPVerifiedType,
+			user_repo.HumanMFAOTPRemovedType,
+			user_repo.HumanOTPSMSAddedType,
+			user_repo.HumanOTPSMSRemovedType,
+			user_repo.HumanOTPEmailAddedType,
+			user_repo.HumanOTPEmailRemovedType,
+			user_repo.HumanU2FTokenAddedType,
+			user_repo.HumanU2FTokenVerifiedType,
+			user_repo.HumanU2FTokenRemovedType,
+			user_repo.HumanPasswordlessTokenAddedType,
+			user_repo.HumanPasswordlessTokenVerifiedType,
+			user_repo.HumanPasswordlessTokenRemovedType,
+			user_repo.HumanMFAInitSkippedType,
+			user_repo.MachineChangedEventType,
+			user_repo.HumanPasswordChangedType,
+			user_repo.HumanInitialCodeAddedType,
+			user_repo.UserV1InitialCodeAddedType,
+			user_repo.UserV1InitializedCheckSucceededType,
+			user_repo.HumanInitializedCheckSucceededType,
+			user_repo.HumanPasswordlessInitCodeAddedType,
+			user_repo.HumanPasswordlessInitCodeRequestedType:
+			user, err = u.view.UserByID(event.Aggregate().ID, event.Aggregate().InstanceID)
 			if err != nil {
-				return err
-			}
-			user = &view_model.UserView{}
-			for _, e := range events {
-				if err = user.AppendEvent(e); err != nil {
+				if !errors.IsNotFound(err) {
+					return err
+				}
+				user, err = u.userFromEventstore(event.Aggregate(), user.EventTypes())
+				if err != nil {
 					return err
 				}
 			}
-		}
-		err = user.AppendEvent(event)
-	case user_repo.UserDomainClaimedType,
-		user_repo.UserUserNameChangedType:
-		user, err = u.view.UserByID(event.AggregateID, event.InstanceID)
-		if err != nil {
-			if !errors.IsNotFound(err) {
-				return err
-			}
-			logging.WithFields(
-				"instance", event.InstanceID,
-				"userID", event.AggregateID,
-				"eventType", event.Type,
-			).Info("user not found in view")
-			query, err := usr_view.UserByIDQuery(event.AggregateID, event.InstanceID, 0, user.EventTypes())
+			err = user.AppendEvent(event)
+		case user_repo.UserDomainClaimedType,
+			user_repo.UserUserNameChangedType:
+			user, err = u.view.UserByID(event.Aggregate().ID, event.Aggregate().InstanceID)
 			if err != nil {
-				return err
-			}
-			events, err := u.es.FilterEvents(context.Background(), query)
-			if err != nil {
-				return err
-			}
-			user = &view_model.UserView{}
-			for _, e := range events {
-				if err = user.AppendEvent(e); err != nil {
+				if !errors.IsNotFound(err) {
+					return err
+				}
+				user, err = u.userFromEventstore(event.Aggregate(), user.EventTypes())
+				if err != nil {
 					return err
 				}
 			}
+			err = user.AppendEvent(event)
+			if err != nil {
+				return err
+			}
+			err = u.fillLoginNames(user)
+		case user_repo.UserRemovedType:
+			return u.view.DeleteUser(event.Aggregate().ID, event.Aggregate().InstanceID, event)
+		default:
+			return nil
 		}
-		err = user.AppendEvent(event)
 		if err != nil {
 			return err
 		}
-		err = u.fillLoginNames(user)
-	case user_repo.UserRemovedType:
-		return u.view.DeleteUser(event.AggregateID, event.InstanceID, event)
-	default:
-		return u.view.ProcessedUserSequence(event)
-	}
-	if err != nil {
-		return err
-	}
-	return u.view.PutUser(user, event)
+		return u.view.PutUser(user, event)
+	}), nil
 }
 
 func (u *User) fillLoginNames(user *view_model.UserView) (err error) {
@@ -236,38 +436,44 @@ func (u *User) fillLoginNames(user *view_model.UserView) (err error) {
 	return nil
 }
 
-func (u *User) ProcessOrg(event *es_models.Event) (err error) {
-	switch eventstore.EventType(event.Type) {
-	case org.OrgDomainVerifiedEventType,
-		org.OrgDomainRemovedEventType,
-		org.DomainPolicyAddedEventType,
-		org.DomainPolicyChangedEventType,
-		org.DomainPolicyRemovedEventType:
-		return u.fillLoginNamesOnOrgUsers(event)
-	case org.OrgDomainPrimarySetEventType:
-		return u.fillPreferredLoginNamesOnOrgUsers(event)
-	case org.OrgRemovedEventType:
-		return u.view.UpdateOrgOwnerRemovedUsers(event)
-	default:
-		return u.view.ProcessedUserSequence(event)
-	}
+func (u *User) ProcessOrg(event eventstore.Event) (_ *handler.Statement, err error) {
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		switch event.Type() {
+		case org.OrgDomainVerifiedEventType,
+			org.OrgDomainRemovedEventType,
+			org.DomainPolicyAddedEventType,
+			org.DomainPolicyChangedEventType,
+			org.DomainPolicyRemovedEventType:
+			return u.fillLoginNamesOnOrgUsers(event)
+		case org.OrgDomainPrimarySetEventType:
+			return u.fillPreferredLoginNamesOnOrgUsers(event)
+		case org.OrgRemovedEventType:
+			return u.view.UpdateOrgOwnerRemovedUsers(event)
+		default:
+			return nil
+		}
+	}), nil
 }
 
-func (u *User) ProcessInstance(event *es_models.Event) (err error) {
-	switch eventstore.EventType(event.Type) {
+func (u *User) ProcessInstance(event eventstore.Event) (_ *handler.Statement, err error) {
+	switch event.Type() {
 	case instance.InstanceRemovedEventType:
-		return u.view.DeleteInstanceUsers(event)
+		return handler.NewStatement(event,
+			func(ex handler.Executer, projectionName string) error {
+				return u.view.DeleteInstanceUsers(event)
+			},
+		), nil
 	default:
-		return u.view.ProcessedUserSequence(event)
+		return handler.NewNoOpStatement(event), nil
 	}
 }
 
-func (u *User) fillLoginNamesOnOrgUsers(event *es_models.Event) error {
-	userLoginMustBeDomain, _, domains, err := u.loginNameInformation(context.Background(), event.ResourceOwner, event.InstanceID)
+func (u *User) fillLoginNamesOnOrgUsers(event eventstore.Event) error {
+	userLoginMustBeDomain, _, domains, err := u.loginNameInformation(context.Background(), event.Aggregate().ResourceOwner, event.Aggregate().InstanceID)
 	if err != nil {
 		return err
 	}
-	users, err := u.view.UsersByOrgID(event.AggregateID, event.InstanceID)
+	users, err := u.view.UsersByOrgID(event.Aggregate().ID, event.Aggregate().InstanceID)
 	if err != nil {
 		return err
 	}
@@ -277,15 +483,15 @@ func (u *User) fillLoginNamesOnOrgUsers(event *es_models.Event) error {
 	return u.view.PutUsers(users, event)
 }
 
-func (u *User) fillPreferredLoginNamesOnOrgUsers(event *es_models.Event) error {
-	userLoginMustBeDomain, primaryDomain, _, err := u.loginNameInformation(context.Background(), event.ResourceOwner, event.InstanceID)
+func (u *User) fillPreferredLoginNamesOnOrgUsers(event eventstore.Event) error {
+	userLoginMustBeDomain, primaryDomain, _, err := u.loginNameInformation(context.Background(), event.Aggregate().ResourceOwner, event.Aggregate().InstanceID)
 	if err != nil {
 		return err
 	}
 	if !userLoginMustBeDomain {
 		return nil
 	}
-	users, err := u.view.UsersByOrgID(event.AggregateID, event.InstanceID)
+	users, err := u.view.UsersByOrgID(event.Aggregate().ID, event.Aggregate().InstanceID)
 	if err != nil {
 		return err
 	}
@@ -295,17 +501,8 @@ func (u *User) fillPreferredLoginNamesOnOrgUsers(event *es_models.Event) error {
 	return u.view.PutUsers(users, event)
 }
 
-func (u *User) OnError(event *es_models.Event, err error) error {
-	logging.WithFields("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(instanceIDs []string) error {
-	return spooler.HandleSuccess(u.view.UpdateUserSpoolerRunTimestamp, instanceIDs)
-}
-
 func (u *User) getOrgByID(ctx context.Context, orgID, instanceID string) (*org_model.Org, error) {
-	orgQuery, err := view.OrgByIDQuery(orgID, instanceID, 0)
+	query, err := org_view.OrgByIDQuery(orgID, instanceID, 0)
 	if err != nil {
 		return nil, err
 	}
@@ -315,8 +512,11 @@ func (u *User) getOrgByID(ctx context.Context, orgID, instanceID string) (*org_m
 			AggregateID: orgID,
 		},
 	}
-	err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, esOrg.AppendEvents, orgQuery)
-	if err != nil && !errors.IsNotFound(err) {
+	events, err := u.es.Filter(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	if err = esOrg.AppendEvents(events...); err != nil {
 		return nil, err
 	}
 	if esOrg.Sequence == 0 {
@@ -334,9 +534,27 @@ func (u *User) loginNameInformation(ctx context.Context, orgID string, instanceI
 	if org.DomainPolicy != nil {
 		return org.DomainPolicy.UserLoginMustBeDomain, org.GetPrimaryDomain().Domain, org.Domains, nil
 	}
-	policy, err := u.queries.DefaultDomainPolicy(withInstanceID(ctx, org.InstanceID))
+	policy, err := u.queries.DefaultDomainPolicy(authz.WithInstanceID(ctx, org.InstanceID))
 	if err != nil {
 		return false, "", nil, err
 	}
 	return policy.UserLoginMustBeDomain, org.GetPrimaryDomain().Domain, org.Domains, nil
 }
+
+func (u *User) userFromEventstore(agg *eventstore.Aggregate, eventTypes []eventstore.EventType) (*view_model.UserView, error) {
+	query, err := usr_view.UserByIDQuery(agg.ID, agg.InstanceID, 0, eventTypes)
+	if err != nil {
+		return nil, err
+	}
+	events, err := u.es.Filter(context.Background(), query)
+	if err != nil {
+		return nil, err
+	}
+	user := &view_model.UserView{}
+	for _, e := range events {
+		if err = user.AppendEvent(e); err != nil {
+			return nil, err
+		}
+	}
+	return user, nil
+}