calculate and push 4 in 6 milestones

internal/query/milestone.go

@@ -0,0 +1,139 @@
+package query
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/zitadel/zitadel/internal/repository/milestone"
+
+	"github.com/zitadel/zitadel/internal/api/authz"
+
+	sq "github.com/Masterminds/squirrel"
+
+	"github.com/zitadel/zitadel/internal/api/call"
+	"github.com/zitadel/zitadel/internal/errors"
+	"github.com/zitadel/zitadel/internal/query/projection"
+	"github.com/zitadel/zitadel/internal/telemetry/tracing"
+)
+
+type Milestones struct {
+	SearchResponse
+	Milestones []*Milestone
+}
+
+type Milestone struct {
+	InstanceID    string
+	MilestoneType milestone.PushedEventType
+	ReachedDate   time.Time
+	PushedDate    time.Time
+	PrimaryDomain string
+}
+
+type MilestonesSearchQueries struct {
+	SearchRequest
+	Queries []SearchQuery
+}
+
+func (q *MilestonesSearchQueries) toQuery(query sq.SelectBuilder) sq.SelectBuilder {
+	query = q.SearchRequest.toQuery(query)
+	for _, q := range q.Queries {
+		query = q.toQuery(query)
+	}
+	return query
+}
+
+var (
+	milestonesTable = table{
+		name:          projection.MilestonesProjectionTable,
+		instanceIDCol: projection.MilestoneColumnInstanceID,
+	}
+	MilestoneInstanceIDColID = Column{
+		name:  projection.MilestoneColumnInstanceID,
+		table: milestonesTable,
+	}
+	MilestoneTypeColID = Column{
+		name:  projection.MilestoneColumnMilestoneType,
+		table: milestonesTable,
+	}
+	MilestonePrimaryDomainColID = Column{
+		name:  projection.MilestoneColumnPrimaryDomain,
+		table: milestonesTable,
+	}
+	MilestoneReachedDateColID = Column{
+		name:  projection.MilestoneColumnReachedDate,
+		table: milestonesTable,
+	}
+	MilestonePushedDateColID = Column{
+		name:  projection.MilestoneColumnPushedDate,
+		table: milestonesTable,
+	}
+)
+
+// SearchMilestones tries to defer the instanceID from the passed context if no instanceIDs are passed
+func (q *Queries) SearchMilestones(ctx context.Context, instanceIDs []string, queries *MilestonesSearchQueries) (_ *Milestones, err error) {
+	ctx, span := tracing.NewSpan(ctx)
+	defer func() { span.EndWithError(err) }()
+	query, scan := prepareMilestonesQuery(ctx, q.client)
+	if len(instanceIDs) == 0 {
+		instanceIDs = []string{authz.GetInstance(ctx).InstanceID()}
+	}
+	stmt, args, err := queries.toQuery(query).
+		Where(sq.Eq{
+			MilestoneInstanceIDColID.identifier(): fmt.Sprintf("IN (%s)", strings.Join(instanceIDs, ",")),
+		}).ToSql()
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "QUERY-A9i5k", "Errors.Query.SQLStatement")
+	}
+	rows, err := q.client.QueryContext(ctx, stmt, args...)
+	if err != nil {
+		return nil, err
+	}
+	milestones, err := scan(rows)
+	if err != nil {
+		return nil, err
+	}
+	milestones.LatestSequence, err = q.latestSequence(ctx, milestonesTable)
+	return milestones, err
+
+}
+
+func prepareMilestonesQuery(ctx context.Context, db prepareDatabase) (sq.SelectBuilder, func(*sql.Rows) (*Milestones, error)) {
+	return sq.Select(
+			MilestonePrimaryDomainColID.identifier(),
+			MilestoneReachedDateColID.identifier(),
+			MilestonePushedDateColID.identifier(),
+			MilestoneTypeColID.identifier(),
+			countColumn.identifier(),
+		).
+			From(notificationPolicyTable.identifier() + db.Timetravel(call.Took(ctx))).
+			PlaceholderFormat(sq.Dollar),
+		func(rows *sql.Rows) (*Milestones, error) {
+			milestones := make([]*Milestone, 0)
+			var count uint64
+			for rows.Next() {
+				m := new(Milestone)
+				err := rows.Scan(
+					&m.PrimaryDomain,
+					&m.ReachedDate,
+					&m.MilestoneType,
+					&count,
+				)
+				if err != nil {
+					return nil, err
+				}
+				milestones = append(milestones, m)
+			}
+			if err := rows.Close(); err != nil {
+				return nil, errors.ThrowInternal(err, "QUERY-CK9mI", "Errors.Query.CloseRows")
+			}
+			return &Milestones{
+				Milestones: milestones,
+				SearchResponse: SearchResponse{
+					Count: count,
+				},
+			}, nil
+		}
+}

internal/query/projection/milestones.go

@@ -6,9 +6,6 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"github.com/zitadel/zitadel/internal/repository/project"
-	"github.com/zitadel/zitadel/internal/repository/user"
-
 	"github.com/zitadel/zitadel/internal/repository/milestone"
 
 	"github.com/zitadel/zitadel/internal/errors"
@@ -16,6 +13,8 @@ import (
 	"github.com/zitadel/zitadel/internal/eventstore/handler"
 	"github.com/zitadel/zitadel/internal/eventstore/handler/crdb"
 	"github.com/zitadel/zitadel/internal/repository/instance"
+	"github.com/zitadel/zitadel/internal/repository/project"
+	"github.com/zitadel/zitadel/internal/repository/user"
 )
 
 const (
@@ -23,25 +22,25 @@ const (
 
 	MilestoneColumnInstanceID    = "instance_id"
 	MilestoneColumnMilestoneType = "milestone_type"
-	MilestoneColumnReachedAt     = "reached_at"
-	MilestoneColumnPushedAt      = "pushed_at"
 	MilestoneColumnPrimaryDomain = "primary_domain"
+	MilestoneColumnReachedDate   = "reached_date"
+	MilestoneColumnPushedDate    = "pushed_date"
 )
 
 type milestoneProjection struct {
 	crdb.StatementHandler
 }
 
-func newMilestoneInstanceProjection(ctx context.Context, config crdb.StatementHandlerConfig) *milestoneProjection {
+func newMilestoneProjection(ctx context.Context, config crdb.StatementHandlerConfig) *milestoneProjection {
 	p := new(milestoneProjection)
 	config.ProjectionName = MilestonesProjectionTable
 	config.Reducers = p.reducers()
 	config.InitCheck = crdb.NewMultiTableCheck(
 		crdb.NewTable([]*crdb.Column{
 			crdb.NewColumn(MilestoneColumnInstanceID, crdb.ColumnTypeText),
-			crdb.NewColumn(MilestoneColumnMilestoneType, crdb.ColumnTypeEnum),
-			crdb.NewColumn(MilestoneColumnReachedAt, crdb.ColumnTypeTimestamp, crdb.Nullable()),
-			crdb.NewColumn(MilestoneColumnPushedAt, crdb.ColumnTypeTimestamp, crdb.Nullable()),
+			crdb.NewColumn(MilestoneColumnMilestoneType, crdb.ColumnTypeText),
+			crdb.NewColumn(MilestoneColumnReachedDate, crdb.ColumnTypeTimestamp, crdb.Nullable()),
+			crdb.NewColumn(MilestoneColumnPushedDate, crdb.ColumnTypeTimestamp, crdb.Nullable()),
 			crdb.NewColumn(MilestoneColumnPrimaryDomain, crdb.ColumnTypeText, crdb.Nullable()),
 		},
 			crdb.NewPrimaryKey(MilestoneColumnInstanceID, MilestoneColumnMilestoneType),
@@ -66,7 +65,7 @@ func (p *milestoneProjection) reducers() []handler.AggregateReducer {
 				},
 				{
 					Event:  instance.InstanceRemovedEventType,
-					Reduce: p.reduceInstanceRemoved,
+					Reduce: p.milestoneReached(milestone.PushedInstanceDeletedEventType),
 				},
 			},
 		},
@@ -75,11 +74,11 @@ func (p *milestoneProjection) reducers() []handler.AggregateReducer {
 			EventRedusers: []handler.EventReducer{
 				{
 					Event:  project.ProjectAddedType,
-					Reduce: p.reduceProjectAdded,
+					Reduce: p.milestoneReached(milestone.PushedProjectCreatedEventType),
 				},
 				{
 					Event:  project.ApplicationAddedType,
-					Reduce: p.reduceApplicationAdded,
+					Reduce: p.milestoneReached(milestone.PushedApplicationCreatedEventType),
 				},
 			},
 		},
@@ -92,57 +91,72 @@ func (p *milestoneProjection) reducers() []handler.AggregateReducer {
 				},
 			},
 		},
-		{
-			Aggregate: milestone.AggregateType,
-			EventRedusers: []handler.EventReducer{
-				{
-					Event:  milestone.PushedEventType,
-					Reduce: p.milestonePushed,
-				},
-			},
-		},
 	}
 }
 
-func (p *milestoneProjection) reduceInstanceDomainPrimarySet(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*instance.DomainPrimarySetEvent)
-	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-Sfrgf", "reduce.wrong.event.type %s", instance.InstanceDomainPrimarySetEventType)
-	}
-
-	var statements []func(eventstore.Event) crdb.Exec
-	for _, ms := range milestone.All() {
-		statements = append(statements, crdb.AddUpsertStatement(
-			[]handler.Column{
-				handler.NewCol(MilestoneColumnInstanceID, nil),
-				handler.NewCol(MilestoneColumnMilestoneType, nil),
-			},
-			[]handler.Column{
-				handler.NewCol(MilestoneColumnInstanceID, e.Aggregate().InstanceID),
-				handler.NewCol(MilestoneColumnMilestoneType, ms),
-				handler.NewCol(MilestoneColumnPrimaryDomain, e.Domain),
-			},
-		))
-	}
-
-	return crdb.NewMultiStatement(e, statements...), nil
-}
-
 func (p *milestoneProjection) reduceInstanceAdded(event eventstore.Event) (*handler.Statement, error) {
 	printEvent(event)
-
-	return crdb.NewNoOpStatement(event), nil
+	e, ok := event.(*instance.InstanceAddedEvent)
+	if !ok {
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-JbHGS", "reduce.wrong.event.type %s", instance.InstanceAddedEventType)
+	}
+	allTypes := milestone.PushedEventTypes()
+	statements := make([]func(eventstore.Event) crdb.Exec, 0, len(allTypes))
+	for _, ms := range allTypes {
+		createColumns := []handler.Column{
+			handler.NewCol(MilestoneColumnInstanceID, e.Aggregate().InstanceID),
+			handler.NewCol(MilestoneColumnMilestoneType, ms),
+		}
+		if ms == milestone.PushedInstanceCreatedEventType {
+			createColumns = append(createColumns, handler.NewCol(MilestoneColumnReachedDate, event.CreationDate()))
+		}
+		statements = append(statements, crdb.AddCreateStatement(createColumns))
+	}
+	return crdb.NewMultiStatement(e, statements...), nil
 }
 
-func (p *milestoneProjection) reduceProjectAdded(event eventstore.Event) (*handler.Statement, error) {
+func (p *milestoneProjection) reduceInstanceDomainPrimarySet(event eventstore.Event) (*handler.Statement, error) {
 	printEvent(event)
-	// ignore instance.ProjectSetEventType
-	return crdb.NewNoOpStatement(event), nil
+	e, ok := event.(*instance.DomainPrimarySetEvent)
+	if !ok {
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-Sfrgf", "reduce.wrong.event.type %s", instance.InstanceDomainPrimarySetEventType)
+	}
+	allTypes := milestone.PushedEventTypes()
+	statements := make([]func(eventstore.Event) crdb.Exec, 0, len(allTypes))
+	for _, ms := range allTypes {
+		statements = append(statements, crdb.AddUpdateStatement(
+			[]handler.Column{
+				handler.NewCol(MilestoneColumnPrimaryDomain, e.Domain),
+			},
+			[]handler.Condition{
+				handler.NewCond(MilestoneColumnInstanceID, e.Aggregate().InstanceID),
+				handler.NewCond(MilestoneColumnMilestoneType, ms),
+				crdb.NewIsNullCond(MilestoneColumnPushedDate),
+			},
+		))
+	}
+	return crdb.NewMultiStatement(e, statements...), nil
 }
 
-func (p *milestoneProjection) reduceApplicationAdded(event eventstore.Event) (*handler.Statement, error) {
-	printEvent(event)
-	return crdb.NewNoOpStatement(event), nil
+func (p *milestoneProjection) milestoneReached(eventType milestone.PushedEventType) func(event eventstore.Event) (*handler.Statement, error) {
+	return func(event eventstore.Event) (*handler.Statement, error) {
+		printEvent(event)
+		if event.EditorUser() == "" || event.EditorService() == "" {
+			return crdb.NewNoOpStatement(event), nil
+		}
+		return crdb.NewUpdateStatement(
+			event,
+			[]handler.Column{
+				handler.NewCol(MilestoneColumnReachedDate, event.CreationDate()),
+			},
+			[]handler.Condition{
+				handler.NewCond(MilestoneColumnInstanceID, event.Aggregate().InstanceID),
+				handler.NewCond(MilestoneColumnMilestoneType, eventType),
+				crdb.NewIsNullCond(MilestoneColumnReachedDate),
+				crdb.NewIsNullCond(MilestoneColumnPushedDate),
+			},
+		), nil
+	}
 }
 
 func (p *milestoneProjection) reduceUserTokenAdded(event eventstore.Event) (*handler.Statement, error) {
@@ -155,11 +169,6 @@ func (p *milestoneProjection) reduceInstanceRemoved(event eventstore.Event) (*ha
 	return crdb.NewNoOpStatement(event), nil
 }
 
-func (p *milestoneProjection) milestonePushed(event eventstore.Event) (*handler.Statement, error) {
-	printEvent(event)
-	return crdb.NewNoOpStatement(event), nil
-}
-
 func printEvent(event eventstore.Event) {
 	var pretty bytes.Buffer
 	if err := json.Indent(&pretty, event.DataAsBytes(), "", "    "); err != nil {

internal/query/projection/projection.go

@@ -67,6 +67,7 @@ var (
 	TelemetryPusherProjection           interface{}
 	DeviceAuthProjection                *deviceAuthProjection
 	SessionProjection                   *sessionProjection
+	MilestoneProjection                 *milestoneProjection
 )
 
 type projection interface {
@@ -144,6 +145,7 @@ func Create(ctx context.Context, sqlClient *database.DB, es *eventstore.Eventsto
 	NotificationPolicyProjection = newNotificationPolicyProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["notification_policies"]))
 	DeviceAuthProjection = newDeviceAuthProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["device_auth"]))
 	SessionProjection = newSessionProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["sessions"]))
+	MilestoneProjection = newMilestoneProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["milestones"]))
 	newProjectionsList()
 	return nil
 }
@@ -241,5 +243,6 @@ func newProjectionsList() {
 		NotificationPolicyProjection,
 		DeviceAuthProjection,
 		SessionProjection,
+		MilestoneProjection,
 	}
 }

internal/query/search_query.go

@@ -66,6 +66,27 @@ func (q *NotNullQuery) comp() sq.Sqlizer {
 	return sq.NotEq{q.Column.identifier(): nil}
 }
 
+type IsNullQuery struct {
+	Column Column
+}
+
+func NewIsNullQuery(col Column) (*IsNullQuery, error) {
+	if col.isZero() {
+		return nil, ErrMissingColumn
+	}
+	return &IsNullQuery{
+		Column: col,
+	}, nil
+}
+
+func (q *IsNullQuery) toQuery(query sq.SelectBuilder) sq.SelectBuilder {
+	return query.Where(q.comp())
+}
+
+func (q *IsNullQuery) comp() sq.Sqlizer {
+	return sq.Eq{q.Column.identifier(): nil}
+}
+
 type orQuery struct {
 	queries []SearchQuery
 }

internal/query/user.go

@@ -338,6 +338,7 @@ func (q *Queries) GetUserByID(ctx context.Context, shouldTriggerBulk bool, userI
 	defer func() { span.EndWithError(err) }()
 
 	if shouldTriggerBulk {
+		// TODO: Why are these errors not handled?
 		projection.UserProjection.Trigger(ctx)
 		projection.LoginNameProjection.Trigger(ctx)
 	}