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/handler.go

@@ -4,84 +4,68 @@ import (
 	"context"
 	"time"
 
-	"github.com/zitadel/zitadel/internal/api/authz"
 	"github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
-	v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
-	"github.com/zitadel/zitadel/internal/eventstore/v1/models"
-	"github.com/zitadel/zitadel/internal/eventstore/v1/query"
+	"github.com/zitadel/zitadel/internal/database"
+	"github.com/zitadel/zitadel/internal/eventstore"
+	handler2 "github.com/zitadel/zitadel/internal/eventstore/handler/v2"
 	query2 "github.com/zitadel/zitadel/internal/query"
-	"github.com/zitadel/zitadel/internal/view/repository"
 )
 
-type Configs map[string]*Config
-
 type Config struct {
+	Client     *database.DB
+	Eventstore *eventstore.Eventstore
+
+	BulkLimit             uint64
+	FailureCountUntilSkip uint64
+	HandleActiveInstances time.Duration
+	TransactionDuration   time.Duration
+	Handlers              map[string]*ConfigOverwrites
+}
+
+type ConfigOverwrites struct {
 	MinimumCycleDuration time.Duration
 }
 
-type handler struct {
-	view                *view.View
-	bulkLimit           uint64
-	cycleDuration       time.Duration
-	errorCountUntilSkip uint64
+func Register(ctx context.Context, configs Config, view *view.View, queries *query2.Queries) {
+	newUser(ctx,
+		configs.overwrite("User"),
+		view,
+		queries,
+	).Start(ctx)
 
-	es v1.Eventstore
+	newUserSession(ctx,
+		configs.overwrite("UserSession"),
+		view,
+		queries,
+	).Start(ctx)
+
+	newToken(ctx,
+		configs.overwrite("Token"),
+		view,
+	).Start(ctx)
+
+	newRefreshToken(ctx,
+		configs.overwrite("RefreshToken"),
+		view,
+	).Start(ctx)
 }
 
-func (h *handler) Eventstore() v1.Eventstore {
-	return h.es
-}
-
-func Register(ctx context.Context, configs Configs, bulkLimit, errorCount uint64, view *view.View, es v1.Eventstore, queries *query2.Queries) []query.Handler {
-	return []query.Handler{
-		newUser(ctx,
-			handler{view, bulkLimit, configs.cycleDuration("User"), errorCount, es}, queries),
-		newUserSession(ctx,
-			handler{view, bulkLimit, configs.cycleDuration("UserSession"), errorCount, es}, queries),
-		newToken(ctx,
-			handler{view, bulkLimit, configs.cycleDuration("Token"), errorCount, es}),
-		newRefreshToken(ctx, handler{view, bulkLimit, configs.cycleDuration("RefreshToken"), errorCount, es}),
+func (config Config) overwrite(viewModel string) handler2.Config {
+	c := handler2.Config{
+		Client:                config.Client,
+		Eventstore:            config.Eventstore,
+		BulkLimit:             uint16(config.BulkLimit),
+		RequeueEvery:          3 * time.Minute,
+		HandleActiveInstances: config.HandleActiveInstances,
+		MaxFailureCount:       uint8(config.FailureCountUntilSkip),
+		TransactionDuration:   config.TransactionDuration,
 	}
-}
-
-func (configs Configs) cycleDuration(viewModel string) time.Duration {
-	c, ok := configs[viewModel]
+	overwrite, ok := config.Handlers[viewModel]
 	if !ok {
-		return 3 * time.Minute
+		return c
 	}
-	return c.MinimumCycleDuration
-}
-
-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
-}
-
-func withInstanceID(ctx context.Context, instanceID string) context.Context {
-	return authz.WithInstanceID(ctx, instanceID)
-}
-
-func newSearchQuery(sequences []*repository.CurrentSequence, aggregateTypes []models.AggregateType, instanceIDs []string) *models.SearchQuery {
-	searchQuery := models.NewSearchQuery()
-	for _, instanceID := range instanceIDs {
-		var seq uint64
-		for _, sequence := range sequences {
-			if sequence.InstanceID == instanceID {
-				seq = sequence.CurrentSequence
-				break
-			}
-		}
-		searchQuery.AddQuery().
-			AggregateTypeFilter(aggregateTypes...).
-			LatestSequenceFilter(seq).
-			InstanceIDFilter(instanceID)
+	if overwrite.MinimumCycleDuration > 0 {
+		c.RequeueEvery = overwrite.MinimumCycleDuration
 	}
-	return searchQuery
+	return c
 }

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

@@ -2,19 +2,15 @@ package handler
 
 import (
 	"context"
-	"encoding/json"
 
 	"github.com/zitadel/logging"
 
+	auth_view "github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
 	caos_errs "github.com/zitadel/zitadel/internal/errors"
 	"github.com/zitadel/zitadel/internal/eventstore"
-	v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
-	es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
-	"github.com/zitadel/zitadel/internal/eventstore/v1/query"
-	"github.com/zitadel/zitadel/internal/eventstore/v1/spooler"
+	"github.com/zitadel/zitadel/internal/eventstore/handler/v2"
 	"github.com/zitadel/zitadel/internal/repository/instance"
 	"github.com/zitadel/zitadel/internal/repository/org"
-	"github.com/zitadel/zitadel/internal/repository/project"
 	"github.com/zitadel/zitadel/internal/repository/user"
 	view_model "github.com/zitadel/zitadel/internal/user/repository/view/model"
 )
@@ -23,110 +19,129 @@ const (
 	refreshTokenTable = "auth.refresh_tokens"
 )
 
+var _ handler.Projection = (*RefreshToken)(nil)
+
 type RefreshToken struct {
-	handler
-	subscription *v1.Subscription
+	view *auth_view.View
 }
 
 func newRefreshToken(
 	ctx context.Context,
-	handler handler,
-) *RefreshToken {
-	h := &RefreshToken{
-		handler: handler,
-	}
-
-	h.subscribe(ctx)
-
-	return h
+	config handler.Config,
+	view *auth_view.View,
+) *handler.Handler {
+	return handler.NewHandler(
+		ctx,
+		&config,
+		&RefreshToken{
+			view: view,
+		},
+	)
 }
 
-func (t *RefreshToken) subscribe(ctx context.Context) {
-	t.subscription = t.es.Subscribe(t.AggregateTypes()...)
-	go func() {
-		for event := range t.subscription.Events {
-			query.ReduceEvent(ctx, t, event)
-		}
-	}()
-}
-
-func (t *RefreshToken) ViewModel() string {
+// Name implements [handler.Projection]
+func (*RefreshToken) Name() string {
 	return refreshTokenTable
 }
 
-func (t *RefreshToken) Subscription() *v1.Subscription {
-	return t.subscription
-}
-
-func (t *RefreshToken) AggregateTypes() []es_models.AggregateType {
-	return []es_models.AggregateType{user.AggregateType, project.AggregateType, instance.AggregateType}
-}
-
-func (t *RefreshToken) CurrentSequence(ctx context.Context, instanceID string) (uint64, error) {
-	sequence, err := t.view.GetLatestRefreshTokenSequence(ctx, instanceID)
-	if err != nil {
-		return 0, err
-	}
-	return sequence.CurrentSequence, nil
-}
-
-func (t *RefreshToken) EventQuery(ctx context.Context, instanceIDs []string) (*es_models.SearchQuery, error) {
-	sequences, err := t.view.GetLatestRefreshTokenSequences(ctx, instanceIDs)
-	if err != nil {
-		return nil, err
-	}
-	return newSearchQuery(sequences, t.AggregateTypes(), instanceIDs), nil
-}
-
-func (t *RefreshToken) Reduce(event *es_models.Event) (err error) {
-	switch eventstore.EventType(event.Type) {
-	case user.HumanRefreshTokenAddedType:
-		token := new(view_model.RefreshTokenView)
-		err := token.AppendEvent(event)
-		if err != nil {
-			return err
-		}
-		return t.view.PutRefreshToken(token, event)
-	case user.HumanRefreshTokenRenewedType:
-		e := new(user.HumanRefreshTokenRenewedEvent)
-		if err := json.Unmarshal(event.Data, e); err != nil {
-			logging.WithError(err).Error("could not unmarshal event data")
-			return caos_errs.ThrowInternal(nil, "MODEL-BHn75", "could not unmarshal data")
-		}
-		token, err := t.view.RefreshTokenByID(e.TokenID, event.InstanceID)
-		if err != nil {
-			return err
-		}
-		err = token.AppendEvent(event)
-		if err != nil {
-			return err
-		}
-		return t.view.PutRefreshToken(token, event)
-	case user.HumanRefreshTokenRemovedType:
-		e := new(user.HumanRefreshTokenRemovedEvent)
-		if err := json.Unmarshal(event.Data, e); err != nil {
-			logging.WithError(err).Error("could not unmarshal event data")
-			return caos_errs.ThrowInternal(nil, "MODEL-Bz653", "could not unmarshal data")
-		}
-		return t.view.DeleteRefreshToken(e.TokenID, event.InstanceID, event)
-	case user.UserLockedType,
-		user.UserDeactivatedType,
-		user.UserRemovedType:
-		return t.view.DeleteUserRefreshTokens(event.AggregateID, event.InstanceID, event)
-	case instance.InstanceRemovedEventType:
-		return t.view.DeleteInstanceRefreshTokens(event)
-	case org.OrgRemovedEventType:
-		return t.view.DeleteOrgRefreshTokens(event)
-	default:
-		return t.view.ProcessedRefreshTokenSequence(event)
+// Reducers implements [handler.Projection]
+func (t *RefreshToken) Reducers() []handler.AggregateReducer {
+	return []handler.AggregateReducer{
+		{
+			Aggregate: user.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  user.HumanRefreshTokenAddedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.HumanRefreshTokenRenewedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.HumanRefreshTokenRemovedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.UserLockedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.UserDeactivatedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.UserRemovedType,
+					Reduce: t.Reduce,
+				},
+			},
+		},
+		{
+			Aggregate: instance.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  instance.InstanceRemovedEventType,
+					Reduce: t.Reduce,
+				},
+			},
+		},
+		{
+			Aggregate: org.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  org.OrgRemovedEventType,
+					Reduce: t.Reduce,
+				},
+			},
+		},
 	}
 }
 
-func (t *RefreshToken) OnError(event *es_models.Event, err error) error {
-	logging.WithFields("id", event.AggregateID).WithError(err).Warn("something went wrong in token handler")
-	return spooler.HandleError(event, err, t.view.GetLatestRefreshTokenFailedEvent, t.view.ProcessedRefreshTokenFailedEvent, t.view.ProcessedRefreshTokenSequence, t.errorCountUntilSkip)
-}
+func (t *RefreshToken) Reduce(event eventstore.Event) (_ *handler.Statement, err error) {
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		switch event.Type() {
+		case user.HumanRefreshTokenAddedType:
+			token := new(view_model.RefreshTokenView)
+			err := token.AppendEvent(event)
+			if err != nil {
+				return err
+			}
 
-func (t *RefreshToken) OnSuccess(instanceIDs []string) error {
-	return spooler.HandleSuccess(t.view.UpdateRefreshTokenSpoolerRunTimestamp, instanceIDs)
+			return t.view.PutRefreshToken(token)
+		case user.HumanRefreshTokenRenewedType:
+			e := new(user.HumanRefreshTokenRenewedEvent)
+			if err := event.Unmarshal(e); err != nil {
+				logging.WithError(err).Error("could not unmarshal event data")
+				return caos_errs.ThrowInternal(nil, "MODEL-BHn75", "could not unmarshal data")
+			}
+			token, err := t.view.RefreshTokenByID(e.TokenID, event.Aggregate().InstanceID)
+			if err != nil {
+				return err
+			}
+			err = token.AppendEvent(event)
+			if err != nil {
+				return err
+			}
+			return t.view.PutRefreshToken(token)
+		case user.HumanRefreshTokenRemovedType:
+			e := new(user.HumanRefreshTokenRemovedEvent)
+			if err := event.Unmarshal(e); err != nil {
+				logging.WithError(err).Error("could not unmarshal event data")
+				return caos_errs.ThrowInternal(nil, "MODEL-Bz653", "could not unmarshal data")
+			}
+			return t.view.DeleteRefreshToken(e.TokenID, event.Aggregate().InstanceID)
+		case user.UserLockedType,
+			user.UserDeactivatedType,
+			user.UserRemovedType:
+
+			return t.view.DeleteUserRefreshTokens(event.Aggregate().ID, event.Aggregate().InstanceID)
+		case instance.InstanceRemovedEventType:
+
+			return t.view.DeleteInstanceRefreshTokens(event.Aggregate().InstanceID)
+		case org.OrgRemovedEventType:
+			return t.view.DeleteOrgRefreshTokens(event)
+		default:
+			return nil
+		}
+	}), nil
 }

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

@@ -2,17 +2,14 @@ package handler
 
 import (
 	"context"
-	"encoding/json"
 
 	"github.com/zitadel/logging"
 
+	auth_view "github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
 	caos_errs "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"
 	proj_model "github.com/zitadel/zitadel/internal/project/model"
 	project_es_model "github.com/zitadel/zitadel/internal/project/repository/eventsourcing/model"
 	proj_view "github.com/zitadel/zitadel/internal/project/repository/view"
@@ -20,7 +17,6 @@ import (
 	"github.com/zitadel/zitadel/internal/repository/org"
 	"github.com/zitadel/zitadel/internal/repository/project"
 	"github.com/zitadel/zitadel/internal/repository/user"
-	user_repo "github.com/zitadel/zitadel/internal/repository/user"
 	view_model "github.com/zitadel/zitadel/internal/user/repository/view/model"
 )
 
@@ -28,189 +24,258 @@ const (
 	tokenTable = "auth.tokens"
 )
 
+var _ handler.Projection = (*Token)(nil)
+
 type Token struct {
-	handler
-	subscription *v1.Subscription
+	view *auth_view.View
+	es   handler.EventStore
 }
 
 func newToken(
 	ctx context.Context,
-	handler handler,
-) *Token {
-	h := &Token{
-		handler: handler,
-	}
-
-	h.subscribe(ctx)
-
-	return h
+	config handler.Config,
+	view *auth_view.View,
+) *handler.Handler {
+	return handler.NewHandler(
+		ctx,
+		&config,
+		&Token{
+			view: view,
+			es:   config.Eventstore,
+		},
+	)
 }
 
-func (t *Token) subscribe(ctx context.Context) {
-	t.subscription = t.es.Subscribe(t.AggregateTypes()...)
-	go func() {
-		for event := range t.subscription.Events {
-			query.ReduceEvent(ctx, t, event)
-		}
-	}()
-}
-
-func (t *Token) ViewModel() string {
+// Name implements [handler.Projection]
+func (*Token) Name() string {
 	return tokenTable
 }
 
-func (t *Token) Subscription() *v1.Subscription {
-	return t.subscription
-}
-
-func (_ *Token) AggregateTypes() []es_models.AggregateType {
-	return []es_models.AggregateType{user.AggregateType, project.AggregateType, instance.AggregateType}
-}
-
-func (t *Token) CurrentSequence(ctx context.Context, instanceID string) (uint64, error) {
-	sequence, err := t.view.GetLatestTokenSequence(ctx, instanceID)
-	if err != nil {
-		return 0, err
+// Reducers implements [handler.Projection]
+func (t *Token) Reducers() []handler.AggregateReducer {
+	return []handler.AggregateReducer{
+		{
+			Aggregate: user.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  user.PersonalAccessTokenAddedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.UserTokenAddedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.UserV1ProfileChangedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.HumanProfileChangedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.UserV1SignedOutType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.HumanSignedOutType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.UserLockedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.UserDeactivatedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.UserRemovedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.UserTokenRemovedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.PersonalAccessTokenRemovedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  user.HumanRefreshTokenRemovedType,
+					Reduce: t.Reduce,
+				},
+			},
+		},
+		{
+			Aggregate: project.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  project.ApplicationDeactivatedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  project.ApplicationRemovedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  project.ProjectDeactivatedType,
+					Reduce: t.Reduce,
+				},
+				{
+					Event:  project.ProjectRemovedType,
+					Reduce: t.Reduce,
+				},
+			},
+		},
+		{
+			Aggregate: org.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  org.OrgRemovedEventType,
+					Reduce: t.Reduce,
+				},
+			},
+		},
+		{
+			Aggregate: instance.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  instance.InstanceRemovedEventType,
+					Reduce: t.Reduce,
+				},
+			},
+		},
 	}
-	return sequence.CurrentSequence, nil
 }
 
-func (t *Token) EventQuery(ctx context.Context, instanceIDs []string) (*es_models.SearchQuery, error) {
-	sequences, err := t.view.GetLatestTokenSequences(ctx, instanceIDs)
-	if err != nil {
-		return nil, err
-	}
-	return newSearchQuery(sequences, t.AggregateTypes(), instanceIDs), nil
-}
-
-func (t *Token) Reduce(event *es_models.Event) (err error) {
-	switch eventstore.EventType(event.Type) {
-	case user.UserTokenAddedType,
-		user_repo.PersonalAccessTokenAddedType:
-		token := new(view_model.TokenView)
-		err := token.AppendEvent(event)
-		if err != nil {
-			return err
-		}
-		return t.view.PutToken(token, event)
-	case user.UserV1ProfileChangedType,
-		user.HumanProfileChangedType:
-		user := new(view_model.UserView)
-		err := user.AppendEvent(event)
-		if err != nil {
-			return err
-		}
-		tokens, err := t.view.TokensByUserID(event.AggregateID, event.InstanceID)
-		if err != nil {
-			return err
-		}
-		for _, token := range tokens {
-			token.PreferredLanguage = user.PreferredLanguage
-		}
-		return t.view.PutTokens(tokens, event)
-	case user.UserV1SignedOutType,
-		user.HumanSignedOutType:
-		id, err := agentIDFromSession(event)
-		if err != nil {
-			return err
-		}
-		return t.view.DeleteSessionTokens(id, event.AggregateID, event.InstanceID, event)
-	case user.UserLockedType,
-		user.UserDeactivatedType,
-		user.UserRemovedType:
-		return t.view.DeleteUserTokens(event.AggregateID, event.InstanceID, event)
-	case user_repo.UserTokenRemovedType,
-		user_repo.PersonalAccessTokenRemovedType:
-		id, err := tokenIDFromRemovedEvent(event)
-		if err != nil {
-			return err
-		}
-		return t.view.DeleteToken(id, event.InstanceID, event)
-	case user_repo.HumanRefreshTokenRemovedType:
-		id, err := refreshTokenIDFromRemovedEvent(event)
-		if err != nil {
-			return err
-		}
-		return t.view.DeleteTokensFromRefreshToken(id, event.InstanceID, event)
-	case project.ApplicationDeactivatedType,
-		project.ApplicationRemovedType:
-		application, err := applicationFromSession(event)
-		if err != nil {
-			return err
-		}
-		return t.view.DeleteApplicationTokens(event, application.AppID)
-	case project.ProjectDeactivatedType,
-		project.ProjectRemovedType:
-		project, err := t.getProjectByID(context.Background(), event.AggregateID, event.InstanceID)
-		if err != nil {
-			return err
-		}
-		clientIDs := make([]string, 0, len(project.Applications))
-		for _, app := range project.Applications {
-			if app.OIDCConfig != nil {
-				clientIDs = append(clientIDs, app.OIDCConfig.ClientID)
+func (t *Token) Reduce(event eventstore.Event) (_ *handler.Statement, err error) { //nolint:gocognit
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		switch event.Type() {
+		case user.UserTokenAddedType,
+			user.PersonalAccessTokenAddedType:
+			token := new(view_model.TokenView)
+			err := token.AppendEvent(event)
+			if err != nil {
+				return err
 			}
+			return t.view.PutToken(token)
+		case user.UserV1ProfileChangedType,
+			user.HumanProfileChangedType:
+			user := new(view_model.UserView)
+			err := user.AppendEvent(event)
+			if err != nil {
+				return err
+			}
+			tokens, err := t.view.TokensByUserID(event.Aggregate().ID, event.Aggregate().InstanceID)
+			if err != nil {
+				return err
+			}
+			for _, token := range tokens {
+				token.PreferredLanguage = user.PreferredLanguage
+			}
+			return t.view.PutTokens(tokens)
+		case user.UserV1SignedOutType,
+			user.HumanSignedOutType:
+			id, err := agentIDFromSession(event)
+			if err != nil {
+				return err
+			}
+
+			return t.view.DeleteSessionTokens(id, event)
+		case user.UserLockedType,
+			user.UserDeactivatedType,
+			user.UserRemovedType:
+
+			return t.view.DeleteUserTokens(event)
+		case user.UserTokenRemovedType,
+			user.PersonalAccessTokenRemovedType:
+			id, err := tokenIDFromRemovedEvent(event)
+			if err != nil {
+				return err
+			}
+
+			return t.view.DeleteToken(id, event.Aggregate().InstanceID)
+		case user.HumanRefreshTokenRemovedType:
+			id, err := refreshTokenIDFromRemovedEvent(event)
+			if err != nil {
+				return err
+			}
+
+			return t.view.DeleteTokensFromRefreshToken(id, event.Aggregate().InstanceID)
+		case project.ApplicationDeactivatedType,
+			project.ApplicationRemovedType:
+			application, err := applicationFromSession(event)
+			if err != nil {
+				return err
+			}
+
+			return t.view.DeleteApplicationTokens(event, application.AppID)
+		case project.ProjectDeactivatedType,
+			project.ProjectRemovedType:
+			project, err := t.getProjectByID(context.Background(), event.Aggregate().ID, event.Aggregate().InstanceID)
+			if err != nil {
+				return err
+			}
+			applicationIDs := make([]string, 0, len(project.Applications))
+			for _, app := range project.Applications {
+				if app.OIDCConfig != nil {
+					applicationIDs = append(applicationIDs, app.OIDCConfig.ClientID)
+				}
+			}
+
+			return t.view.DeleteApplicationTokens(event, applicationIDs...)
+		case instance.InstanceRemovedEventType:
+			return t.view.DeleteInstanceTokens(event)
+		case org.OrgRemovedEventType:
+			// deletes all tokens including PATs, which is expected for now
+			// if there is an undo of the org deletion in the future,
+			// we will need to have a look on how to handle the deleted PATs
+			return t.view.DeleteOrgTokens(event)
+		default:
+			return nil
 		}
-		return t.view.DeleteApplicationTokens(event, clientIDs...)
-	case instance.InstanceRemovedEventType:
-		return t.view.DeleteInstanceTokens(event)
-	case org.OrgRemovedEventType:
-		// deletes all tokens including PATs, which is expected for now
-		// if there is an undo of the org deletion in the future,
-		// we will need to have a look on how to handle the deleted PATs
-		return t.view.DeleteOrgTokens(event)
-	default:
-		return t.view.ProcessedTokenSequence(event)
-	}
+	}), nil
 }
 
-func (t *Token) OnError(event *es_models.Event, err error) error {
-	logging.WithFields("id", event.AggregateID).WithError(err).Warn("something went wrong in token handler")
-	return spooler.HandleError(event, err, t.view.GetLatestTokenFailedEvent, t.view.ProcessedTokenFailedEvent, t.view.ProcessedTokenSequence, t.errorCountUntilSkip)
-}
-
-func agentIDFromSession(event *es_models.Event) (string, error) {
+func agentIDFromSession(event eventstore.Event) (string, error) {
 	session := make(map[string]interface{})
-	if err := json.Unmarshal(event.Data, &session); err != nil {
+	if err := event.Unmarshal(&session); err != nil {
 		logging.WithError(err).Error("could not unmarshal event data")
 		return "", caos_errs.ThrowInternal(nil, "MODEL-sd325", "could not unmarshal data")
 	}
 	return session["userAgentID"].(string), nil
 }
 
-func applicationFromSession(event *es_models.Event) (*project_es_model.Application, error) {
+func applicationFromSession(event eventstore.Event) (*project_es_model.Application, error) {
 	application := new(project_es_model.Application)
-	if err := json.Unmarshal(event.Data, &application); err != nil {
+	if err := event.Unmarshal(application); err != nil {
 		logging.WithError(err).Error("could not unmarshal event data")
 		return nil, caos_errs.ThrowInternal(nil, "MODEL-Hrw1q", "could not unmarshal data")
 	}
 	return application, nil
 }
 
-func tokenIDFromRemovedEvent(event *es_models.Event) (string, error) {
+func tokenIDFromRemovedEvent(event eventstore.Event) (string, error) {
 	removed := make(map[string]interface{})
-	if err := json.Unmarshal(event.Data, &removed); err != nil {
+	if err := event.Unmarshal(&removed); err != nil {
 		logging.WithError(err).Error("could not unmarshal event data")
 		return "", caos_errs.ThrowInternal(nil, "MODEL-Sff32", "could not unmarshal data")
 	}
 	return removed["tokenId"].(string), nil
 }
 
-func refreshTokenIDFromRemovedEvent(event *es_models.Event) (string, error) {
+func refreshTokenIDFromRemovedEvent(event eventstore.Event) (string, error) {
 	removed := make(map[string]interface{})
-	if err := json.Unmarshal(event.Data, &removed); err != nil {
+	if err := event.Unmarshal(&removed); err != nil {
 		logging.WithError(err).Error("could not unmarshal event data")
 		return "", caos_errs.ThrowInternal(nil, "MODEL-Dfb3w", "could not unmarshal data")
 	}
 	return removed["tokenId"].(string), nil
 }
 
-func (t *Token) OnSuccess(instanceIDs []string) error {
-	return spooler.HandleSuccess(t.view.UpdateTokenSpoolerRunTimestamp, instanceIDs)
-}
-
 func (t *Token) getProjectByID(ctx context.Context, projID, instanceID string) (*proj_model.Project, error) {
-	projectQuery, err := proj_view.ProjectByIDQuery(projID, instanceID, 0)
+	query, err := proj_view.ProjectByIDQuery(projID, instanceID, 0)
 	if err != nil {
 		return nil, err
 	}
@@ -219,13 +284,16 @@ func (t *Token) getProjectByID(ctx context.Context, projID, instanceID string) (
 			AggregateID: projID,
 		},
 	}
-	err = es_sdk.Filter(ctx, t.Eventstore().FilterEvents, esProject.AppendEvents, projectQuery)
-	if err != nil && !caos_errs.IsNotFound(err) {
+	events, err := t.es.Filter(ctx, query)
+	if err != nil {
 		return nil, err
 	}
+	if err = esProject.AppendEvents(events...); err != nil {
+		return nil, err
+	}
+
 	if esProject.Sequence == 0 {
 		return nil, caos_errs.ThrowNotFound(nil, "EVENT-Dsdw2", "Errors.Project.NotFound")
 	}
-
 	return project_es_model.ProjectToModel(esProject), nil
 }

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
+}

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

@@ -3,19 +3,16 @@ 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/domain"
 	"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"
 	"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,158 +25,299 @@ const (
 )
 
 type UserSession struct {
-	handler
-	subscription *v1.Subscription
-	queries      *query2.Queries
+	queries *query2.Queries
+	view    *auth_view.View
+	es      handler.EventStore
 }
 
-func newUserSession(ctx context.Context, handler handler, queries *query2.Queries) *UserSession {
-	h := &UserSession{
-		handler: handler,
-		queries: queries,
-	}
+var _ handler.Projection = (*UserSession)(nil)
 
-	h.subscribe(ctx)
-
-	return h
+func newUserSession(
+	ctx context.Context,
+	config handler.Config,
+	view *auth_view.View,
+	queries *query2.Queries,
+) *handler.Handler {
+	return handler.NewHandler(
+		ctx,
+		&config,
+		&UserSession{
+			queries: queries,
+			view:    view,
+			es:      config.Eventstore,
+		},
+	)
 }
 
-func (u *UserSession) 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 *UserSession) ViewModel() string {
+// Name implements [handler.Projection]
+func (*UserSession) Name() string {
 	return userSessionTable
 }
 
-func (u *UserSession) Subscription() *v1.Subscription {
-	return u.subscription
-}
-
-func (_ *UserSession) AggregateTypes() []models.AggregateType {
-	return []models.AggregateType{user.AggregateType, org.AggregateType, instance.AggregateType}
-}
-
-func (u *UserSession) CurrentSequence(ctx context.Context, instanceID string) (uint64, error) {
-	sequence, err := u.view.GetLatestUserSessionSequence(ctx, instanceID)
-	if err != nil {
-		return 0, err
+// Reducers implements [handler.Projection]
+func (s *UserSession) Reducers() []handler.AggregateReducer {
+	return []handler.AggregateReducer{
+		{
+			Aggregate: user.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  user.UserV1PasswordCheckSucceededType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserV1PasswordCheckFailedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserV1MFAOTPCheckSucceededType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserV1MFAOTPCheckFailedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserV1SignedOutType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanPasswordCheckSucceededType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanPasswordCheckFailedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserIDPLoginCheckSucceededType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanMFAOTPCheckSucceededType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanMFAOTPCheckFailedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanU2FTokenCheckSucceededType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanU2FTokenCheckFailedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanPasswordlessTokenCheckSucceededType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanPasswordlessTokenCheckFailedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanSignedOutType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserV1PasswordChangedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserV1MFAOTPRemovedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserV1ProfileChangedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserLockedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserDeactivatedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanPasswordChangedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanMFAOTPRemovedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanProfileChangedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanAvatarAddedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanAvatarRemovedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserDomainClaimedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserUserNameChangedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserIDPLinkRemovedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserIDPLinkCascadeRemovedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanPasswordlessTokenRemovedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.HumanU2FTokenRemovedType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  user.UserRemovedType,
+					Reduce: s.Reduce,
+				},
+			},
+		},
+		{
+			Aggregate: org.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  org.OrgDomainPrimarySetEventType,
+					Reduce: s.Reduce,
+				},
+				{
+					Event:  org.OrgRemovedEventType,
+					Reduce: s.Reduce,
+				},
+			},
+		},
+		{
+			Aggregate: instance.AggregateType,
+			EventReducers: []handler.EventReducer{
+				{
+					Event:  instance.InstanceRemovedEventType,
+					Reduce: s.Reduce,
+				},
+			},
+		},
 	}
-	return sequence.CurrentSequence, nil
 }
 
-func (u *UserSession) EventQuery(ctx context.Context, instanceIDs []string) (*models.SearchQuery, error) {
-	sequences, err := u.view.GetLatestUserSessionSequences(ctx, instanceIDs)
-	if err != nil {
-		return nil, err
-	}
-	return newSearchQuery(sequences, u.AggregateTypes(), instanceIDs), nil
+func (u *UserSession) Reduce(event eventstore.Event) (_ *handler.Statement, err error) {
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		var session *view_model.UserSessionView
+		switch event.Type() {
+		case user.UserV1PasswordCheckSucceededType,
+			user.UserV1PasswordCheckFailedType,
+			user.UserV1MFAOTPCheckSucceededType,
+			user.UserV1MFAOTPCheckFailedType,
+			user.UserV1SignedOutType,
+			user.HumanPasswordCheckSucceededType,
+			user.HumanPasswordCheckFailedType,
+			user.UserIDPLoginCheckSucceededType,
+			user.HumanMFAOTPCheckSucceededType,
+			user.HumanMFAOTPCheckFailedType,
+			user.HumanU2FTokenCheckSucceededType,
+			user.HumanU2FTokenCheckFailedType,
+			user.HumanPasswordlessTokenCheckSucceededType,
+			user.HumanPasswordlessTokenCheckFailedType,
+			user.HumanSignedOutType:
+
+			eventData, err := view_model.UserSessionFromEvent(event)
+			if err != nil {
+				return err
+			}
+			session, err = u.view.UserSessionByIDs(eventData.UserAgentID, event.Aggregate().ID, event.Aggregate().InstanceID)
+			if err != nil {
+				if !errors.IsNotFound(err) {
+					return err
+				}
+				session = &view_model.UserSessionView{
+					CreationDate:  event.CreatedAt(),
+					ResourceOwner: event.Aggregate().ResourceOwner,
+					UserAgentID:   eventData.UserAgentID,
+					UserID:        event.Aggregate().ID,
+					State:         int32(domain.UserSessionStateActive),
+					InstanceID:    event.Aggregate().InstanceID,
+				}
+			}
+			return u.updateSession(session, event)
+		case user.UserV1PasswordChangedType,
+			user.UserV1MFAOTPRemovedType,
+			user.UserV1ProfileChangedType,
+			user.UserLockedType,
+			user.UserDeactivatedType,
+			user.HumanPasswordChangedType,
+			user.HumanMFAOTPRemovedType,
+			user.HumanProfileChangedType,
+			user.HumanAvatarAddedType,
+			user.HumanAvatarRemovedType,
+			user.UserDomainClaimedType,
+			user.UserUserNameChangedType,
+			user.UserIDPLinkRemovedType,
+			user.UserIDPLinkCascadeRemovedType,
+			user.HumanPasswordlessTokenRemovedType,
+			user.HumanU2FTokenRemovedType:
+			sessions, err := u.view.UserSessionsByUserID(event.Aggregate().ID, event.Aggregate().InstanceID)
+			if err != nil || len(sessions) == 0 {
+				return err
+			}
+			if err = u.appendEventOnSessions(sessions, event); err != nil {
+				return err
+			}
+			if err = u.view.PutUserSessions(sessions); err != nil {
+				return err
+			}
+			return nil
+		case org.OrgDomainPrimarySetEventType:
+			return u.fillLoginNamesOnOrgUsers(event)
+		case user.UserRemovedType:
+			return u.view.DeleteUserSessions(event.Aggregate().ID, event.Aggregate().InstanceID)
+		case instance.InstanceRemovedEventType:
+			return u.view.DeleteInstanceUserSessions(event.Aggregate().InstanceID)
+		case org.OrgRemovedEventType:
+			return u.view.DeleteOrgUserSessions(event)
+		default:
+			return nil
+		}
+	}), nil
 }
 
-func (u *UserSession) Reduce(event *models.Event) (err error) {
-	var session *view_model.UserSessionView
-	switch eventstore.EventType(event.Type) {
-	case user.UserV1PasswordCheckSucceededType,
-		user.UserV1PasswordCheckFailedType,
-		user.UserV1MFAOTPCheckSucceededType,
-		user.UserV1MFAOTPCheckFailedType,
-		user.UserV1SignedOutType,
-		user.HumanPasswordCheckSucceededType,
-		user.HumanPasswordCheckFailedType,
-		user.UserIDPLoginCheckSucceededType,
-		user.HumanMFAOTPCheckSucceededType,
-		user.HumanMFAOTPCheckFailedType,
-		user.HumanU2FTokenCheckSucceededType,
-		user.HumanU2FTokenCheckFailedType,
-		user.HumanPasswordlessTokenCheckSucceededType,
-		user.HumanPasswordlessTokenCheckFailedType,
-		user.HumanSignedOutType:
-		eventData, err := view_model.UserSessionFromEvent(event)
-		if err != nil {
+func (u *UserSession) appendEventOnSessions(sessions []*view_model.UserSessionView, event eventstore.Event) error {
+	for _, session := range sessions {
+		if err := session.AppendEvent(event); err != nil {
 			return err
 		}
-		session, err = u.view.UserSessionByIDs(eventData.UserAgentID, event.AggregateID, event.InstanceID)
-		if err != nil {
-			if !errors.IsNotFound(err) {
-				return err
-			}
-			session = &view_model.UserSessionView{
-				CreationDate:  event.CreationDate,
-				ResourceOwner: event.ResourceOwner,
-				UserAgentID:   eventData.UserAgentID,
-				UserID:        event.AggregateID,
-				State:         int32(domain.UserSessionStateActive),
-				InstanceID:    event.InstanceID,
-			}
-		}
-		return u.updateSession(session, event)
-	case user.UserV1PasswordChangedType,
-		user.UserV1MFAOTPRemovedType,
-		user.UserV1ProfileChangedType,
-		user.UserLockedType,
-		user.UserDeactivatedType,
-		user.HumanPasswordChangedType,
-		user.HumanMFAOTPRemovedType,
-		user.HumanProfileChangedType,
-		user.HumanAvatarAddedType,
-		user.HumanAvatarRemovedType,
-		user.UserDomainClaimedType,
-		user.UserUserNameChangedType,
-		user.UserIDPLinkRemovedType,
-		user.UserIDPLinkCascadeRemovedType,
-		user.HumanPasswordlessTokenRemovedType,
-		user.HumanU2FTokenRemovedType:
-		sessions, err := u.view.UserSessionsByUserID(event.AggregateID, event.InstanceID)
-		if err != nil {
+		if err := u.fillUserInfo(session); err != nil {
 			return err
 		}
-		if len(sessions) == 0 {
-			return u.view.ProcessedUserSessionSequence(event)
-		}
-		for _, session := range sessions {
-			if err := session.AppendEvent(event); err != nil {
-				return err
-			}
-			if err := u.fillUserInfo(session); err != nil {
-				return err
-			}
-		}
-		return u.view.PutUserSessions(sessions, event)
-	case org.OrgDomainPrimarySetEventType:
-		return u.fillLoginNamesOnOrgUsers(event)
-	case user.UserRemovedType:
-		return u.view.DeleteUserSessions(event.AggregateID, event.InstanceID, event)
-	case instance.InstanceRemovedEventType:
-		return u.view.DeleteInstanceUserSessions(event)
-	case org.OrgRemovedEventType:
-		return u.view.DeleteOrgUserSessions(event)
-	default:
-		return u.view.ProcessedUserSessionSequence(event)
 	}
+	return nil
 }
 
-func (u *UserSession) OnError(event *models.Event, err error) error {
-	logging.WithFields("id", event.AggregateID).WithError(err).Warn("something went wrong in user session handler")
-	return spooler.HandleError(event, err, u.view.GetLatestUserSessionFailedEvent, u.view.ProcessedUserSessionFailedEvent, u.view.ProcessedUserSessionSequence, u.errorCountUntilSkip)
-}
-
-func (u *UserSession) OnSuccess(instanceIDs []string) error {
-	return spooler.HandleSuccess(u.view.UpdateUserSessionSpoolerRunTimestamp, instanceIDs)
-}
-
-func (u *UserSession) updateSession(session *view_model.UserSessionView, event *models.Event) error {
+func (u *UserSession) updateSession(session *view_model.UserSessionView, event eventstore.Event) error {
 	if err := session.AppendEvent(event); err != nil {
 		return err
 	}
 	if err := u.fillUserInfo(session); err != nil {
 		return err
 	}
-	return u.view.PutUserSession(session, event)
+	if err := u.view.PutUserSession(session); err != nil {
+		return err
+	}
+	return nil
 }
 
 func (u *UserSession) fillUserInfo(session *view_model.UserSessionView) error {
@@ -194,15 +332,15 @@ func (u *UserSession) fillUserInfo(session *view_model.UserSessionView) error {
 	return nil
 }
 
-func (u *UserSession) fillLoginNamesOnOrgUsers(event *models.Event) error {
-	sessions, err := u.view.UserSessionsByOrgID(event.ResourceOwner, event.InstanceID)
+func (u *UserSession) fillLoginNamesOnOrgUsers(event eventstore.Event) error {
+	sessions, err := u.view.UserSessionsByOrgID(event.Aggregate().ResourceOwner, event.Aggregate().InstanceID)
 	if err != nil {
 		return err
 	}
 	if len(sessions) == 0 {
-		return u.view.ProcessedUserSessionSequence(event)
+		return nil
 	}
-	userLoginMustBeDomain, primaryDomain, err := u.loginNameInformation(context.Background(), event.ResourceOwner, event.InstanceID)
+	userLoginMustBeDomain, primaryDomain, err := u.loginNameInformation(context.Background(), event.Aggregate().ResourceOwner, event.Aggregate().InstanceID)
 	if err != nil {
 		return err
 	}
@@ -212,7 +350,7 @@ func (u *UserSession) fillLoginNamesOnOrgUsers(event *models.Event) error {
 	for _, session := range sessions {
 		session.LoginName = session.UserName + "@" + primaryDomain
 	}
-	return u.view.PutUserSessions(sessions, event)
+	return u.view.PutUserSessions(sessions)
 }
 
 func (u *UserSession) loginNameInformation(ctx context.Context, orgID string, instanceID string) (userLoginMustBeDomain bool, primaryDomain string, err error) {
@@ -223,7 +361,7 @@ func (u *UserSession) loginNameInformation(ctx context.Context, orgID string, in
 	if org.DomainPolicy != nil {
 		return org.DomainPolicy.UserLoginMustBeDomain, org.GetPrimaryDomain().Domain, 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, "", err
 	}
@@ -231,7 +369,7 @@ func (u *UserSession) loginNameInformation(ctx context.Context, orgID string, in
 }
 
 func (u *UserSession) 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
 	}
@@ -241,13 +379,16 @@ func (u *UserSession) getOrgByID(ctx context.Context, orgID, instanceID string)
 			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 {
 		return nil, errors.ThrowNotFound(nil, "EVENT-3m9vs", "Errors.Org.NotFound")
 	}
-
 	return org_es_model.OrgToModel(esOrg), nil
 }