perf(milestones): refactor (#8788)

# Which Problems Are Solved

Milestones used existing events from a number of aggregates. OIDC
session is one of them. We noticed in load-tests that the reduction of
the oidc_session.added event into the milestone projection is a costly
business with payload based conditionals. A milestone is reached once,
but even then we remain subscribed to the OIDC events. This requires the
projections.current_states to be updated continuously.


# How the Problems Are Solved

The milestone creation is refactored to use dedicated events instead.
The command side decides when a milestone is reached and creates the
reached event once for each milestone when required.

# Additional Changes

In order to prevent reached milestones being created twice, a migration
script is provided. When the old `projections.milestones` table exist,
the state is read from there and `v2` milestone aggregate events are
created, with the original reached and pushed dates.

# Additional Context

- Closes https://github.com/zitadel/zitadel/issues/8800

internal/query/projection/milestones.go

@@ -2,35 +2,26 @@ package projection
 
 import (
 	"context"
-	"strconv"
 
-	internal_authz "github.com/zitadel/zitadel/internal/api/authz"
 	"github.com/zitadel/zitadel/internal/eventstore"
 	old_handler "github.com/zitadel/zitadel/internal/eventstore/handler"
 	"github.com/zitadel/zitadel/internal/eventstore/handler/v2"
-	"github.com/zitadel/zitadel/internal/repository/instance"
 	"github.com/zitadel/zitadel/internal/repository/milestone"
-	"github.com/zitadel/zitadel/internal/repository/oidcsession"
-	"github.com/zitadel/zitadel/internal/repository/project"
 )
 
 const (
-	MilestonesProjectionTable = "projections.milestones"
+	MilestonesProjectionTable = "projections.milestones2"
 
-	MilestoneColumnInstanceID      = "instance_id"
-	MilestoneColumnType            = "type"
-	MilestoneColumnPrimaryDomain   = "primary_domain"
-	MilestoneColumnReachedDate     = "reached_date"
-	MilestoneColumnPushedDate      = "last_pushed_date"
-	MilestoneColumnIgnoreClientIDs = "ignore_client_ids"
+	MilestoneColumnInstanceID  = "instance_id"
+	MilestoneColumnType        = "type"
+	MilestoneColumnReachedDate = "reached_date"
+	MilestoneColumnPushedDate  = "last_pushed_date"
 )
 
-type milestoneProjection struct {
-	systemUsers map[string]*internal_authz.SystemAPIUser
-}
+type milestoneProjection struct{}
 
-func newMilestoneProjection(ctx context.Context, config handler.Config, systemUsers map[string]*internal_authz.SystemAPIUser) *handler.Handler {
-	return handler.NewHandler(ctx, &config, &milestoneProjection{systemUsers: systemUsers})
+func newMilestoneProjection(ctx context.Context, config handler.Config) *handler.Handler {
+	return handler.NewHandler(ctx, &config, &milestoneProjection{})
 }
 
 func (*milestoneProjection) Name() string {
@@ -44,8 +35,6 @@ func (*milestoneProjection) Init() *old_handler.Check {
 			handler.NewColumn(MilestoneColumnType, handler.ColumnTypeEnum),
 			handler.NewColumn(MilestoneColumnReachedDate, handler.ColumnTypeTimestamp, handler.Nullable()),
 			handler.NewColumn(MilestoneColumnPushedDate, handler.ColumnTypeTimestamp, handler.Nullable()),
-			handler.NewColumn(MilestoneColumnPrimaryDomain, handler.ColumnTypeText, handler.Nullable()),
-			handler.NewColumn(MilestoneColumnIgnoreClientIDs, handler.ColumnTypeTextArray, handler.Nullable()),
 		},
 			handler.NewPrimaryKey(MilestoneColumnInstanceID, MilestoneColumnType),
 		),
@@ -55,183 +44,47 @@ func (*milestoneProjection) Init() *old_handler.Check {
 // Reducers implements handler.Projection.
 func (p *milestoneProjection) Reducers() []handler.AggregateReducer {
 	return []handler.AggregateReducer{
-		{
-			Aggregate: instance.AggregateType,
-			EventReducers: []handler.EventReducer{
-				{
-					Event:  instance.InstanceAddedEventType,
-					Reduce: p.reduceInstanceAdded,
-				},
-				{
-					Event:  instance.InstanceDomainPrimarySetEventType,
-					Reduce: p.reduceInstanceDomainPrimarySet,
-				},
-				{
-					Event:  instance.InstanceRemovedEventType,
-					Reduce: p.reduceInstanceRemoved,
-				},
-			},
-		},
-		{
-			Aggregate: project.AggregateType,
-			EventReducers: []handler.EventReducer{
-				{
-					Event:  project.ProjectAddedType,
-					Reduce: p.reduceProjectAdded,
-				},
-				{
-					Event:  project.ApplicationAddedType,
-					Reduce: p.reduceApplicationAdded,
-				},
-				{
-					Event:  project.OIDCConfigAddedType,
-					Reduce: p.reduceOIDCConfigAdded,
-				},
-				{
-					Event:  project.APIConfigAddedType,
-					Reduce: p.reduceAPIConfigAdded,
-				},
-			},
-		},
-		{
-			Aggregate: oidcsession.AggregateType,
-			EventReducers: []handler.EventReducer{
-				{
-					Event:  oidcsession.AddedType,
-					Reduce: p.reduceOIDCSessionAdded,
-				},
-			},
-		},
 		{
 			Aggregate: milestone.AggregateType,
 			EventReducers: []handler.EventReducer{
+				{
+					Event:  milestone.ReachedEventType,
+					Reduce: p.reduceReached,
+				},
 				{
 					Event:  milestone.PushedEventType,
-					Reduce: p.reduceMilestonePushed,
+					Reduce: p.reducePushed,
 				},
 			},
 		},
 	}
 }
 
-func (p *milestoneProjection) reduceInstanceAdded(event eventstore.Event) (*handler.Statement, error) {
-	e, err := assertEvent[*instance.InstanceAddedEvent](event)
+func (p *milestoneProjection) reduceReached(event eventstore.Event) (*handler.Statement, error) {
+	e, err := assertEvent[*milestone.ReachedEvent](event)
 	if err != nil {
 		return nil, err
 	}
-	allTypes := milestone.AllTypes()
-	statements := make([]func(eventstore.Event) handler.Exec, 0, len(allTypes))
-	for _, msType := range allTypes {
-		createColumns := []handler.Column{
-			handler.NewCol(MilestoneColumnInstanceID, e.Aggregate().InstanceID),
-			handler.NewCol(MilestoneColumnType, msType),
-		}
-		if msType == milestone.InstanceCreated {
-			createColumns = append(createColumns, handler.NewCol(MilestoneColumnReachedDate, event.CreatedAt()))
-		}
-		statements = append(statements, handler.AddCreateStatement(createColumns))
-	}
-	return handler.NewMultiStatement(e, statements...), nil
+	return handler.NewCreateStatement(event, []handler.Column{
+		handler.NewCol(MilestoneColumnInstanceID, e.Agg.InstanceID),
+		handler.NewCol(MilestoneColumnType, e.MilestoneType),
+		handler.NewCol(MilestoneColumnReachedDate, e.GetReachedDate()),
+	}), nil
 }
 
-func (p *milestoneProjection) reduceInstanceDomainPrimarySet(event eventstore.Event) (*handler.Statement, error) {
-	e, err := assertEvent[*instance.DomainPrimarySetEvent](event)
-	if err != nil {
-		return nil, err
-	}
-	return handler.NewUpdateStatement(
-		e,
-		[]handler.Column{
-			handler.NewCol(MilestoneColumnPrimaryDomain, e.Domain),
-		},
-		[]handler.Condition{
-			handler.NewCond(MilestoneColumnInstanceID, e.Aggregate().InstanceID),
-			handler.NewIsNullCond(MilestoneColumnPushedDate),
-		},
-	), nil
-}
-
-func (p *milestoneProjection) reduceProjectAdded(event eventstore.Event) (*handler.Statement, error) {
-	if _, err := assertEvent[*project.ProjectAddedEvent](event); err != nil {
-		return nil, err
-	}
-	return p.reduceReachedIfUserEventFunc(milestone.ProjectCreated)(event)
-}
-
-func (p *milestoneProjection) reduceApplicationAdded(event eventstore.Event) (*handler.Statement, error) {
-	if _, err := assertEvent[*project.ApplicationAddedEvent](event); err != nil {
-		return nil, err
-	}
-	return p.reduceReachedIfUserEventFunc(milestone.ApplicationCreated)(event)
-}
-
-func (p *milestoneProjection) reduceOIDCConfigAdded(event eventstore.Event) (*handler.Statement, error) {
-	e, err := assertEvent[*project.OIDCConfigAddedEvent](event)
-	if err != nil {
-		return nil, err
-	}
-	return p.reduceAppConfigAdded(e, e.ClientID)
-}
-
-func (p *milestoneProjection) reduceAPIConfigAdded(event eventstore.Event) (*handler.Statement, error) {
-	e, err := assertEvent[*project.APIConfigAddedEvent](event)
-	if err != nil {
-		return nil, err
-	}
-	return p.reduceAppConfigAdded(e, e.ClientID)
-}
-
-func (p *milestoneProjection) reduceOIDCSessionAdded(event eventstore.Event) (*handler.Statement, error) {
-	e, err := assertEvent[*oidcsession.AddedEvent](event)
-	if err != nil {
-		return nil, err
-	}
-	statements := []func(eventstore.Event) handler.Exec{
-		handler.AddUpdateStatement(
-			[]handler.Column{
-				handler.NewCol(MilestoneColumnReachedDate, event.CreatedAt()),
-			},
-			[]handler.Condition{
-				handler.NewCond(MilestoneColumnInstanceID, event.Aggregate().InstanceID),
-				handler.NewCond(MilestoneColumnType, milestone.AuthenticationSucceededOnInstance),
-				handler.NewIsNullCond(MilestoneColumnReachedDate),
-			},
-		),
-	}
-	// We ignore authentications without app, for example JWT profile or PAT
-	if e.ClientID != "" {
-		statements = append(statements, handler.AddUpdateStatement(
-			[]handler.Column{
-				handler.NewCol(MilestoneColumnReachedDate, event.CreatedAt()),
-			},
-			[]handler.Condition{
-				handler.NewCond(MilestoneColumnInstanceID, event.Aggregate().InstanceID),
-				handler.NewCond(MilestoneColumnType, milestone.AuthenticationSucceededOnApplication),
-				handler.Not(handler.NewTextArrayContainsCond(MilestoneColumnIgnoreClientIDs, e.ClientID)),
-				handler.NewIsNullCond(MilestoneColumnReachedDate),
-			},
-		))
-	}
-	return handler.NewMultiStatement(e, statements...), nil
-}
-
-func (p *milestoneProjection) reduceInstanceRemoved(event eventstore.Event) (*handler.Statement, error) {
-	if _, err := assertEvent[*instance.InstanceRemovedEvent](event); err != nil {
-		return nil, err
-	}
-	return p.reduceReachedFunc(milestone.InstanceDeleted)(event)
-}
-
-func (p *milestoneProjection) reduceMilestonePushed(event eventstore.Event) (*handler.Statement, error) {
+func (p *milestoneProjection) reducePushed(event eventstore.Event) (*handler.Statement, error) {
 	e, err := assertEvent[*milestone.PushedEvent](event)
 	if err != nil {
 		return nil, err
 	}
+	if e.Agg.Version != milestone.AggregateVersion {
+		return handler.NewNoOpStatement(event), nil // Skip v1 events.
+	}
 	if e.MilestoneType != milestone.InstanceDeleted {
 		return handler.NewUpdateStatement(
 			event,
 			[]handler.Column{
-				handler.NewCol(MilestoneColumnPushedDate, event.CreatedAt()),
+				handler.NewCol(MilestoneColumnPushedDate, e.GetPushedDate()),
 			},
 			[]handler.Condition{
 				handler.NewCond(MilestoneColumnInstanceID, event.Aggregate().InstanceID),
@@ -246,58 +99,3 @@ func (p *milestoneProjection) reduceMilestonePushed(event eventstore.Event) (*ha
 		},
 	), nil
 }
-
-func (p *milestoneProjection) reduceReachedIfUserEventFunc(msType milestone.Type) func(event eventstore.Event) (*handler.Statement, error) {
-	return func(event eventstore.Event) (*handler.Statement, error) {
-		if p.isSystemEvent(event) {
-			return handler.NewNoOpStatement(event), nil
-		}
-		return p.reduceReachedFunc(msType)(event)
-	}
-}
-
-func (p *milestoneProjection) reduceReachedFunc(msType milestone.Type) func(event eventstore.Event) (*handler.Statement, error) {
-	return func(event eventstore.Event) (*handler.Statement, error) {
-		return handler.NewUpdateStatement(event, []handler.Column{
-			handler.NewCol(MilestoneColumnReachedDate, event.CreatedAt()),
-		},
-			[]handler.Condition{
-				handler.NewCond(MilestoneColumnInstanceID, event.Aggregate().InstanceID),
-				handler.NewCond(MilestoneColumnType, msType),
-				handler.NewIsNullCond(MilestoneColumnReachedDate),
-			}), nil
-	}
-}
-
-func (p *milestoneProjection) reduceAppConfigAdded(event eventstore.Event, clientID string) (*handler.Statement, error) {
-	if !p.isSystemEvent(event) {
-		return handler.NewNoOpStatement(event), nil
-	}
-	return handler.NewUpdateStatement(
-		event,
-		[]handler.Column{
-			handler.NewArrayAppendCol(MilestoneColumnIgnoreClientIDs, clientID),
-		},
-		[]handler.Condition{
-			handler.NewCond(MilestoneColumnInstanceID, event.Aggregate().InstanceID),
-			handler.NewCond(MilestoneColumnType, milestone.AuthenticationSucceededOnApplication),
-			handler.NewIsNullCond(MilestoneColumnReachedDate),
-		},
-	), nil
-}
-
-func (p *milestoneProjection) isSystemEvent(event eventstore.Event) bool {
-	if userId, err := strconv.Atoi(event.Creator()); err == nil && userId > 0 {
-		return false
-	}
-
-	// check if it is a hard coded event creator
-	for _, creator := range []string{"", "system", "OIDC", "LOGIN", "SYSTEM"} {
-		if creator == event.Creator() {
-			return true
-		}
-	}
-
-	_, ok := p.systemUsers[event.Creator()]
-	return ok
-}