push milestones

internal/repository/milestone/aggregate.go

@@ -0,0 +1,27 @@
+package milestone
+
+import (
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+const (
+	AggregateType    = "milestone"
+	AggregateVersion = "v1"
+)
+
+type Aggregate struct {
+	eventstore.Aggregate
+}
+
+// Each data point receives its own aggregate
+func newAggregate(id, instanceId, resourceOwner string) *Aggregate {
+	return &Aggregate{
+		Aggregate: eventstore.Aggregate{
+			Type:          AggregateType,
+			Version:       AggregateVersion,
+			ID:            id,
+			InstanceID:    instanceId,
+			ResourceOwner: resourceOwner,
+		},
+	}
+}

internal/repository/milestone/events.go

@@ -0,0 +1,102 @@
+package milestone
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/zitadel/zitadel/internal/errors"
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/eventstore/repository"
+)
+
+const (
+	eventTypePrefix  = eventstore.EventType("milestone.")
+	ReachedEventType = eventTypePrefix + "reached"
+	PushedEventType  = eventTypePrefix + "pushed"
+)
+
+type ReachedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+	MilestoneEvent       SerializableEvent `json:"milestoneEvent"`
+}
+
+func (n *ReachedEvent) Data() interface{} {
+	return n
+}
+
+func (n *ReachedEvent) UniqueConstraints() []*eventstore.EventUniqueConstraint {
+	return nil
+}
+
+func NewReachedEvent(
+	ctx context.Context,
+	newAggregateID string,
+	milestoneEvent eventstore.BaseEvent,
+) *ReachedEvent {
+	triggeringEventsAggregate := milestoneEvent.Aggregate()
+	return &ReachedEvent{
+		BaseEvent: *eventstore.NewBaseEventForPush(
+			ctx,
+			&newAggregate(newAggregateID, triggeringEventsAggregate.InstanceID, triggeringEventsAggregate.ResourceOwner).Aggregate,
+			ReachedEventType,
+		),
+		MilestoneEvent: newSerializableEvent(milestoneEvent),
+	}
+}
+
+func ReachedEventMapper(event *repository.Event) (eventstore.Event, error) {
+	e := &ReachedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "QUOTA-k56rT", "unable to unmarshal milestone reached")
+	}
+
+	return e, nil
+}
+
+type PushedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+	ReachedEventSequence uint64   `json:"reachedEventSequence"`
+	Endpoints            []string `json:"endpoints"`
+}
+
+func (e *PushedEvent) Data() interface{} {
+	return e
+}
+
+func (e *PushedEvent) UniqueConstraints() []*eventstore.EventUniqueConstraint {
+	return nil
+}
+
+func NewPushedEvent(
+	ctx context.Context,
+	reachedEvent *ReachedEvent,
+	endpoints []string,
+) *PushedEvent {
+	aggregate := reachedEvent.Aggregate()
+	return &PushedEvent{
+		BaseEvent: *eventstore.NewBaseEventForPush(
+			ctx,
+			&aggregate,
+			PushedEventType,
+		),
+		ReachedEventSequence: reachedEvent.Sequence(),
+		Endpoints:            endpoints,
+	}
+}
+
+func PushedEventMapper(event *repository.Event) (eventstore.Event, error) {
+	e := &PushedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "QUOTA-4n8vs", "unable to unmarshal milestone pushed")
+	}
+
+	return e, nil
+}

internal/repository/milestone/eventstore.go

@@ -0,0 +1,10 @@
+package milestone
+
+import (
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+func RegisterEventMappers(es *eventstore.Eventstore) {
+	es.RegisterFilterEventMapper(AggregateType, ReachedEventType, ReachedEventMapper).
+		RegisterFilterEventMapper(AggregateType, PushedEventType, PushedEventMapper)
+}

internal/repository/milestone/serializable_event.go

@@ -0,0 +1,15 @@
+package milestone
+
+import "github.com/zitadel/zitadel/internal/eventstore"
+
+type SerializableEvent struct {
+	eventstore.BaseEvent `json:",inline"`
+	Data                 []byte `json:"data"`
+}
+
+func newSerializableEvent(triggeringEvent eventstore.BaseEvent) SerializableEvent {
+	return SerializableEvent{
+		BaseEvent: triggeringEvent,
+		Data:      triggeringEvent.DataAsBytes(),
+	}
+}