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/notification/handlers/already_handled.go

@@ -11,10 +11,10 @@ func (n *NotificationQueries) IsAlreadyHandled(ctx context.Context, event events
 		ctx,
 		eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
 			InstanceID(event.Aggregate().InstanceID).
+			SequenceGreater(event.Sequence()).
 			AddQuery().
 			AggregateTypes(aggregateType).
 			AggregateIDs(event.Aggregate().ID).
-			SequenceGreater(event.Sequence()).
 			EventTypes(eventTypes...).
 			EventData(data).
 			Builder(),

internal/notification/handlers/ctx.go

@@ -9,7 +9,7 @@ import (
 
 const NotifyUserID = "NOTIFICATION" //TODO: system?
 
-func HandlerContext(event eventstore.Aggregate) context.Context {
+func HandlerContext(event *eventstore.Aggregate) context.Context {
 	ctx := authz.WithInstanceID(context.Background(), event.InstanceID)
 	return authz.SetCtxData(ctx, authz.CtxData{UserID: NotifyUserID, OrgID: event.ResourceOwner})
 }

internal/notification/handlers/quota_notifier.go

@@ -7,12 +7,10 @@ import (
 	"github.com/zitadel/zitadel/internal/command"
 	"github.com/zitadel/zitadel/internal/errors"
 	"github.com/zitadel/zitadel/internal/eventstore"
-	"github.com/zitadel/zitadel/internal/eventstore/handler"
-	"github.com/zitadel/zitadel/internal/eventstore/handler/crdb"
+	"github.com/zitadel/zitadel/internal/eventstore/handler/v2"
 	"github.com/zitadel/zitadel/internal/notification/channels/webhook"
 	_ "github.com/zitadel/zitadel/internal/notification/statik"
 	"github.com/zitadel/zitadel/internal/notification/types"
-	"github.com/zitadel/zitadel/internal/query/projection"
 	"github.com/zitadel/zitadel/internal/repository/quota"
 )
 
@@ -21,7 +19,6 @@ const (
 )
 
 type quotaNotifier struct {
-	crdb.StatementHandler
 	commands *command.Commands
 	queries  *NotificationQueries
 	channels types.ChannelChains
@@ -29,27 +26,28 @@ type quotaNotifier struct {
 
 func NewQuotaNotifier(
 	ctx context.Context,
-	config crdb.StatementHandlerConfig,
+	config handler.Config,
 	commands *command.Commands,
 	queries *NotificationQueries,
 	channels types.ChannelChains,
-) *quotaNotifier {
-	p := new(quotaNotifier)
-	config.ProjectionName = QuotaNotificationsProjectionTable
-	config.Reducers = p.reducers()
-	p.StatementHandler = crdb.NewStatementHandler(ctx, config)
-	p.commands = commands
-	p.queries = queries
-	p.channels = channels
-	projection.NotificationsQuotaProjection = p
-	return p
+) *handler.Handler {
+	return handler.NewHandler(ctx, &config, &quotaNotifier{
+		commands: commands,
+		queries:  queries,
+		channels: channels,
+	})
+
 }
 
-func (u *quotaNotifier) reducers() []handler.AggregateReducer {
+func (*quotaNotifier) Name() string {
+	return QuotaNotificationsProjectionTable
+}
+
+func (u *quotaNotifier) Reducers() []handler.AggregateReducer {
 	return []handler.AggregateReducer{
 		{
 			Aggregate: quota.AggregateType,
-			EventRedusers: []handler.EventReducer{
+			EventReducers: []handler.EventReducer{
 				{
 					Event:  quota.NotificationDueEventType,
 					Reduce: u.reduceNotificationDue,
@@ -64,21 +62,20 @@ func (u *quotaNotifier) reduceNotificationDue(event eventstore.Event) (*handler.
 	if !ok {
 		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-DLxdE", "reduce.wrong.event.type %s", quota.NotificationDueEventType)
 	}
-	ctx := HandlerContext(event.Aggregate())
-	alreadyHandled, err := u.queries.IsAlreadyHandled(ctx, event, map[string]interface{}{"dueEventID": e.ID}, quota.AggregateType, quota.NotifiedEventType)
-	if err != nil {
-		return nil, err
-	}
-	if alreadyHandled {
-		return crdb.NewNoOpStatement(e), nil
-	}
-	err = types.SendJSON(ctx, webhook.Config{CallURL: e.CallURL, Method: http.MethodPost}, u.channels, e, e).WithoutTemplate()
-	if err != nil {
-		return nil, err
-	}
-	err = u.commands.UsageNotificationSent(ctx, e)
-	if err != nil {
-		return nil, err
-	}
-	return crdb.NewNoOpStatement(e), nil
+
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		ctx := HandlerContext(event.Aggregate())
+		alreadyHandled, err := u.queries.IsAlreadyHandled(ctx, event, map[string]interface{}{"dueEventID": e.ID}, quota.AggregateType, quota.NotifiedEventType)
+		if err != nil {
+			return err
+		}
+		if alreadyHandled {
+			return nil
+		}
+		err = types.SendJSON(ctx, webhook.Config{CallURL: e.CallURL, Method: http.MethodPost}, u.channels, e, e).WithoutTemplate()
+		if err != nil {
+			return err
+		}
+		return u.commands.UsageNotificationSent(ctx, e)
+	}), nil
 }

internal/notification/handlers/telemetry_pusher.go

@@ -3,7 +3,6 @@ package handlers
 import (
 	"context"
 	"fmt"
-	"math"
 	"net/http"
 	"time"
 
@@ -14,13 +13,11 @@ import (
 	"github.com/zitadel/zitadel/internal/command"
 	"github.com/zitadel/zitadel/internal/errors"
 	"github.com/zitadel/zitadel/internal/eventstore"
-	"github.com/zitadel/zitadel/internal/eventstore/handler"
-	"github.com/zitadel/zitadel/internal/eventstore/handler/crdb"
+	"github.com/zitadel/zitadel/internal/eventstore/handler/v2"
 	"github.com/zitadel/zitadel/internal/notification/channels/webhook"
 	_ "github.com/zitadel/zitadel/internal/notification/statik"
 	"github.com/zitadel/zitadel/internal/notification/types"
 	"github.com/zitadel/zitadel/internal/query"
-	"github.com/zitadel/zitadel/internal/query/projection"
 	"github.com/zitadel/zitadel/internal/repository/milestone"
 	"github.com/zitadel/zitadel/internal/repository/pseudo"
 )
@@ -37,7 +34,6 @@ type TelemetryPusherConfig struct {
 }
 
 type telemetryPusher struct {
-	crdb.StatementHandler
 	cfg      TelemetryPusherConfig
 	commands *command.Commands
 	queries  *NotificationQueries
@@ -47,28 +43,33 @@ type telemetryPusher struct {
 func NewTelemetryPusher(
 	ctx context.Context,
 	telemetryCfg TelemetryPusherConfig,
-	handlerCfg crdb.StatementHandlerConfig,
+	handlerCfg handler.Config,
 	commands *command.Commands,
 	queries *NotificationQueries,
 	channels types.ChannelChains,
-) *telemetryPusher {
-	p := new(telemetryPusher)
-	handlerCfg.ProjectionName = TelemetryProjectionTable
-	handlerCfg.Reducers = p.reducers()
-	p.cfg = telemetryCfg
-	handlerCfg.ConcurrentInstances = math.MaxInt
-	p.StatementHandler = crdb.NewStatementHandler(ctx, handlerCfg)
-	p.commands = commands
-	p.queries = queries
-	p.channels = channels
-	projection.TelemetryPusherProjection = p
-	return p
+) *handler.Handler {
+	pusher := &telemetryPusher{
+		cfg:      telemetryCfg,
+		commands: commands,
+		queries:  queries,
+		channels: channels,
+	}
+	handlerCfg.TriggerWithoutEvents = pusher.pushMilestones
+	return handler.NewHandler(
+		ctx,
+		&handlerCfg,
+		pusher,
+	)
 }
 
-func (t *telemetryPusher) reducers() []handler.AggregateReducer {
+func (u *telemetryPusher) Name() string {
+	return TelemetryProjectionTable
+}
+
+func (t *telemetryPusher) Reducers() []handler.AggregateReducer {
 	return []handler.AggregateReducer{{
 		Aggregate: pseudo.AggregateType,
-		EventRedusers: []handler.EventReducer{{
+		EventReducers: []handler.EventReducer{{
 			Event:  pseudo.ScheduledEventType,
 			Reduce: t.pushMilestones,
 		}},
@@ -82,41 +83,42 @@ func (t *telemetryPusher) pushMilestones(event eventstore.Event) (*handler.State
 		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-lDTs5", "reduce.wrong.event.type %s", event.Type())
 	}
 
-	isReached, err := query.NewNotNullQuery(query.MilestoneReachedDateColID)
-	if err != nil {
-		return nil, err
-	}
-	isNotPushed, err := query.NewIsNullQuery(query.MilestonePushedDateColID)
-	if err != nil {
-		return nil, err
-	}
-	hasPrimaryDomain, err := query.NewNotNullQuery(query.MilestonePrimaryDomainColID)
-	if err != nil {
-		return nil, err
-	}
-	unpushedMilestones, err := t.queries.Queries.SearchMilestones(ctx, scheduledEvent.InstanceIDs, &query.MilestonesSearchQueries{
-		SearchRequest: query.SearchRequest{
-			Limit:         t.cfg.Limit,
-			SortingColumn: query.MilestoneReachedDateColID,
-			Asc:           true,
-		},
-		Queries: []query.SearchQuery{isReached, isNotPushed, hasPrimaryDomain},
-	})
-	if err != nil {
-		return nil, err
-	}
-	var errs int
-	for _, ms := range unpushedMilestones.Milestones {
-		if err = t.pushMilestone(ctx, scheduledEvent, ms); err != nil {
-			errs++
-			logging.Warnf("pushing milestone %+v failed: %s", *ms, err.Error())
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		isReached, err := query.NewNotNullQuery(query.MilestoneReachedDateColID)
+		if err != nil {
+			return err
 		}
-	}
-	if errs > 0 {
-		return nil, fmt.Errorf("pushing %d of %d milestones failed", errs, unpushedMilestones.Count)
-	}
-
-	return crdb.NewNoOpStatement(scheduledEvent), nil
+		isNotPushed, err := query.NewIsNullQuery(query.MilestonePushedDateColID)
+		if err != nil {
+			return err
+		}
+		hasPrimaryDomain, err := query.NewNotNullQuery(query.MilestonePrimaryDomainColID)
+		if err != nil {
+			return err
+		}
+		unpushedMilestones, err := t.queries.Queries.SearchMilestones(ctx, scheduledEvent.InstanceIDs, &query.MilestonesSearchQueries{
+			SearchRequest: query.SearchRequest{
+				Limit:         t.cfg.Limit,
+				SortingColumn: query.MilestoneReachedDateColID,
+				Asc:           true,
+			},
+			Queries: []query.SearchQuery{isReached, isNotPushed, hasPrimaryDomain},
+		})
+		if err != nil {
+			return err
+		}
+		var errs int
+		for _, ms := range unpushedMilestones.Milestones {
+			if err = t.pushMilestone(ctx, scheduledEvent, ms); err != nil {
+				errs++
+				logging.Warnf("pushing milestone %+v failed: %s", *ms, err.Error())
+			}
+		}
+		if errs > 0 {
+			return fmt.Errorf("pushing %d of %d milestones failed", errs, unpushedMilestones.Count)
+		}
+		return nil
+	}), nil
 }
 
 func (t *telemetryPusher) pushMilestone(ctx context.Context, event *pseudo.ScheduledEvent, ms *query.Milestone) error {

internal/notification/handlers/user_notifier.go

@@ -11,11 +11,9 @@ import (
 	"github.com/zitadel/zitadel/internal/domain"
 	"github.com/zitadel/zitadel/internal/errors"
 	"github.com/zitadel/zitadel/internal/eventstore"
-	"github.com/zitadel/zitadel/internal/eventstore/handler"
-	"github.com/zitadel/zitadel/internal/eventstore/handler/crdb"
+	"github.com/zitadel/zitadel/internal/eventstore/handler/v2"
 	"github.com/zitadel/zitadel/internal/notification/types"
 	"github.com/zitadel/zitadel/internal/query"
-	"github.com/zitadel/zitadel/internal/query/projection"
 	"github.com/zitadel/zitadel/internal/repository/session"
 	"github.com/zitadel/zitadel/internal/repository/user"
 )
@@ -25,7 +23,6 @@ const (
 )
 
 type userNotifier struct {
-	crdb.StatementHandler
 	commands     Commands
 	queries      *NotificationQueries
 	channels     types.ChannelChains
@@ -34,29 +31,29 @@ type userNotifier struct {
 
 func NewUserNotifier(
 	ctx context.Context,
-	config crdb.StatementHandlerConfig,
+	config handler.Config,
 	commands Commands,
 	queries *NotificationQueries,
 	channels types.ChannelChains,
 	otpEmailTmpl string,
-) *userNotifier {
-	p := new(userNotifier)
-	config.ProjectionName = UserNotificationsProjectionTable
-	config.Reducers = p.reducers()
-	p.StatementHandler = crdb.NewStatementHandler(ctx, config)
-	p.commands = commands
-	p.queries = queries
-	p.channels = channels
-	p.otpEmailTmpl = otpEmailTmpl
-	projection.NotificationsProjection = p
-	return p
+) *handler.Handler {
+	return handler.NewHandler(ctx, &config, &userNotifier{
+		commands:     commands,
+		queries:      queries,
+		otpEmailTmpl: otpEmailTmpl,
+		channels:     channels,
+	})
 }
 
-func (u *userNotifier) reducers() []handler.AggregateReducer {
+func (u *userNotifier) Name() string {
+	return UserNotificationsProjectionTable
+}
+
+func (u *userNotifier) Reducers() []handler.AggregateReducer {
 	return []handler.AggregateReducer{
 		{
 			Aggregate: user.AggregateType,
-			EventRedusers: []handler.EventReducer{
+			EventReducers: []handler.EventReducer{
 				{
 					Event:  user.UserV1InitialCodeAddedType,
 					Reduce: u.reduceInitCodeAdded,
@@ -113,7 +110,7 @@ func (u *userNotifier) reducers() []handler.AggregateReducer {
 		},
 		{
 			Aggregate: session.AggregateType,
-			EventRedusers: []handler.EventReducer{
+			EventReducers: []handler.EventReducer{
 				{
 					Event:  session.OTPSMSChallengedType,
 					Reduce: u.reduceSessionOTPSMSChallenged,
@@ -132,52 +129,52 @@ func (u *userNotifier) reduceInitCodeAdded(event eventstore.Event) (*handler.Sta
 	if !ok {
 		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-EFe2f", "reduce.wrong.event.type %s", user.HumanInitialCodeAddedType)
 	}
-	ctx := HandlerContext(event.Aggregate())
-	alreadyHandled, err := u.checkIfCodeAlreadyHandledOrExpired(ctx, event, e.Expiry, nil,
-		user.UserV1InitialCodeAddedType, user.UserV1InitialCodeSentType,
-		user.HumanInitialCodeAddedType, user.HumanInitialCodeSentType)
-	if err != nil {
-		return nil, err
-	}
-	if alreadyHandled {
-		return crdb.NewNoOpStatement(e), nil
-	}
-	code, err := crypto.DecryptString(e.Code, u.queries.UserDataCrypto)
-	if err != nil {
-		return nil, err
-	}
-	colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
-	if err != nil {
-		return nil, err
-	}
 
-	template, err := u.queries.MailTemplateByOrg(ctx, e.Aggregate().ResourceOwner, false)
-	if err != nil {
-		return nil, err
-	}
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		ctx := HandlerContext(event.Aggregate())
+		alreadyHandled, err := u.checkIfCodeAlreadyHandledOrExpired(ctx, event, e.Expiry, nil,
+			user.UserV1InitialCodeAddedType, user.UserV1InitialCodeSentType,
+			user.HumanInitialCodeAddedType, user.HumanInitialCodeSentType)
+		if err != nil {
+			return err
+		}
+		if alreadyHandled {
+			return nil
+		}
+		code, err := crypto.DecryptString(e.Code, u.queries.UserDataCrypto)
+		if err != nil {
+			return err
+		}
+		colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
+		if err != nil {
+			return err
+		}
 
-	notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
-	if err != nil {
-		return nil, err
-	}
-	translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.InitCodeMessageType)
-	if err != nil {
-		return nil, err
-	}
-	ctx, err = u.queries.Origin(ctx, e)
-	if err != nil {
-		return nil, err
-	}
-	err = types.SendEmail(ctx, u.channels, string(template.Template), translator, notifyUser, colors, e).
-		SendUserInitCode(ctx, notifyUser, code)
-	if err != nil {
-		return nil, err
-	}
-	err = u.commands.HumanInitCodeSent(ctx, e.Aggregate().ResourceOwner, e.Aggregate().ID)
-	if err != nil {
-		return nil, err
-	}
-	return crdb.NewNoOpStatement(e), nil
+		template, err := u.queries.MailTemplateByOrg(ctx, e.Aggregate().ResourceOwner, false)
+		if err != nil {
+			return err
+		}
+
+		notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
+		if err != nil {
+			return err
+		}
+		translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.InitCodeMessageType)
+		if err != nil {
+			return err
+		}
+
+		ctx, err = u.queries.Origin(ctx, e)
+		if err != nil {
+			return err
+		}
+		err = types.SendEmail(ctx, u.channels, string(template.Template), translator, notifyUser, colors, e).
+			SendUserInitCode(ctx, notifyUser, code)
+		if err != nil {
+			return err
+		}
+		return u.commands.HumanInitCodeSent(ctx, e.Aggregate().ResourceOwner, e.Aggregate().ID)
+	}), nil
 }
 
 func (u *userNotifier) reduceEmailCodeAdded(event eventstore.Event) (*handler.Statement, error) {
@@ -187,54 +184,54 @@ func (u *userNotifier) reduceEmailCodeAdded(event eventstore.Event) (*handler.St
 	}
 
 	if e.CodeReturned {
-		return crdb.NewNoOpStatement(e), nil
-	}
-	ctx := HandlerContext(event.Aggregate())
-	alreadyHandled, err := u.checkIfCodeAlreadyHandledOrExpired(ctx, event, e.Expiry, nil,
-		user.UserV1EmailCodeAddedType, user.UserV1EmailCodeSentType,
-		user.HumanEmailCodeAddedType, user.HumanEmailCodeSentType)
-	if err != nil {
-		return nil, err
-	}
-	if alreadyHandled {
-		return crdb.NewNoOpStatement(e), nil
-	}
-	code, err := crypto.DecryptString(e.Code, u.queries.UserDataCrypto)
-	if err != nil {
-		return nil, err
-	}
-	colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
-	if err != nil {
-		return nil, err
+		return handler.NewNoOpStatement(e), nil
 	}
 
-	template, err := u.queries.MailTemplateByOrg(ctx, e.Aggregate().ResourceOwner, false)
-	if err != nil {
-		return nil, err
-	}
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		ctx := HandlerContext(event.Aggregate())
+		alreadyHandled, err := u.checkIfCodeAlreadyHandledOrExpired(ctx, event, e.Expiry, nil,
+			user.UserV1EmailCodeAddedType, user.UserV1EmailCodeSentType,
+			user.HumanEmailCodeAddedType, user.HumanEmailCodeSentType)
+		if err != nil {
+			return err
+		}
+		if alreadyHandled {
+			return nil
+		}
+		code, err := crypto.DecryptString(e.Code, u.queries.UserDataCrypto)
+		if err != nil {
+			return err
+		}
+		colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
+		if err != nil {
+			return err
+		}
 
-	notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
-	if err != nil {
-		return nil, err
-	}
-	translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.VerifyEmailMessageType)
-	if err != nil {
-		return nil, err
-	}
-	ctx, err = u.queries.Origin(ctx, e)
-	if err != nil {
-		return nil, err
-	}
-	err = types.SendEmail(ctx, u.channels, string(template.Template), translator, notifyUser, colors, e).
-		SendEmailVerificationCode(ctx, notifyUser, code, e.URLTemplate)
-	if err != nil {
-		return nil, err
-	}
-	err = u.commands.HumanEmailVerificationCodeSent(ctx, e.Aggregate().ResourceOwner, e.Aggregate().ID)
-	if err != nil {
-		return nil, err
-	}
-	return crdb.NewNoOpStatement(e), nil
+		template, err := u.queries.MailTemplateByOrg(ctx, e.Aggregate().ResourceOwner, false)
+		if err != nil {
+			return err
+		}
+
+		notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
+		if err != nil {
+			return err
+		}
+		translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.VerifyEmailMessageType)
+		if err != nil {
+			return err
+		}
+
+		ctx, err = u.queries.Origin(ctx, e)
+		if err != nil {
+			return err
+		}
+		err = types.SendEmail(ctx, u.channels, string(template.Template), translator, notifyUser, colors, e).
+			SendEmailVerificationCode(ctx, notifyUser, code, e.URLTemplate)
+		if err != nil {
+			return err
+		}
+		return u.commands.HumanEmailVerificationCodeSent(ctx, e.Aggregate().ResourceOwner, e.Aggregate().ID)
+	}), nil
 }
 
 func (u *userNotifier) reducePasswordCodeAdded(event eventstore.Event) (*handler.Statement, error) {
@@ -243,57 +240,57 @@ func (u *userNotifier) reducePasswordCodeAdded(event eventstore.Event) (*handler
 		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-Eeg3s", "reduce.wrong.event.type %s", user.HumanPasswordCodeAddedType)
 	}
 	if e.CodeReturned {
-		return crdb.NewNoOpStatement(e), nil
-	}
-	ctx := HandlerContext(event.Aggregate())
-	alreadyHandled, err := u.checkIfCodeAlreadyHandledOrExpired(ctx, event, e.Expiry, nil,
-		user.UserV1PasswordCodeAddedType, user.UserV1PasswordCodeSentType,
-		user.HumanPasswordCodeAddedType, user.HumanPasswordCodeSentType)
-	if err != nil {
-		return nil, err
-	}
-	if alreadyHandled {
-		return crdb.NewNoOpStatement(e), nil
-	}
-	code, err := crypto.DecryptString(e.Code, u.queries.UserDataCrypto)
-	if err != nil {
-		return nil, err
-	}
-	colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
-	if err != nil {
-		return nil, err
+		return handler.NewNoOpStatement(e), nil
 	}
 
-	template, err := u.queries.MailTemplateByOrg(ctx, e.Aggregate().ResourceOwner, false)
-	if err != nil {
-		return nil, err
-	}
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		ctx := HandlerContext(event.Aggregate())
+		alreadyHandled, err := u.checkIfCodeAlreadyHandledOrExpired(ctx, event, e.Expiry, nil,
+			user.UserV1PasswordCodeAddedType, user.UserV1PasswordCodeSentType,
+			user.HumanPasswordCodeAddedType, user.HumanPasswordCodeSentType)
+		if err != nil {
+			return err
+		}
+		if alreadyHandled {
+			return nil
+		}
+		code, err := crypto.DecryptString(e.Code, u.queries.UserDataCrypto)
+		if err != nil {
+			return err
+		}
+		colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
+		if err != nil {
+			return err
+		}
 
-	notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
-	if err != nil {
-		return nil, err
-	}
-	translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.PasswordResetMessageType)
-	if err != nil {
-		return nil, err
-	}
-	ctx, err = u.queries.Origin(ctx, e)
-	if err != nil {
-		return nil, err
-	}
-	notify := types.SendEmail(ctx, u.channels, string(template.Template), translator, notifyUser, colors, e)
-	if e.NotificationType == domain.NotificationTypeSms {
-		notify = types.SendSMSTwilio(ctx, u.channels, translator, notifyUser, colors, e)
-	}
-	err = notify.SendPasswordCode(ctx, notifyUser, code, e.URLTemplate)
-	if err != nil {
-		return nil, err
-	}
-	err = u.commands.PasswordCodeSent(ctx, e.Aggregate().ResourceOwner, e.Aggregate().ID)
-	if err != nil {
-		return nil, err
-	}
-	return crdb.NewNoOpStatement(e), nil
+		template, err := u.queries.MailTemplateByOrg(ctx, e.Aggregate().ResourceOwner, false)
+		if err != nil {
+			return err
+		}
+
+		notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
+		if err != nil {
+			return err
+		}
+		translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.PasswordResetMessageType)
+		if err != nil {
+			return err
+		}
+
+		ctx, err = u.queries.Origin(ctx, e)
+		if err != nil {
+			return err
+		}
+		notify := types.SendEmail(ctx, u.channels, string(template.Template), translator, notifyUser, colors, e)
+		if e.NotificationType == domain.NotificationTypeSms {
+			notify = types.SendSMSTwilio(ctx, u.channels, translator, notifyUser, colors, e)
+		}
+		err = notify.SendPasswordCode(ctx, notifyUser, code, e.URLTemplate)
+		if err != nil {
+			return err
+		}
+		return u.commands.PasswordCodeSent(ctx, e.Aggregate().ResourceOwner, e.Aggregate().ID)
+	}), nil
 }
 
 func (u *userNotifier) reduceOTPSMSCodeAdded(event eventstore.Event) (*handler.Statement, error) {
@@ -319,7 +316,7 @@ func (u *userNotifier) reduceSessionOTPSMSChallenged(event eventstore.Event) (*h
 		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-Sk32L", "reduce.wrong.event.type %s", session.OTPSMSChallengedType)
 	}
 	if e.CodeReturned {
-		return crdb.NewNoOpStatement(e), nil
+		return handler.NewNoOpStatement(e), nil
 	}
 	ctx := HandlerContext(event.Aggregate())
 	s, err := u.queries.SessionByID(ctx, true, e.Aggregate().ID, "")
@@ -353,7 +350,7 @@ func (u *userNotifier) reduceOTPSMS(
 		return nil, err
 	}
 	if alreadyHandled {
-		return crdb.NewNoOpStatement(event), nil
+		return handler.NewNoOpStatement(event), nil
 	}
 	plainCode, err := crypto.DecryptString(code, u.queries.UserDataCrypto)
 	if err != nil {
@@ -385,7 +382,7 @@ func (u *userNotifier) reduceOTPSMS(
 	if err != nil {
 		return nil, err
 	}
-	return crdb.NewNoOpStatement(event), nil
+	return handler.NewNoOpStatement(event), nil
 }
 
 func (u *userNotifier) reduceOTPEmailCodeAdded(event eventstore.Event) (*handler.Statement, error) {
@@ -419,7 +416,7 @@ func (u *userNotifier) reduceSessionOTPEmailChallenged(event eventstore.Event) (
 		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-zbsgt", "reduce.wrong.event.type %s", session.OTPEmailChallengedType)
 	}
 	if e.ReturnCode {
-		return crdb.NewNoOpStatement(e), nil
+		return handler.NewNoOpStatement(e), nil
 	}
 	ctx := HandlerContext(event.Aggregate())
 	s, err := u.queries.SessionByID(ctx, true, e.Aggregate().ID, "")
@@ -466,7 +463,7 @@ func (u *userNotifier) reduceOTPEmail(
 		return nil, err
 	}
 	if alreadyHandled {
-		return crdb.NewNoOpStatement(event), nil
+		return handler.NewNoOpStatement(event), nil
 	}
 	plainCode, err := crypto.DecryptString(code, u.queries.UserDataCrypto)
 	if err != nil {
@@ -507,7 +504,7 @@ func (u *userNotifier) reduceOTPEmail(
 	if err != nil {
 		return nil, err
 	}
-	return crdb.NewNoOpStatement(event), nil
+	return handler.NewNoOpStatement(event), nil
 }
 
 func (u *userNotifier) reduceDomainClaimed(event eventstore.Event) (*handler.Statement, error) {
@@ -515,47 +512,46 @@ func (u *userNotifier) reduceDomainClaimed(event eventstore.Event) (*handler.Sta
 	if !ok {
 		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-Drh5w", "reduce.wrong.event.type %s", user.UserDomainClaimedType)
 	}
-	ctx := HandlerContext(event.Aggregate())
-	alreadyHandled, err := u.queries.IsAlreadyHandled(ctx, event, nil, user.AggregateType,
-		user.UserDomainClaimedType, user.UserDomainClaimedSentType)
-	if err != nil {
-		return nil, err
-	}
-	if alreadyHandled {
-		return crdb.NewNoOpStatement(e), nil
-	}
-	colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
-	if err != nil {
-		return nil, err
-	}
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		ctx := HandlerContext(event.Aggregate())
+		alreadyHandled, err := u.queries.IsAlreadyHandled(ctx, event, nil, user.AggregateType,
+			user.UserDomainClaimedType, user.UserDomainClaimedSentType)
+		if err != nil {
+			return err
+		}
+		if alreadyHandled {
+			return nil
+		}
+		colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
+		if err != nil {
+			return err
+		}
 
-	template, err := u.queries.MailTemplateByOrg(ctx, e.Aggregate().ResourceOwner, false)
-	if err != nil {
-		return nil, err
-	}
+		template, err := u.queries.MailTemplateByOrg(ctx, e.Aggregate().ResourceOwner, false)
+		if err != nil {
+			return err
+		}
 
-	notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
-	if err != nil {
-		return nil, err
-	}
-	translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.DomainClaimedMessageType)
-	if err != nil {
-		return nil, err
-	}
-	ctx, err = u.queries.Origin(ctx, e)
-	if err != nil {
-		return nil, err
-	}
-	err = types.SendEmail(ctx, u.channels, string(template.Template), translator, notifyUser, colors, e).
-		SendDomainClaimed(ctx, notifyUser, e.UserName)
-	if err != nil {
-		return nil, err
-	}
-	err = u.commands.UserDomainClaimedSent(ctx, e.Aggregate().ResourceOwner, e.Aggregate().ID)
-	if err != nil {
-		return nil, err
-	}
-	return crdb.NewNoOpStatement(e), nil
+		notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
+		if err != nil {
+			return err
+		}
+		translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.DomainClaimedMessageType)
+		if err != nil {
+			return err
+		}
+
+		ctx, err = u.queries.Origin(ctx, e)
+		if err != nil {
+			return err
+		}
+		err = types.SendEmail(ctx, u.channels, string(template.Template), translator, notifyUser, colors, e).
+			SendDomainClaimed(ctx, notifyUser, e.UserName)
+		if err != nil {
+			return err
+		}
+		return u.commands.UserDomainClaimedSent(ctx, e.Aggregate().ResourceOwner, e.Aggregate().ID)
+	}), nil
 }
 
 func (u *userNotifier) reducePasswordlessCodeRequested(event eventstore.Event) (*handler.Statement, error) {
@@ -564,52 +560,52 @@ func (u *userNotifier) reducePasswordlessCodeRequested(event eventstore.Event) (
 		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-EDtjd", "reduce.wrong.event.type %s", user.HumanPasswordlessInitCodeAddedType)
 	}
 	if e.CodeReturned {
-		return crdb.NewNoOpStatement(e), nil
-	}
-	ctx := HandlerContext(event.Aggregate())
-	alreadyHandled, err := u.checkIfCodeAlreadyHandledOrExpired(ctx, event, e.Expiry, map[string]interface{}{"id": e.ID}, user.HumanPasswordlessInitCodeSentType)
-	if err != nil {
-		return nil, err
-	}
-	if alreadyHandled {
-		return crdb.NewNoOpStatement(e), nil
-	}
-	code, err := crypto.DecryptString(e.Code, u.queries.UserDataCrypto)
-	if err != nil {
-		return nil, err
-	}
-	colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
-	if err != nil {
-		return nil, err
+		return handler.NewNoOpStatement(e), nil
 	}
 
-	template, err := u.queries.MailTemplateByOrg(ctx, e.Aggregate().ResourceOwner, false)
-	if err != nil {
-		return nil, err
-	}
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		ctx := HandlerContext(event.Aggregate())
+		alreadyHandled, err := u.checkIfCodeAlreadyHandledOrExpired(ctx, event, e.Expiry, map[string]interface{}{"id": e.ID}, user.HumanPasswordlessInitCodeSentType)
+		if err != nil {
+			return err
+		}
+		if alreadyHandled {
+			return nil
+		}
+		code, err := crypto.DecryptString(e.Code, u.queries.UserDataCrypto)
+		if err != nil {
+			return err
+		}
+		colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
+		if err != nil {
+			return err
+		}
 
-	notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
-	if err != nil {
-		return nil, err
-	}
-	translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.PasswordlessRegistrationMessageType)
-	if err != nil {
-		return nil, err
-	}
-	ctx, err = u.queries.Origin(ctx, e)
-	if err != nil {
-		return nil, err
-	}
-	err = types.SendEmail(ctx, u.channels, string(template.Template), translator, notifyUser, colors, e).
-		SendPasswordlessRegistrationLink(ctx, notifyUser, code, e.ID, e.URLTemplate)
-	if err != nil {
-		return nil, err
-	}
-	err = u.commands.HumanPasswordlessInitCodeSent(ctx, e.Aggregate().ID, e.Aggregate().ResourceOwner, e.ID)
-	if err != nil {
-		return nil, err
-	}
-	return crdb.NewNoOpStatement(e), nil
+		template, err := u.queries.MailTemplateByOrg(ctx, e.Aggregate().ResourceOwner, false)
+		if err != nil {
+			return err
+		}
+
+		notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
+		if err != nil {
+			return err
+		}
+		translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.PasswordlessRegistrationMessageType)
+		if err != nil {
+			return err
+		}
+
+		ctx, err = u.queries.Origin(ctx, e)
+		if err != nil {
+			return err
+		}
+		err = types.SendEmail(ctx, u.channels, string(template.Template), translator, notifyUser, colors, e).
+			SendPasswordlessRegistrationLink(ctx, notifyUser, code, e.ID, e.URLTemplate)
+		if err != nil {
+			return err
+		}
+		return u.commands.HumanPasswordlessInitCodeSent(ctx, e.Aggregate().ID, e.Aggregate().ResourceOwner, e.ID)
+	}), nil
 }
 
 func (u *userNotifier) reducePasswordChanged(event eventstore.Event) (*handler.Statement, error) {
@@ -617,57 +613,58 @@ func (u *userNotifier) reducePasswordChanged(event eventstore.Event) (*handler.S
 	if !ok {
 		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-Yko2z8", "reduce.wrong.event.type %s", user.HumanPasswordChangedType)
 	}
-	ctx := HandlerContext(event.Aggregate())
-	alreadyHandled, err := u.queries.IsAlreadyHandled(ctx, event, nil, user.AggregateType, user.HumanPasswordChangeSentType)
-	if err != nil {
-		return nil, err
-	}
-	if alreadyHandled {
-		return crdb.NewNoOpStatement(e), nil
-	}
 
-	notificationPolicy, err := u.queries.NotificationPolicyByOrg(ctx, true, e.Aggregate().ResourceOwner, false)
-	if errors.IsNotFound(err) {
-		return crdb.NewNoOpStatement(e), nil
-	}
-	if err != nil {
-		return nil, err
-	}
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		ctx := HandlerContext(event.Aggregate())
+		alreadyHandled, err := u.queries.IsAlreadyHandled(ctx, event, nil, user.AggregateType, user.HumanPasswordChangeSentType)
+		if err != nil {
+			return err
+		}
+		if alreadyHandled {
+			return nil
+		}
+
+		notificationPolicy, err := u.queries.NotificationPolicyByOrg(ctx, true, e.Aggregate().ResourceOwner, false)
+		if errors.IsNotFound(err) {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+
+		if !notificationPolicy.PasswordChange {
+			return nil
+		}
 
-	if notificationPolicy.PasswordChange {
 		colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
 		if err != nil {
-			return nil, err
+			return err
 		}
 
 		template, err := u.queries.MailTemplateByOrg(ctx, e.Aggregate().ResourceOwner, false)
 		if err != nil {
-			return nil, err
+			return err
 		}
 
 		notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.PasswordChangeMessageType)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		ctx, err = u.queries.Origin(ctx, e)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		err = types.SendEmail(ctx, u.channels, string(template.Template), translator, notifyUser, colors, e).
 			SendPasswordChange(ctx, notifyUser)
 		if err != nil {
-			return nil, err
+			return err
 		}
-		err = u.commands.PasswordChangeSent(ctx, e.Aggregate().ResourceOwner, e.Aggregate().ID)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return crdb.NewNoOpStatement(e), nil
+		return u.commands.PasswordChangeSent(ctx, e.Aggregate().ResourceOwner, e.Aggregate().ID)
+	}), nil
 }
 
 func (u *userNotifier) reducePhoneCodeAdded(event eventstore.Event) (*handler.Statement, error) {
@@ -676,53 +673,53 @@ func (u *userNotifier) reducePhoneCodeAdded(event eventstore.Event) (*handler.St
 		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-He83g", "reduce.wrong.event.type %s", user.HumanPhoneCodeAddedType)
 	}
 	if e.CodeReturned {
-		return crdb.NewNoOpStatement(e), nil
-	}
-	ctx := HandlerContext(event.Aggregate())
-	alreadyHandled, err := u.checkIfCodeAlreadyHandledOrExpired(ctx, event, e.Expiry, nil,
-		user.UserV1PhoneCodeAddedType, user.UserV1PhoneCodeSentType,
-		user.HumanPhoneCodeAddedType, user.HumanPhoneCodeSentType)
-	if err != nil {
-		return nil, err
-	}
-	if alreadyHandled {
-		return crdb.NewNoOpStatement(e), nil
-	}
-	code, err := crypto.DecryptString(e.Code, u.queries.UserDataCrypto)
-	if err != nil {
-		return nil, err
-	}
-	colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
-	if err != nil {
-		return nil, err
+		return handler.NewNoOpStatement(e), nil
 	}
 
-	notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
-	if err != nil {
-		return nil, err
-	}
-	translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.VerifyPhoneMessageType)
-	if err != nil {
-		return nil, err
-	}
-	ctx, err = u.queries.Origin(ctx, e)
-	if err != nil {
-		return nil, err
-	}
-	err = types.SendSMSTwilio(ctx, u.channels, translator, notifyUser, colors, e).
-		SendPhoneVerificationCode(ctx, code)
-	if err != nil {
-		return nil, err
-	}
-	err = u.commands.HumanPhoneVerificationCodeSent(ctx, e.Aggregate().ResourceOwner, e.Aggregate().ID)
-	if err != nil {
-		return nil, err
-	}
-	return crdb.NewNoOpStatement(e), nil
+	return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
+		ctx := HandlerContext(event.Aggregate())
+		alreadyHandled, err := u.checkIfCodeAlreadyHandledOrExpired(ctx, event, e.Expiry, nil,
+			user.UserV1PhoneCodeAddedType, user.UserV1PhoneCodeSentType,
+			user.HumanPhoneCodeAddedType, user.HumanPhoneCodeSentType)
+		if err != nil {
+			return err
+		}
+		if alreadyHandled {
+			return nil
+		}
+		code, err := crypto.DecryptString(e.Code, u.queries.UserDataCrypto)
+		if err != nil {
+			return err
+		}
+		colors, err := u.queries.ActiveLabelPolicyByOrg(ctx, e.Aggregate().ResourceOwner, false)
+		if err != nil {
+			return err
+		}
+
+		notifyUser, err := u.queries.GetNotifyUserByID(ctx, true, e.Aggregate().ID, false)
+		if err != nil {
+			return err
+		}
+		translator, err := u.queries.GetTranslatorWithOrgTexts(ctx, notifyUser.ResourceOwner, domain.VerifyPhoneMessageType)
+		if err != nil {
+			return err
+		}
+
+		ctx, err = u.queries.Origin(ctx, e)
+		if err != nil {
+			return err
+		}
+		err = types.SendSMSTwilio(ctx, u.channels, translator, notifyUser, colors, e).
+			SendPhoneVerificationCode(ctx, code)
+		if err != nil {
+			return err
+		}
+		return u.commands.HumanPhoneVerificationCodeSent(ctx, e.Aggregate().ResourceOwner, e.Aggregate().ID)
+	}), nil
 }
 
 func (u *userNotifier) checkIfCodeAlreadyHandledOrExpired(ctx context.Context, event eventstore.Event, expiry time.Duration, data map[string]interface{}, eventTypes ...eventstore.EventType) (bool, error) {
-	if event.CreationDate().Add(expiry).Before(time.Now().UTC()) {
+	if event.CreatedAt().Add(expiry).Before(time.Now().UTC()) {
 		return true, nil
 	}
 	return u.queries.IsAlreadyHandled(ctx, event, data, user.AggregateType, eventTypes...)

internal/notification/handlers/user_notifier_test.go

@@ -72,9 +72,9 @@ func Test_userNotifier_reduceInitCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanInitialCodeAddedEvent{
@@ -111,9 +111,9 @@ func Test_userNotifier_reduceInitCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanInitialCodeAddedEvent{
@@ -144,9 +144,9 @@ func Test_userNotifier_reduceInitCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanInitialCodeAddedEvent{
@@ -184,9 +184,9 @@ func Test_userNotifier_reduceInitCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanInitialCodeAddedEvent{
@@ -210,7 +210,13 @@ func Test_userNotifier_reduceInitCodeAdded(t *testing.T) {
 			queries := mock.NewMockQueries(ctrl)
 			commands := mock.NewMockCommands(ctrl)
 			f, a, w := tt.test(ctrl, queries, commands)
-			_, err = newUserNotifier(t, ctrl, queries, fs, f, a, w).reduceInitCodeAdded(a.event)
+			stmt, err := newUserNotifier(t, ctrl, queries, fs, f, a, w).reduceInitCodeAdded(a.event)
+			if w.err != nil {
+				w.err(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+			err = stmt.Execute(nil, "")
 			if w.err != nil {
 				w.err(t, err)
 			} else {
@@ -241,9 +247,9 @@ func Test_userNotifier_reduceEmailCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanEmailCodeAddedEvent{
@@ -282,9 +288,9 @@ func Test_userNotifier_reduceEmailCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanEmailCodeAddedEvent{
@@ -317,9 +323,9 @@ func Test_userNotifier_reduceEmailCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 					SMSTokenCrypto: nil,
 				}, args{
@@ -360,9 +366,9 @@ func Test_userNotifier_reduceEmailCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanEmailCodeAddedEvent{
@@ -396,9 +402,9 @@ func Test_userNotifier_reduceEmailCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 					SMSTokenCrypto: nil,
 				}, args{
@@ -425,7 +431,13 @@ func Test_userNotifier_reduceEmailCodeAdded(t *testing.T) {
 			queries := mock.NewMockQueries(ctrl)
 			commands := mock.NewMockCommands(ctrl)
 			f, a, w := tt.test(ctrl, queries, commands)
-			_, err = newUserNotifier(t, ctrl, queries, fs, f, a, w).reduceEmailCodeAdded(a.event)
+			stmt, err := newUserNotifier(t, ctrl, queries, fs, f, a, w).reduceEmailCodeAdded(a.event)
+			if w.err != nil {
+				w.err(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+			err = stmt.Execute(nil, "")
 			if w.err != nil {
 				w.err(t, err)
 			} else {
@@ -456,9 +468,9 @@ func Test_userNotifier_reducePasswordCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanPasswordCodeAddedEvent{
@@ -497,9 +509,9 @@ func Test_userNotifier_reducePasswordCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanPasswordCodeAddedEvent{
@@ -532,9 +544,9 @@ func Test_userNotifier_reducePasswordCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 					SMSTokenCrypto: nil,
 				}, args{
@@ -575,9 +587,9 @@ func Test_userNotifier_reducePasswordCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanPasswordCodeAddedEvent{
@@ -611,9 +623,9 @@ func Test_userNotifier_reducePasswordCodeAdded(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 					SMSTokenCrypto: nil,
 				}, args{
@@ -640,7 +652,13 @@ func Test_userNotifier_reducePasswordCodeAdded(t *testing.T) {
 			queries := mock.NewMockQueries(ctrl)
 			commands := mock.NewMockCommands(ctrl)
 			f, a, w := tt.test(ctrl, queries, commands)
-			_, err = newUserNotifier(t, ctrl, queries, fs, f, a, w).reducePasswordCodeAdded(a.event)
+			stmt, err := newUserNotifier(t, ctrl, queries, fs, f, a, w).reducePasswordCodeAdded(a.event)
+			if w.err != nil {
+				w.err(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+			err = stmt.Execute(nil, "")
 			if w.err != nil {
 				w.err(t, err)
 			} else {
@@ -670,9 +688,9 @@ func Test_userNotifier_reduceDomainClaimed(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 				}, args{
 					event: &user.DomainClaimedEvent{
 						BaseEvent: *eventstore.BaseEventFromRepo(&repository.Event{
@@ -705,9 +723,9 @@ func Test_userNotifier_reduceDomainClaimed(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 				}, args{
 					event: &user.DomainClaimedEvent{
 						BaseEvent: *eventstore.BaseEventFromRepo(&repository.Event{
@@ -727,7 +745,13 @@ func Test_userNotifier_reduceDomainClaimed(t *testing.T) {
 			queries := mock.NewMockQueries(ctrl)
 			commands := mock.NewMockCommands(ctrl)
 			f, a, w := tt.test(ctrl, queries, commands)
-			_, err = newUserNotifier(t, ctrl, queries, fs, f, a, w).reduceDomainClaimed(a.event)
+			stmt, err := newUserNotifier(t, ctrl, queries, fs, f, a, w).reduceDomainClaimed(a.event)
+			if w.err != nil {
+				w.err(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+			err = stmt.Execute(nil, "")
 			if w.err != nil {
 				w.err(t, err)
 			} else {
@@ -758,9 +782,9 @@ func Test_userNotifier_reducePasswordlessCodeRequested(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanPasswordlessInitCodeRequestedEvent{
@@ -800,9 +824,9 @@ func Test_userNotifier_reducePasswordlessCodeRequested(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanPasswordlessInitCodeRequestedEvent{
@@ -836,9 +860,9 @@ func Test_userNotifier_reducePasswordlessCodeRequested(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 					SMSTokenCrypto: nil,
 				}, args{
@@ -880,9 +904,9 @@ func Test_userNotifier_reducePasswordlessCodeRequested(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &user.HumanPasswordlessInitCodeRequestedEvent{
@@ -917,9 +941,9 @@ func Test_userNotifier_reducePasswordlessCodeRequested(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 					SMSTokenCrypto: nil,
 				}, args{
@@ -947,7 +971,13 @@ func Test_userNotifier_reducePasswordlessCodeRequested(t *testing.T) {
 			queries := mock.NewMockQueries(ctrl)
 			commands := mock.NewMockCommands(ctrl)
 			f, a, w := tt.test(ctrl, queries, commands)
-			_, err = newUserNotifier(t, ctrl, queries, fs, f, a, w).reducePasswordlessCodeRequested(a.event)
+			stmt, err := newUserNotifier(t, ctrl, queries, fs, f, a, w).reducePasswordlessCodeRequested(a.event)
+			if w.err != nil {
+				w.err(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+			err = stmt.Execute(nil, "")
 			if w.err != nil {
 				w.err(t, err)
 			} else {
@@ -980,9 +1010,9 @@ func Test_userNotifier_reducePasswordChanged(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 				}, args{
 					event: &user.HumanPasswordChangedEvent{
 						BaseEvent: *eventstore.BaseEventFromRepo(&repository.Event{
@@ -1018,9 +1048,9 @@ func Test_userNotifier_reducePasswordChanged(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 				}, args{
 					event: &user.HumanPasswordChangedEvent{
 						BaseEvent: *eventstore.BaseEventFromRepo(&repository.Event{
@@ -1040,7 +1070,13 @@ func Test_userNotifier_reducePasswordChanged(t *testing.T) {
 			queries := mock.NewMockQueries(ctrl)
 			commands := mock.NewMockCommands(ctrl)
 			f, a, w := tt.test(ctrl, queries, commands)
-			_, err = newUserNotifier(t, ctrl, queries, fs, f, a, w).reducePasswordChanged(a.event)
+			stmt, err := newUserNotifier(t, ctrl, queries, fs, f, a, w).reducePasswordChanged(a.event)
+			if w.err != nil {
+				w.err(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+			err = stmt.Execute(nil, "")
 			if w.err != nil {
 				w.err(t, err)
 			} else {
@@ -1072,9 +1108,9 @@ func Test_userNotifier_reduceOTPEmailChallenged(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &session.OTPEmailChallengedEvent{
@@ -1114,9 +1150,9 @@ func Test_userNotifier_reduceOTPEmailChallenged(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &session.OTPEmailChallengedEvent{
@@ -1150,9 +1186,9 @@ func Test_userNotifier_reduceOTPEmailChallenged(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 					SMSTokenCrypto: nil,
 				}, args{
@@ -1194,9 +1230,9 @@ func Test_userNotifier_reduceOTPEmailChallenged(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 				}, args{
 					event: &session.OTPEmailChallengedEvent{
@@ -1230,9 +1266,9 @@ func Test_userNotifier_reduceOTPEmailChallenged(t *testing.T) {
 			return fields{
 					queries:  queries,
 					commands: commands,
-					es: eventstore.NewEventstore(eventstore.TestConfig(
-						es_repo_mock.NewRepo(t).ExpectFilterEvents(),
-					)),
+					es: eventstore.NewEventstore(&eventstore.Config{
+						Querier: es_repo_mock.NewRepo(t).ExpectFilterEvents().MockQuerier,
+					}),
 					userDataCrypto: codeAlg,
 					SMSTokenCrypto: nil,
 				}, args{

internal/notification/projections.go

@@ -33,9 +33,9 @@ func Start(
 	logging.OnError(err).Panic("unable to start listener")
 	q := handlers.NewNotificationQueries(queries, es, externalDomain, externalPort, externalSecure, fileSystemPath, userEncryption, smtpEncryption, smsEncryption, statikFS)
 	c := newChannels(q)
-	handlers.NewUserNotifier(ctx, projection.ApplyCustomConfig(userHandlerCustomConfig), commands, q, c, otpEmailTmpl).Start()
-	handlers.NewQuotaNotifier(ctx, projection.ApplyCustomConfig(quotaHandlerCustomConfig), commands, q, c).Start()
+	handlers.NewUserNotifier(ctx, projection.ApplyCustomConfig(userHandlerCustomConfig), commands, q, c, otpEmailTmpl).Start(ctx)
+	handlers.NewQuotaNotifier(ctx, projection.ApplyCustomConfig(quotaHandlerCustomConfig), commands, q, c).Start(ctx)
 	if telemetryCfg.Enabled {
-		handlers.NewTelemetryPusher(ctx, telemetryCfg, projection.ApplyCustomConfig(telemetryHandlerCustomConfig), commands, q, c).Start()
+		handlers.NewTelemetryPusher(ctx, telemetryCfg, projection.ApplyCustomConfig(telemetryHandlerCustomConfig), commands, q, c).Start(ctx)
 	}
 }

internal/notification/senders/email.go

@@ -4,7 +4,6 @@ import (
 	"context"
 
 	"github.com/zitadel/logging"
-
 	"github.com/zitadel/zitadel/internal/api/authz"
 	"github.com/zitadel/zitadel/internal/notification/channels"
 	"github.com/zitadel/zitadel/internal/notification/channels/fs"

internal/notification/senders/webhook.go

@@ -4,7 +4,6 @@ import (
 	"context"
 
 	"github.com/zitadel/logging"
-
 	"github.com/zitadel/zitadel/internal/api/authz"
 	"github.com/zitadel/zitadel/internal/notification/channels"
 	"github.com/zitadel/zitadel/internal/notification/channels/fs"