chore: move the go code into a subfolder

apps/api/internal/v2/readmodel/last_successful_mirror.go

@@ -0,0 +1,75 @@
+package readmodel
+
+import (
+	"github.com/shopspring/decimal"
+
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/v2/system"
+	"github.com/zitadel/zitadel/internal/v2/system/mirror"
+)
+
+type LastSuccessfulMirror struct {
+	ID       string
+	Position decimal.Decimal
+	source   string
+}
+
+func NewLastSuccessfulMirror(source string) *LastSuccessfulMirror {
+	return &LastSuccessfulMirror{
+		source: source,
+	}
+}
+
+var _ eventstore.Reducer = (*LastSuccessfulMirror)(nil)
+
+func (p *LastSuccessfulMirror) Filter() *eventstore.Filter {
+	return eventstore.NewFilter(
+		eventstore.AppendAggregateFilter(
+			system.AggregateType,
+			eventstore.AggregateOwnersEqual(system.AggregateOwner),
+			eventstore.AppendEvent(
+				eventstore.SetEventTypes(
+					mirror.SucceededType,
+				),
+				eventstore.EventCreatorsEqual(mirror.Creator),
+			),
+		),
+		eventstore.FilterPagination(
+			eventstore.Descending(),
+			eventstore.Limit(1),
+		),
+	)
+}
+
+// Reduce implements eventstore.Reducer.
+func (h *LastSuccessfulMirror) Reduce(events ...*eventstore.StorageEvent) (err error) {
+	for _, event := range events {
+		if event.Type == mirror.SucceededType {
+			err = h.reduceSucceeded(event)
+		}
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (h *LastSuccessfulMirror) reduceSucceeded(event *eventstore.StorageEvent) error {
+	// if position is set we skip all older events
+	if h.Position.GreaterThan(decimal.NewFromInt(0)) {
+		return nil
+
+	}
+	succeededEvent, err := mirror.SucceededEventFromStorage(event)
+	if err != nil {
+		return err
+	}
+
+	if h.source != succeededEvent.Payload.Source {
+		return nil
+	}
+
+	h.Position = succeededEvent.Payload.Position
+
+	return nil
+}

apps/api/internal/v2/readmodel/org.go

@@ -0,0 +1,70 @@
+package readmodel
+
+import (
+	"time"
+
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+	"github.com/zitadel/zitadel/internal/v2/org"
+	"github.com/zitadel/zitadel/internal/v2/projection"
+)
+
+type Org struct {
+	ID            string
+	Name          string
+	PrimaryDomain *projection.OrgPrimaryDomain
+	State         *projection.OrgState
+
+	Sequence     uint32
+	CreationDate time.Time
+	ChangeDate   time.Time
+	Owner        string
+	InstanceID   string
+}
+
+func NewOrg(id string) *Org {
+	return &Org{
+		ID:            id,
+		State:         projection.NewStateProjection(id),
+		PrimaryDomain: projection.NewOrgPrimaryDomain(id),
+	}
+}
+
+func (rm *Org) Filter() []*eventstore.Filter {
+	return []*eventstore.Filter{
+		// we don't need the filters of the projections as we filter all events of the read model
+		eventstore.NewFilter(
+			eventstore.AppendAggregateFilter(
+				org.AggregateType,
+				eventstore.SetAggregateID(rm.ID),
+			),
+		),
+	}
+}
+
+func (rm *Org) Reduce(events ...*eventstore.StorageEvent) error {
+	for _, event := range events {
+		switch event.Type {
+		case org.AddedType:
+			added, err := org.AddedEventFromStorage(event)
+			if err != nil {
+				return err
+			}
+			rm.Name = added.Payload.Name
+			rm.Owner = event.Aggregate.Owner
+			rm.CreationDate = event.CreatedAt
+		case org.ChangedType:
+			changed, err := org.ChangedEventFromStorage(event)
+			if err != nil {
+				return err
+			}
+			rm.Name = changed.Payload.Name
+		}
+		rm.Sequence = event.Sequence
+		rm.ChangeDate = event.CreatedAt
+		rm.InstanceID = event.Aggregate.Instance
+	}
+	if err := rm.State.Reduce(events...); err != nil {
+		return err
+	}
+	return rm.PrimaryDomain.Reduce(events...)
+}

apps/api/internal/v2/readmodel/query.go

@@ -0,0 +1,15 @@
+package readmodel
+
+import (
+	"database/sql"
+
+	"github.com/zitadel/zitadel/internal/v2/eventstore"
+)
+
+type QueryOpt func(opts []eventstore.QueryOpt) []eventstore.QueryOpt
+
+func WithTx(tx *sql.Tx) QueryOpt {
+	return func(opts []eventstore.QueryOpt) []eventstore.QueryOpt {
+		return append(opts, eventstore.SetQueryTx(tx))
+	}
+}