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/view/error_event.go

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

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

@@ -3,12 +3,14 @@ package view
 import (
 	"context"
 
+	"github.com/zitadel/zitadel/internal/api/authz"
 	"github.com/zitadel/zitadel/internal/errors"
+	"github.com/zitadel/zitadel/internal/eventstore"
 	"github.com/zitadel/zitadel/internal/eventstore/v1/models"
+	"github.com/zitadel/zitadel/internal/query"
 	user_model "github.com/zitadel/zitadel/internal/user/model"
 	usr_view "github.com/zitadel/zitadel/internal/user/repository/view"
 	"github.com/zitadel/zitadel/internal/user/repository/view/model"
-	"github.com/zitadel/zitadel/internal/view/repository"
 )
 
 const (
@@ -27,36 +29,28 @@ func (v *View) SearchRefreshTokens(request *user_model.RefreshTokenSearchRequest
 	return usr_view.SearchRefreshTokens(v.Db, refreshTokenTable, request)
 }
 
-func (v *View) PutRefreshToken(token *model.RefreshTokenView, event *models.Event) error {
-	err := usr_view.PutRefreshToken(v.Db, refreshTokenTable, token)
-	if err != nil {
-		return err
-	}
-	return v.ProcessedRefreshTokenSequence(event)
+func (v *View) PutRefreshToken(token *model.RefreshTokenView) error {
+	return usr_view.PutRefreshToken(v.Db, refreshTokenTable, token)
 }
 
-func (v *View) PutRefreshTokens(token []*model.RefreshTokenView, event *models.Event) error {
-	err := usr_view.PutRefreshTokens(v.Db, refreshTokenTable, token...)
-	if err != nil {
-		return err
-	}
-	return v.ProcessedRefreshTokenSequence(event)
+func (v *View) PutRefreshTokens(token []*model.RefreshTokenView) error {
+	return usr_view.PutRefreshTokens(v.Db, refreshTokenTable, token...)
 }
 
-func (v *View) DeleteRefreshToken(tokenID, instanceID string, event *models.Event) error {
+func (v *View) DeleteRefreshToken(tokenID, instanceID string) error {
 	err := usr_view.DeleteRefreshToken(v.Db, refreshTokenTable, tokenID, instanceID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedRefreshTokenSequence(event)
+	return nil
 }
 
-func (v *View) DeleteUserRefreshTokens(userID, instanceID string, event *models.Event) error {
+func (v *View) DeleteUserRefreshTokens(userID, instanceID string) error {
 	err := usr_view.DeleteUserRefreshTokens(v.Db, refreshTokenTable, userID, instanceID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedRefreshTokenSequence(event)
+	return nil
 }
 
 func (v *View) DeleteApplicationRefreshTokens(event *models.Event, ids ...string) error {
@@ -64,45 +58,40 @@ func (v *View) DeleteApplicationRefreshTokens(event *models.Event, ids ...string
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedRefreshTokenSequence(event)
+	return nil
 }
 
-func (v *View) DeleteInstanceRefreshTokens(event *models.Event) error {
-	err := usr_view.DeleteInstanceRefreshTokens(v.Db, refreshTokenTable, event.InstanceID)
+func (v *View) DeleteInstanceRefreshTokens(instanceID string) error {
+	err := usr_view.DeleteInstanceRefreshTokens(v.Db, refreshTokenTable, instanceID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedRefreshTokenSequence(event)
+	return nil
 }
 
-func (v *View) DeleteOrgRefreshTokens(event *models.Event) error {
-	err := usr_view.DeleteOrgRefreshTokens(v.Db, refreshTokenTable, event.InstanceID, event.ResourceOwner)
+func (v *View) DeleteOrgRefreshTokens(event eventstore.Event) error {
+	err := usr_view.DeleteOrgRefreshTokens(v.Db, refreshTokenTable, event.Aggregate().InstanceID, event.Aggregate().ResourceOwner)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedRefreshTokenSequence(event)
+	return nil
 }
 
-func (v *View) GetLatestRefreshTokenSequence(ctx context.Context, instanceID string) (*repository.CurrentSequence, error) {
-	return v.latestSequence(ctx, refreshTokenTable, instanceID)
-}
-
-func (v *View) GetLatestRefreshTokenSequences(ctx context.Context, instanceIDs []string) ([]*repository.CurrentSequence, error) {
-	return v.latestSequences(ctx, refreshTokenTable, instanceIDs)
-}
-
-func (v *View) ProcessedRefreshTokenSequence(event *models.Event) error {
-	return v.saveCurrentSequence(refreshTokenTable, event)
-}
-
-func (v *View) UpdateRefreshTokenSpoolerRunTimestamp(instanceIDs []string) error {
-	return v.updateSpoolerRunSequence(refreshTokenTable, instanceIDs)
-}
-
-func (v *View) GetLatestRefreshTokenFailedEvent(sequence uint64, instanceID string) (*repository.FailedEvent, error) {
-	return v.latestFailedEvent(refreshTokenTable, instanceID, sequence)
-}
-
-func (v *View) ProcessedRefreshTokenFailedEvent(failedEvent *repository.FailedEvent) error {
-	return v.saveFailedEvent(failedEvent)
+func (v *View) GetLatestRefreshTokenSequence(ctx context.Context) (_ *query.CurrentState, err error) {
+	q := &query.CurrentStateSearchQueries{
+		Queries: make([]query.SearchQuery, 2),
+	}
+	q.Queries[0], err = query.NewCurrentStatesInstanceIDSearchQuery(authz.GetInstance(ctx).InstanceID())
+	if err != nil {
+		return nil, err
+	}
+	q.Queries[1], err = query.NewCurrentStatesProjectionSearchQuery(refreshTokenTable)
+	if err != nil {
+		return nil, err
+	}
+	states, err := v.query.SearchCurrentStates(ctx, q)
+	if err != nil || states.SearchResponse.Count == 0 {
+		return nil, err
+	}
+	return states.CurrentStates[0], nil
 }

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

@@ -1,39 +0,0 @@
-package view
-
-import (
-	"context"
-	"time"
-
-	"github.com/zitadel/zitadel/internal/eventstore/v1/models"
-	"github.com/zitadel/zitadel/internal/view/repository"
-)
-
-const (
-	sequencesTable = "auth.current_sequences"
-)
-
-func (v *View) saveCurrentSequence(viewName string, event *models.Event) error {
-	return repository.SaveCurrentSequence(v.Db, sequencesTable, viewName, event.InstanceID, event.Sequence, event.CreationDate)
-}
-
-func (v *View) latestSequence(ctx context.Context, viewName, instanceID string) (*repository.CurrentSequence, error) {
-	return repository.LatestSequence(v.Db, v.TimeTravel(ctx, sequencesTable), viewName, instanceID)
-}
-
-func (v *View) latestSequences(ctx context.Context, viewName string, instanceIDs []string) ([]*repository.CurrentSequence, error) {
-	return repository.LatestSequences(v.Db, v.TimeTravel(ctx, sequencesTable), viewName, instanceIDs)
-}
-
-func (v *View) updateSpoolerRunSequence(viewName string, instanceIDs []string) error {
-	currentSequences, err := repository.LatestSequences(v.Db, sequencesTable, viewName, instanceIDs)
-	if err != nil {
-		return err
-	}
-	for _, currentSequence := range currentSequences {
-		if currentSequence.ViewName == "" {
-			currentSequence.ViewName = viewName
-		}
-		currentSequence.LastSuccessfulSpoolerRun = time.Now()
-	}
-	return repository.UpdateCurrentSequences(v.Db, sequencesTable, currentSequences)
-}

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

@@ -4,10 +4,10 @@ import (
 	"context"
 
 	"github.com/zitadel/zitadel/internal/errors"
-	"github.com/zitadel/zitadel/internal/eventstore/v1/models"
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/query"
 	usr_view "github.com/zitadel/zitadel/internal/user/repository/view"
 	"github.com/zitadel/zitadel/internal/user/repository/view/model"
-	"github.com/zitadel/zitadel/internal/view/repository"
 )
 
 const (
@@ -22,98 +22,85 @@ func (v *View) TokensByUserID(userID, instanceID string) ([]*model.TokenView, er
 	return usr_view.TokensByUserID(v.Db, tokenTable, userID, instanceID)
 }
 
-func (v *View) PutToken(token *model.TokenView, event *models.Event) error {
-	err := usr_view.PutToken(v.Db, tokenTable, token)
-	if err != nil {
-		return err
-	}
-	return v.ProcessedTokenSequence(event)
+func (v *View) PutToken(token *model.TokenView) error {
+	return usr_view.PutToken(v.Db, tokenTable, token)
 }
 
-func (v *View) PutTokens(token []*model.TokenView, event *models.Event) error {
-	err := usr_view.PutTokens(v.Db, tokenTable, token...)
-	if err != nil {
-		return err
-	}
-	return v.ProcessedTokenSequence(event)
+func (v *View) PutTokens(token []*model.TokenView) error {
+	return usr_view.PutTokens(v.Db, tokenTable, token...)
 }
 
-func (v *View) DeleteToken(tokenID, instanceID string, event *models.Event) error {
+func (v *View) DeleteToken(tokenID, instanceID string) error {
 	err := usr_view.DeleteToken(v.Db, tokenTable, tokenID, instanceID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedTokenSequence(event)
+	return nil
 }
 
-func (v *View) DeleteSessionTokens(agentID, userID, instanceID string, event *models.Event) error {
-	err := usr_view.DeleteSessionTokens(v.Db, tokenTable, agentID, userID, instanceID)
+func (v *View) DeleteSessionTokens(agentID string, event eventstore.Event) error {
+	err := usr_view.DeleteSessionTokens(v.Db, tokenTable, agentID, event.Aggregate().ID, event.Aggregate().InstanceID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedTokenSequence(event)
+	return nil
 }
 
-func (v *View) DeleteUserTokens(userID, instanceID string, event *models.Event) error {
-	err := usr_view.DeleteUserTokens(v.Db, tokenTable, userID, instanceID)
+func (v *View) DeleteUserTokens(event eventstore.Event) error {
+	err := usr_view.DeleteUserTokens(v.Db, tokenTable, event.Aggregate().ID, event.Aggregate().InstanceID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedTokenSequence(event)
+	return nil
 }
 
-func (v *View) DeleteApplicationTokens(event *models.Event, ids ...string) error {
-	err := usr_view.DeleteApplicationTokens(v.Db, tokenTable, event.InstanceID, ids)
+func (v *View) DeleteApplicationTokens(event eventstore.Event, ids ...string) error {
+	err := usr_view.DeleteApplicationTokens(v.Db, tokenTable, event.Aggregate().InstanceID, ids)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedTokenSequence(event)
+	return nil
 }
 
-func (v *View) DeleteTokensFromRefreshToken(refreshTokenID, instanceID string, event *models.Event) error {
+func (v *View) DeleteTokensFromRefreshToken(refreshTokenID, instanceID string) error {
 	err := usr_view.DeleteTokensFromRefreshToken(v.Db, tokenTable, refreshTokenID, instanceID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedTokenSequence(event)
+	return nil
 }
 
-func (v *View) DeleteInstanceTokens(event *models.Event) error {
-	err := usr_view.DeleteInstanceTokens(v.Db, tokenTable, event.InstanceID)
+func (v *View) DeleteInstanceTokens(event eventstore.Event) error {
+	err := usr_view.DeleteInstanceTokens(v.Db, tokenTable, event.Aggregate().InstanceID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedTokenSequence(event)
+	return nil
 }
 
-func (v *View) DeleteOrgTokens(event *models.Event) error {
-	err := usr_view.DeleteOrgTokens(v.Db, tokenTable, event.InstanceID, event.ResourceOwner)
+func (v *View) DeleteOrgTokens(event eventstore.Event) error {
+	err := usr_view.DeleteOrgTokens(v.Db, tokenTable, event.Aggregate().InstanceID, event.Aggregate().ResourceOwner)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedTokenSequence(event)
+	return nil
 }
 
-func (v *View) GetLatestTokenSequence(ctx context.Context, instanceID string) (*repository.CurrentSequence, error) {
-	return v.latestSequence(ctx, tokenTable, instanceID)
-}
-
-func (v *View) GetLatestTokenSequences(ctx context.Context, instanceIDs []string) ([]*repository.CurrentSequence, error) {
-	return v.latestSequences(ctx, tokenTable, instanceIDs)
-}
-
-func (v *View) ProcessedTokenSequence(event *models.Event) error {
-	return v.saveCurrentSequence(tokenTable, event)
-}
-
-func (v *View) UpdateTokenSpoolerRunTimestamp(instanceIDs []string) error {
-	return v.updateSpoolerRunSequence(tokenTable, instanceIDs)
-}
-
-func (v *View) GetLatestTokenFailedEvent(sequence uint64, instanceID string) (*repository.FailedEvent, error) {
-	return v.latestFailedEvent(tokenTable, instanceID, sequence)
-}
-
-func (v *View) ProcessedTokenFailedEvent(failedEvent *repository.FailedEvent) error {
-	return v.saveFailedEvent(failedEvent)
+func (v *View) GetLatestTokenSequence(ctx context.Context, instanceID string) (_ *query.CurrentState, err error) {
+	q := &query.CurrentStateSearchQueries{
+		Queries: make([]query.SearchQuery, 2),
+	}
+	q.Queries[0], err = query.NewCurrentStatesInstanceIDSearchQuery(instanceID)
+	if err != nil {
+		return nil, err
+	}
+	q.Queries[1], err = query.NewCurrentStatesProjectionSearchQuery(tokenTable)
+	if err != nil {
+		return nil, err
+	}
+	states, err := v.query.SearchCurrentStates(ctx, q)
+	if err != nil || states.SearchResponse.Count == 0 {
+		return nil, err
+	}
+	return states.CurrentStates[0], nil
 }

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

@@ -4,14 +4,12 @@ import (
 	"context"
 
 	"github.com/zitadel/logging"
-
 	"github.com/zitadel/zitadel/internal/errors"
-	"github.com/zitadel/zitadel/internal/eventstore/v1/models"
+	"github.com/zitadel/zitadel/internal/eventstore"
 	"github.com/zitadel/zitadel/internal/query"
 	usr_model "github.com/zitadel/zitadel/internal/user/model"
 	"github.com/zitadel/zitadel/internal/user/repository/view"
 	"github.com/zitadel/zitadel/internal/user/repository/view/model"
-	"github.com/zitadel/zitadel/internal/view/repository"
 )
 
 const (
@@ -104,7 +102,7 @@ func (v *View) userByID(ctx context.Context, instanceID string, queries ...query
 			Errorf("could not get current sequence for userByID")
 		user = new(model.UserView)
 		if sequence != nil {
-			user.Sequence = sequence.CurrentSequence
+			user.Sequence = sequence.Sequence
 		}
 	}
 
@@ -112,7 +110,7 @@ func (v *View) userByID(ctx context.Context, instanceID string, queries ...query
 	if err != nil {
 		return nil, err
 	}
-	events, err := v.es.FilterEvents(ctx, query)
+	events, err := v.es.Filter(ctx, query)
 	if err != nil && user.Sequence == 0 {
 		return nil, err
 	} else if err != nil {
@@ -138,82 +136,53 @@ func (v *View) UsersByOrgID(orgID, instanceID string) ([]*model.UserView, error)
 	return view.UsersByOrgID(v.Db, userTable, orgID, instanceID)
 }
 
-func (v *View) UserIDsByDomain(domain, instanceID string) ([]string, error) {
-	return view.UserIDsByDomain(v.Db, userTable, domain, instanceID)
+func (v *View) PutUser(user *model.UserView, event eventstore.Event) error {
+	return view.PutUser(v.Db, userTable, user)
 }
 
-func (v *View) SearchUsers(request *usr_model.UserSearchRequest) ([]*model.UserView, uint64, error) {
-	return view.SearchUsers(v.Db, userTable, request)
+func (v *View) PutUsers(users []*model.UserView, event eventstore.Event) error {
+	return view.PutUsers(v.Db, userTable, users...)
 }
 
-func (v *View) GetGlobalUserByLoginName(email, instanceID string) (*model.UserView, error) {
-	return view.GetGlobalUserByLoginName(v.Db, userTable, email, instanceID)
-}
-
-func (v *View) UserMFAs(userID, instanceID string) ([]*usr_model.MultiFactor, error) {
-	return view.UserMFAs(v.Db, userTable, userID, instanceID)
-}
-
-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) PutUsers(users []*model.UserView, event *models.Event) error {
-	err := view.PutUsers(v.Db, userTable, users...)
-	if err != nil {
-		return err
-	}
-	return v.ProcessedUserSequence(event)
-}
-
-func (v *View) DeleteUser(userID, instanceID string, event *models.Event) error {
+func (v *View) DeleteUser(userID, instanceID string, event eventstore.Event) error {
 	err := view.DeleteUser(v.Db, userTable, userID, instanceID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedUserSequence(event)
+	return nil
 }
 
-func (v *View) DeleteInstanceUsers(event *models.Event) error {
-	err := view.DeleteInstanceUsers(v.Db, userTable, event.InstanceID)
+func (v *View) DeleteInstanceUsers(event eventstore.Event) error {
+	err := view.DeleteInstanceUsers(v.Db, userTable, event.Aggregate().InstanceID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedUserSequence(event)
+	return nil
 }
 
-func (v *View) UpdateOrgOwnerRemovedUsers(event *models.Event) error {
-	err := view.UpdateOrgOwnerRemovedUsers(v.Db, userTable, event.InstanceID, event.AggregateID)
+func (v *View) UpdateOrgOwnerRemovedUsers(event eventstore.Event) error {
+	err := view.UpdateOrgOwnerRemovedUsers(v.Db, userTable, event.Aggregate().InstanceID, event.Aggregate().ID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedUserSequence(event)
+	return nil
 }
 
-func (v *View) GetLatestUserSequence(ctx context.Context, instanceID string) (*repository.CurrentSequence, error) {
-	return v.latestSequence(ctx, userTable, instanceID)
-}
-
-func (v *View) GetLatestUserSequences(ctx context.Context, instanceIDs []string) ([]*repository.CurrentSequence, error) {
-	return v.latestSequences(ctx, userTable, instanceIDs)
-}
-
-func (v *View) ProcessedUserSequence(event *models.Event) error {
-	return v.saveCurrentSequence(userTable, event)
-}
-
-func (v *View) UpdateUserSpoolerRunTimestamp(instanceIDs []string) error {
-	return v.updateSpoolerRunSequence(userTable, instanceIDs)
-}
-
-func (v *View) GetLatestUserFailedEvent(sequence uint64, instanceID string) (*repository.FailedEvent, error) {
-	return v.latestFailedEvent(userTable, instanceID, sequence)
-}
-
-func (v *View) ProcessedUserFailedEvent(failedEvent *repository.FailedEvent) error {
-	return v.saveFailedEvent(failedEvent)
+func (v *View) GetLatestUserSequence(ctx context.Context, instanceID string) (_ *query.CurrentState, err error) {
+	q := &query.CurrentStateSearchQueries{
+		Queries: make([]query.SearchQuery, 2),
+	}
+	q.Queries[0], err = query.NewCurrentStatesInstanceIDSearchQuery(instanceID)
+	if err != nil {
+		return nil, err
+	}
+	q.Queries[1], err = query.NewCurrentStatesProjectionSearchQuery(userTable)
+	if err != nil {
+		return nil, err
+	}
+	states, err := v.query.SearchCurrentStates(ctx, q)
+	if err != nil || states.SearchResponse.Count == 0 {
+		return nil, err
+	}
+	return states.CurrentStates[0], nil
 }

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

@@ -4,10 +4,10 @@ import (
 	"context"
 
 	"github.com/zitadel/zitadel/internal/errors"
-	"github.com/zitadel/zitadel/internal/eventstore/v1/models"
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/query"
 	"github.com/zitadel/zitadel/internal/user/repository/view"
 	"github.com/zitadel/zitadel/internal/user/repository/view/model"
-	"github.com/zitadel/zitadel/internal/view/repository"
 )
 
 const (
@@ -34,66 +34,53 @@ func (v *View) ActiveUserSessionsCount() (uint64, error) {
 	return view.ActiveUserSessions(v.Db, userSessionTable)
 }
 
-func (v *View) PutUserSession(userSession *model.UserSessionView, event *models.Event) error {
-	err := view.PutUserSession(v.Db, userSessionTable, userSession)
-	if err != nil {
-		return err
-	}
-	return v.ProcessedUserSessionSequence(event)
+func (v *View) PutUserSession(userSession *model.UserSessionView) error {
+	return view.PutUserSession(v.Db, userSessionTable, userSession)
 }
 
-func (v *View) PutUserSessions(userSession []*model.UserSessionView, event *models.Event) error {
-	err := view.PutUserSessions(v.Db, userSessionTable, userSession...)
-	if err != nil {
-		return err
-	}
-	return v.ProcessedUserSessionSequence(event)
+func (v *View) PutUserSessions(userSession []*model.UserSessionView) error {
+	return view.PutUserSessions(v.Db, userSessionTable, userSession...)
 }
 
-func (v *View) DeleteUserSessions(userID, instanceID string, event *models.Event) error {
+func (v *View) DeleteUserSessions(userID, instanceID string) error {
 	err := view.DeleteUserSessions(v.Db, userSessionTable, userID, instanceID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedUserSessionSequence(event)
+	return nil
 }
 
-func (v *View) DeleteInstanceUserSessions(event *models.Event) error {
-	err := view.DeleteInstanceUserSessions(v.Db, userSessionTable, event.InstanceID)
+func (v *View) DeleteInstanceUserSessions(instanceID string) error {
+	err := view.DeleteInstanceUserSessions(v.Db, userSessionTable, instanceID)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedUserSessionSequence(event)
+	return nil
 }
 
-func (v *View) DeleteOrgUserSessions(event *models.Event) error {
-	err := view.DeleteOrgUserSessions(v.Db, userSessionTable, event.InstanceID, event.ResourceOwner)
+func (v *View) DeleteOrgUserSessions(event eventstore.Event) error {
+	err := view.DeleteOrgUserSessions(v.Db, userSessionTable, event.Aggregate().InstanceID, event.Aggregate().ResourceOwner)
 	if err != nil && !errors.IsNotFound(err) {
 		return err
 	}
-	return v.ProcessedUserSessionSequence(event)
+	return nil
 }
 
-func (v *View) GetLatestUserSessionSequence(ctx context.Context, instanceID string) (*repository.CurrentSequence, error) {
-	return v.latestSequence(ctx, userSessionTable, instanceID)
-}
-
-func (v *View) GetLatestUserSessionSequences(ctx context.Context, instanceIDs []string) ([]*repository.CurrentSequence, error) {
-	return v.latestSequences(ctx, userSessionTable, instanceIDs)
-}
-
-func (v *View) ProcessedUserSessionSequence(event *models.Event) error {
-	return v.saveCurrentSequence(userSessionTable, event)
-}
-
-func (v *View) UpdateUserSessionSpoolerRunTimestamp(instanceIDs []string) error {
-	return v.updateSpoolerRunSequence(userSessionTable, instanceIDs)
-}
-
-func (v *View) GetLatestUserSessionFailedEvent(sequence uint64, instanceID string) (*repository.FailedEvent, error) {
-	return v.latestFailedEvent(userSessionTable, instanceID, sequence)
-}
-
-func (v *View) ProcessedUserSessionFailedEvent(failedEvent *repository.FailedEvent) error {
-	return v.saveFailedEvent(failedEvent)
+func (v *View) GetLatestUserSessionSequence(ctx context.Context, instanceID string) (_ *query.CurrentState, err error) {
+	q := &query.CurrentStateSearchQueries{
+		Queries: make([]query.SearchQuery, 2),
+	}
+	q.Queries[0], err = query.NewCurrentStatesInstanceIDSearchQuery(instanceID)
+	if err != nil {
+		return nil, err
+	}
+	q.Queries[1], err = query.NewCurrentStatesProjectionSearchQuery(userSessionTable)
+	if err != nil {
+		return nil, err
+	}
+	states, err := v.query.SearchCurrentStates(ctx, q)
+	if err != nil || states.SearchResponse.Count == 0 {
+		return nil, err
+	}
+	return states.CurrentStates[0], nil
 }

internal/auth/repository/eventsourcing/view/view.go

@@ -8,32 +8,29 @@ import (
 	"github.com/zitadel/zitadel/internal/api/call"
 	"github.com/zitadel/zitadel/internal/crypto"
 	"github.com/zitadel/zitadel/internal/database"
-	eventstore "github.com/zitadel/zitadel/internal/eventstore/v1"
-	"github.com/zitadel/zitadel/internal/id"
+	"github.com/zitadel/zitadel/internal/eventstore"
 	"github.com/zitadel/zitadel/internal/query"
 )
 
 type View struct {
 	Db           *gorm.DB
-	keyAlgorithm crypto.EncryptionAlgorithm
-	idGenerator  id.Generator
-	query        *query.Queries
-	es           eventstore.Eventstore
 	client       *database.DB
+	keyAlgorithm crypto.EncryptionAlgorithm
+	query        *query.Queries
+	es           *eventstore.Eventstore
 }
 
-func StartView(sqlClient *database.DB, keyAlgorithm crypto.EncryptionAlgorithm, queries *query.Queries, idGenerator id.Generator, es eventstore.Eventstore) (*View, error) {
+func StartView(sqlClient *database.DB, keyAlgorithm crypto.EncryptionAlgorithm, queries *query.Queries, es *eventstore.Eventstore) (*View, error) {
 	gorm, err := gorm.Open("postgres", sqlClient.DB)
 	if err != nil {
 		return nil, err
 	}
 	return &View{
 		Db:           gorm,
+		client:       sqlClient,
 		keyAlgorithm: keyAlgorithm,
-		idGenerator:  idGenerator,
 		query:        queries,
 		es:           es,
-		client:       sqlClient,
 	}, nil
 }