chore: move the go code into a subfolder

2025-08-12 17:37:32 +00:00 · 2025-08-05 15:20:32 -07:00
parent 4ad22ba456
commit cd2921de26
2978 changed files with 373 additions and 300 deletions
--- a/apps/api/internal/repository/feature/aggregate.go
+++ b/apps/api/internal/repository/feature/aggregate.go
@@ -0,0 +1,15 @@
+package feature
+
+import (
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+const (
+	eventTypePrefix = eventstore.EventType("feature.")
+	setSuffix       = ".set"
+)
+
+const (
+	AggregateType    = "feature"
+	AggregateVersion = "v1"
+)
--- a/apps/api/internal/repository/feature/eventstore.go
+++ b/apps/api/internal/repository/feature/eventstore.go
@@ -0,0 +1,9 @@
+package feature
+
+import (
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+func init() {
+	eventstore.RegisterFilterEventMapper(AggregateType, DefaultLoginInstanceEventType, eventstore.GenericEventMapper[SetEvent[Boolean]])
+}
--- a/apps/api/internal/repository/feature/feature.go
+++ b/apps/api/internal/repository/feature/feature.go
@@ -0,0 +1,79 @@
+// Package feature implements the v1 feature repository.
+// DEPRECATED: use ./feature_v2 instead.
+package feature
+
+import (
+	"context"
+	"strings"
+
+	"github.com/zitadel/zitadel/internal/domain"
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/repository/feature/feature_v2"
+)
+
+var (
+	DefaultLoginInstanceEventType = eventTypePrefix + eventstore.EventType(strings.ToLower("FeatureLoginDefaultOrg")) + setSuffix
+)
+
+// DefaultLoginInstanceEventToV2 upgrades the SetEvent to a V2 SetEvent so that
+// the v2 reducers can handle the V1 events.
+func DefaultLoginInstanceEventToV2(e *SetEvent[Boolean]) *feature_v2.SetEvent[bool] {
+	v2e := &feature_v2.SetEvent[bool]{
+		BaseEvent: e.BaseEvent,
+		Value:     e.Value.Boolean,
+	}
+
+	// v1 used a random aggregate ID.
+	// v2 uses the instance ID as aggregate ID.
+	v2e.BaseEvent.Agg.ID = e.Agg.InstanceID
+	v2e.BaseEvent.EventType = feature_v2.InstanceLoginDefaultOrgEventType
+	return v2e
+}
+
+type SetEvent[T SetEventType] struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	Value T
+}
+
+func (e *SetEvent[T]) SetBaseEvent(b *eventstore.BaseEvent) {
+	e.BaseEvent = b
+}
+
+func (e *SetEvent[T]) Payload() interface{} {
+	return e
+}
+
+func (e *SetEvent[T]) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+type SetEventType interface {
+	Boolean
+	FeatureType() domain.FeatureType
+}
+
+type EventType[T SetEventType] struct {
+	eventstore.EventType
+}
+
+type Boolean struct {
+	Boolean bool
+}
+
+func (b Boolean) FeatureType() domain.FeatureType {
+	return domain.FeatureTypeBoolean
+}
+
+func NewSetEvent[T SetEventType](
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+	eventType eventstore.EventType,
+	setType T,
+) *SetEvent[T] {
+	return &SetEvent[T]{
+		eventstore.NewBaseEventForPush(
+			ctx, aggregate, eventType),
+		setType,
+	}
+}
--- a/apps/api/internal/repository/feature/feature_v2/aggregate.go
+++ b/apps/api/internal/repository/feature/feature_v2/aggregate.go
@@ -0,0 +1,25 @@
+package feature_v2
+
+import (
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+const (
+	AggregateType    = "feature"
+	AggregateVersion = "v2"
+)
+
+type Aggregate struct {
+	eventstore.Aggregate
+}
+
+func NewAggregate(id, resourceOwner string) *Aggregate {
+	return &Aggregate{
+		Aggregate: eventstore.Aggregate{
+			Type:          AggregateType,
+			Version:       AggregateVersion,
+			ID:            id,
+			ResourceOwner: resourceOwner,
+		},
+	}
+}
--- a/apps/api/internal/repository/feature/feature_v2/eventstore.go
+++ b/apps/api/internal/repository/feature/feature_v2/eventstore.go
@@ -0,0 +1,32 @@
+package feature_v2
+
+import (
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/feature"
+)
+
+func init() {
+	eventstore.RegisterFilterEventMapper(AggregateType, SystemResetEventType, eventstore.GenericEventMapper[ResetEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, SystemLoginDefaultOrgEventType, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, SystemUserSchemaEventType, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, SystemTokenExchangeEventType, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, SystemImprovedPerformanceEventType, eventstore.GenericEventMapper[SetEvent[[]feature.ImprovedPerformanceType]])
+	eventstore.RegisterFilterEventMapper(AggregateType, SystemOIDCSingleV1SessionTerminationEventType, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, SystemDisableUserTokenEvent, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, SystemEnableBackChannelLogout, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, SystemLoginVersion, eventstore.GenericEventMapper[SetEvent[*feature.LoginV2]])
+	eventstore.RegisterFilterEventMapper(AggregateType, SystemPermissionCheckV2, eventstore.GenericEventMapper[SetEvent[bool]])
+
+	eventstore.RegisterFilterEventMapper(AggregateType, InstanceResetEventType, eventstore.GenericEventMapper[ResetEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, InstanceLoginDefaultOrgEventType, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, InstanceUserSchemaEventType, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, InstanceTokenExchangeEventType, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, InstanceImprovedPerformanceEventType, eventstore.GenericEventMapper[SetEvent[[]feature.ImprovedPerformanceType]])
+	eventstore.RegisterFilterEventMapper(AggregateType, InstanceDebugOIDCParentErrorEventType, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, InstanceOIDCSingleV1SessionTerminationEventType, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, InstanceDisableUserTokenEvent, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, InstanceEnableBackChannelLogout, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, InstanceLoginVersion, eventstore.GenericEventMapper[SetEvent[*feature.LoginV2]])
+	eventstore.RegisterFilterEventMapper(AggregateType, InstancePermissionCheckV2, eventstore.GenericEventMapper[SetEvent[bool]])
+	eventstore.RegisterFilterEventMapper(AggregateType, InstanceConsoleUseV2UserApi, eventstore.GenericEventMapper[SetEvent[bool]])
+}
--- a/apps/api/internal/repository/feature/feature_v2/feature.go
+++ b/apps/api/internal/repository/feature/feature_v2/feature.go
@@ -0,0 +1,146 @@
+package feature_v2
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/feature"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+var (
+	SystemResetEventType                          = resetEventTypeFromFeature(feature.LevelSystem)
+	SystemLoginDefaultOrgEventType                = setEventTypeFromFeature(feature.LevelSystem, feature.KeyLoginDefaultOrg)
+	SystemUserSchemaEventType                     = setEventTypeFromFeature(feature.LevelSystem, feature.KeyUserSchema)
+	SystemTokenExchangeEventType                  = setEventTypeFromFeature(feature.LevelSystem, feature.KeyTokenExchange)
+	SystemImprovedPerformanceEventType            = setEventTypeFromFeature(feature.LevelSystem, feature.KeyImprovedPerformance)
+	SystemOIDCSingleV1SessionTerminationEventType = setEventTypeFromFeature(feature.LevelSystem, feature.KeyOIDCSingleV1SessionTermination)
+	SystemDisableUserTokenEvent                   = setEventTypeFromFeature(feature.LevelSystem, feature.KeyDisableUserTokenEvent)
+	SystemEnableBackChannelLogout                 = setEventTypeFromFeature(feature.LevelSystem, feature.KeyEnableBackChannelLogout)
+	SystemLoginVersion                            = setEventTypeFromFeature(feature.LevelSystem, feature.KeyLoginV2)
+	SystemPermissionCheckV2                       = setEventTypeFromFeature(feature.LevelSystem, feature.KeyPermissionCheckV2)
+
+	InstanceResetEventType                          = resetEventTypeFromFeature(feature.LevelInstance)
+	InstanceLoginDefaultOrgEventType                = setEventTypeFromFeature(feature.LevelInstance, feature.KeyLoginDefaultOrg)
+	InstanceUserSchemaEventType                     = setEventTypeFromFeature(feature.LevelInstance, feature.KeyUserSchema)
+	InstanceTokenExchangeEventType                  = setEventTypeFromFeature(feature.LevelInstance, feature.KeyTokenExchange)
+	InstanceImprovedPerformanceEventType            = setEventTypeFromFeature(feature.LevelInstance, feature.KeyImprovedPerformance)
+	InstanceDebugOIDCParentErrorEventType           = setEventTypeFromFeature(feature.LevelInstance, feature.KeyDebugOIDCParentError)
+	InstanceOIDCSingleV1SessionTerminationEventType = setEventTypeFromFeature(feature.LevelInstance, feature.KeyOIDCSingleV1SessionTermination)
+	InstanceDisableUserTokenEvent                   = setEventTypeFromFeature(feature.LevelInstance, feature.KeyDisableUserTokenEvent)
+	InstanceEnableBackChannelLogout                 = setEventTypeFromFeature(feature.LevelInstance, feature.KeyEnableBackChannelLogout)
+	InstanceLoginVersion                            = setEventTypeFromFeature(feature.LevelInstance, feature.KeyLoginV2)
+	InstancePermissionCheckV2                       = setEventTypeFromFeature(feature.LevelInstance, feature.KeyPermissionCheckV2)
+	InstanceConsoleUseV2UserApi                     = setEventTypeFromFeature(feature.LevelInstance, feature.KeyConsoleUseV2UserApi)
+)
+
+const (
+	resetSuffix = "reset"
+	setSuffix   = "set"
+)
+
+func resetEventTypeFromFeature(level feature.Level) eventstore.EventType {
+	return eventstore.EventType(strings.Join([]string{AggregateType, level.String(), resetSuffix}, "."))
+}
+
+func setEventTypeFromFeature(level feature.Level, key feature.Key) eventstore.EventType {
+	return eventstore.EventType(strings.Join([]string{AggregateType, level.String(), key.String(), setSuffix}, "."))
+}
+
+type ResetEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+}
+
+func (e *ResetEvent) SetBaseEvent(b *eventstore.BaseEvent) {
+	e.BaseEvent = b
+}
+
+func (e *ResetEvent) Payload() interface{} {
+	return e
+}
+
+func (e *ResetEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewResetEvent(
+	ctx context.Context,
+	aggregate *Aggregate,
+	eventType eventstore.EventType,
+) *ResetEvent {
+	return &ResetEvent{
+		eventstore.NewBaseEventForPush(
+			ctx, &aggregate.Aggregate, eventType),
+	}
+}
+
+type SetEvent[T any] struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	Value T
+}
+
+func (e *SetEvent[T]) SetBaseEvent(b *eventstore.BaseEvent) {
+	e.BaseEvent = b
+}
+
+func (e *SetEvent[T]) Payload() interface{} {
+	return e
+}
+
+func (e *SetEvent[T]) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+type FeatureJSON struct {
+	Key   feature.Key
+	Value []byte
+}
+
+// FeatureJSON prepares converts the event to a key-value pair with a JSON value payload.
+func (e *SetEvent[T]) FeatureJSON() (*FeatureJSON, error) {
+	_, key, err := e.FeatureInfo()
+	if err != nil {
+		return nil, err
+	}
+	jsonValue, err := json.Marshal(e.Value)
+	if err != nil {
+		return nil, zerrors.ThrowInternalf(err, "FEAT-go9Ji", "reduce.wrong.event.type %s", e.EventType)
+	}
+	return &FeatureJSON{
+		Key:   key,
+		Value: jsonValue,
+	}, nil
+}
+
+// FeatureInfo extracts a feature's level and key from the event.
+func (e *SetEvent[T]) FeatureInfo() (feature.Level, feature.Key, error) {
+	ss := strings.Split(string(e.EventType), ".")
+	if len(ss) != 4 {
+		return 0, 0, zerrors.ThrowInternalf(nil, "FEAT-Ahs4m", "reduce.wrong.event.type %s", e.EventType)
+	}
+	level, err := feature.LevelString(ss[1])
+	if err != nil {
+		return 0, 0, zerrors.ThrowInternalf(err, "FEAT-Boo2i", "reduce.wrong.event.type %s", e.EventType)
+	}
+	key, err := feature.KeyString(ss[2])
+	if err != nil {
+		return 0, 0, zerrors.ThrowInternalf(err, "FEAT-eir0M", "reduce.wrong.event.type %s", e.EventType)
+	}
+	return level, key, nil
+}
+
+func NewSetEvent[T any](
+	ctx context.Context,
+	aggregate *Aggregate,
+	eventType eventstore.EventType,
+	value T,
+) *SetEvent[T] {
+	return &SetEvent[T]{
+		eventstore.NewBaseEventForPush(
+			ctx, &aggregate.Aggregate, eventType),
+		value,
+	}
+}
--- a/apps/api/internal/repository/feature/feature_v2/feature_test.go
+++ b/apps/api/internal/repository/feature/feature_v2/feature_test.go
@@ -0,0 +1,118 @@
+package feature_v2
+
+import (
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/feature"
+	"github.com/zitadel/zitadel/internal/zerrors"
+)
+
+func TestSetEvent_FeatureJSON(t *testing.T) {
+	tests := []struct {
+		name    string
+		e       *SetEvent[float64] // using float so it's easy to create marshal errors
+		want    *FeatureJSON
+		wantErr error
+	}{
+		{
+			name: "invalid key error",
+			e: &SetEvent[float64]{
+				BaseEvent: &eventstore.BaseEvent{
+					EventType: "feature.system.foo_bar.some_feat",
+				},
+			},
+			wantErr: zerrors.ThrowInternalf(nil, "FEAT-eir0M", "reduce.wrong.event.type %s", "feature.system.foo_bar.some_feat"),
+		},
+		{
+			name: "marshal error",
+			e: &SetEvent[float64]{
+				BaseEvent: &eventstore.BaseEvent{
+					EventType: SystemLoginDefaultOrgEventType,
+				},
+				Value: math.NaN(),
+			},
+			wantErr: zerrors.ThrowInternalf(nil, "FEAT-go9Ji", "reduce.wrong.event.type %s", SystemLoginDefaultOrgEventType),
+		},
+		{
+			name: "success",
+			e: &SetEvent[float64]{
+				BaseEvent: &eventstore.BaseEvent{
+					EventType: SystemLoginDefaultOrgEventType,
+				},
+				Value: 555,
+			},
+			want: &FeatureJSON{
+				Key:   feature.KeyLoginDefaultOrg,
+				Value: []byte(`555`),
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tt.e.FeatureJSON()
+			require.ErrorIs(t, err, tt.wantErr)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestSetEvent_FeatureInfo(t *testing.T) {
+	tests := []struct {
+		name    string
+		e       *SetEvent[bool]
+		want    feature.Level
+		want1   feature.Key
+		wantErr error
+	}{
+		{
+			name: "format error",
+			e: &SetEvent[bool]{
+				BaseEvent: &eventstore.BaseEvent{
+					EventType: "foo.bar",
+				},
+			},
+			wantErr: zerrors.ThrowInternalf(nil, "FEAT-Ahs4m", "reduce.wrong.event.type %s", "foo.bar"),
+		},
+		{
+			name: "level error",
+			e: &SetEvent[bool]{
+				BaseEvent: &eventstore.BaseEvent{
+					EventType: "feature.foo.bar.something",
+				},
+			},
+			wantErr: zerrors.ThrowInternalf(nil, "FEAT-Boo2i", "reduce.wrong.event.type %s", "feature.foo.bar.something"),
+		},
+		{
+			name: "key error",
+			e: &SetEvent[bool]{
+				BaseEvent: &eventstore.BaseEvent{
+					EventType: "feature.system.bar.something",
+				},
+			},
+			wantErr: zerrors.ThrowInternalf(nil, "FEAT-eir0M", "reduce.wrong.event.type %s", "feature.system.bar.something"),
+		},
+		{
+			name: "success",
+			e: &SetEvent[bool]{
+				BaseEvent: &eventstore.BaseEvent{
+					EventType: SystemLoginDefaultOrgEventType,
+				},
+			},
+			want:  feature.LevelSystem,
+			want1: feature.KeyLoginDefaultOrg,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, got1, err := tt.e.FeatureInfo()
+			require.ErrorIs(t, err, tt.wantErr)
+			assert.Equal(t, tt.want, got)
+			assert.Equal(t, tt.want1, got1)
+		})
+	}
+}