new pkg structure (#1150)

* fix: split command query side

* fix: split command query side

* fix: members in correct pkg structure

* fix: label policy in correct pkg structure

* fix: structure

* fix: structure of login policy

* fix: identityprovider structure

* fix: org iam policy structure

* fix: password age policy structure

* fix: password complexity policy structure

* fix: password lockout policy structure

* fix: idp structure

* fix: user events structure

* fix: user write model

* fix: profile email changed command

* fix: address changed command

* fix: user states

* fix: user

* fix: org structure and add human

* begin iam setup command side

* setup

* step2

* step2

* fix: add user

* step2

* isvalid

* fix: folder structure v2 business

Co-authored-by: Fabiennne <[email protected]>

internal/v2/repository/iam/aggregate.go

@@ -2,26 +2,12 @@ package iam
 
 import (
 	"context"
-	"github.com/caos/zitadel/internal/crypto"
 	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/label"
-	iam_login "github.com/caos/zitadel/internal/v2/repository/iam/policy/login"
-	factors2 "github.com/caos/zitadel/internal/v2/repository/iam/policy/login/factors"
-	iam_factors "github.com/caos/zitadel/internal/v2/repository/iam/policy/login/factors"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/login/idpprovider"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/org_iam"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/password_age"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/password_complexity"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/password_lockout"
-	"github.com/caos/zitadel/internal/v2/repository/idp"
-	"github.com/caos/zitadel/internal/v2/repository/idp/oidc"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login/factors"
-	idpprovider2 "github.com/caos/zitadel/internal/v2/repository/policy/login/idpprovider"
+	"github.com/caos/zitadel/internal/v2/domain"
 )
 
 const (
-	IamEventTypePrefix = eventstore.EventType("iam.")
+	iamEventTypePrefix = eventstore.EventType("iam.")
 )
 
 const (
@@ -50,252 +36,12 @@ func NewAggregate(
 	}
 }
 
-func AggregateFromWriteModel(wm *eventstore.WriteModel) *Aggregate {
-	return &Aggregate{
-		Aggregate: *eventstore.AggregateFromWriteModel(wm, AggregateType, AggregateVersion),
-	}
-}
-
-func AggregateFromReadModel(rm *ReadModel) *Aggregate {
-	return &Aggregate{
-		Aggregate: *eventstore.NewAggregate(
-			rm.AggregateID,
-			AggregateType,
-			rm.ResourceOwner,
-			AggregateVersion,
-			rm.ProcessedSequence,
-		),
-	}
-}
-
-func (a *Aggregate) PushMemberAdded(ctx context.Context, userID string, roles ...string) *Aggregate {
-	a.Aggregate = *a.PushEvents(NewMemberAddedEvent(ctx, userID, roles...))
-	return a
-}
-
-func (a *Aggregate) PushMemberChangedFromExisting(ctx context.Context, current *MemberWriteModel, roles ...string) *Aggregate {
-	e, err := MemberChangedEventFromExisting(ctx, current, roles...)
-	if err != nil {
-		return a
-	}
-	a.Aggregate = *a.PushEvents(e)
-	return a
-}
-
-func (a *Aggregate) PushMemberRemoved(ctx context.Context, userID string) *Aggregate {
-	a.Aggregate = *a.PushEvents(NewMemberRemovedEvent(ctx, userID))
-	return a
-}
-
-func (a *Aggregate) PushStepStarted(ctx context.Context, step Step) *Aggregate {
+func (a *Aggregate) PushStepStarted(ctx context.Context, step domain.Step) *Aggregate {
 	a.Aggregate = *a.PushEvents(NewSetupStepStartedEvent(ctx, step))
 	return a
 }
 
-func (a *Aggregate) PushStepDone(ctx context.Context, step Step) *Aggregate {
+func (a *Aggregate) PushStepDone(ctx context.Context, step domain.Step) *Aggregate {
 	a.Aggregate = *a.PushEvents(NewSetupStepDoneEvent(ctx, step))
 	return a
 }
-
-func (a *Aggregate) PushOrgIAMPolicyAddedEvent(ctx context.Context, userLoginMustBeDomain bool) *Aggregate {
-	a.Aggregate = *a.PushEvents(org_iam.NewAddedEvent(ctx, userLoginMustBeDomain))
-	return a
-}
-
-func (a *Aggregate) PushOrgIAMPolicyChangedFromExisting(ctx context.Context, current *org_iam.WriteModel, userLoginMustBeDomain bool) *Aggregate {
-	e, err := org_iam.ChangedEventFromExisting(ctx, current, userLoginMustBeDomain)
-	if err != nil {
-		return a
-	}
-	a.Aggregate = *a.PushEvents(e)
-	return a
-}
-
-func (a *Aggregate) PushPasswordAgePolicyAddedEvent(ctx context.Context, expireWarnDays, maxAgeDays uint64) *Aggregate {
-	a.Aggregate = *a.PushEvents(password_age.NewAddedEvent(ctx, expireWarnDays, maxAgeDays))
-	return a
-}
-
-func (a *Aggregate) PushPasswordAgePolicyChangedFromExisting(ctx context.Context, current *password_age.WriteModel, expireWarnDays, maxAgeDays uint64) *Aggregate {
-	e, err := password_age.ChangedEventFromExisting(ctx, current, expireWarnDays, maxAgeDays)
-	if err != nil {
-		return a
-	}
-	a.Aggregate = *a.PushEvents(e)
-	return a
-}
-
-func (a *Aggregate) PushPasswordComplexityPolicyAddedEvent(ctx context.Context, minLength uint64, hasLowercase, hasUppercase, hasNumber, hasSymbol bool) *Aggregate {
-	a.Aggregate = *a.PushEvents(password_complexity.NewAddedEvent(ctx, minLength, hasLowercase, hasUppercase, hasNumber, hasSymbol))
-	return a
-}
-
-func (a *Aggregate) PushPasswordComplexityPolicyChangedFromExisting(ctx context.Context, current *password_complexity.WriteModel, minLength uint64, hasLowercase, hasUppercase, hasNumber, hasSymbol bool) *Aggregate {
-	e, err := password_complexity.ChangedEventFromExisting(ctx, current, minLength, hasLowercase, hasUppercase, hasNumber, hasSymbol)
-	if err != nil {
-		return a
-	}
-	a.Aggregate = *a.PushEvents(e)
-	return a
-}
-
-func (a *Aggregate) PushPasswordLockoutPolicyAddedEvent(ctx context.Context, maxAttempts uint64, showLockoutFailure bool) *Aggregate {
-	a.Aggregate = *a.PushEvents(password_lockout.NewAddedEvent(ctx, maxAttempts, showLockoutFailure))
-	return a
-}
-
-func (a *Aggregate) PushPasswordLockoutPolicyChangedFromExisting(ctx context.Context, current *password_lockout.WriteModel, maxAttempts uint64, showLockoutFailure bool) *Aggregate {
-	e, err := password_lockout.ChangedEventFromExisting(ctx, current, maxAttempts, showLockoutFailure)
-	if err != nil {
-		return a
-	}
-	a.Aggregate = *a.PushEvents(e)
-	return a
-}
-
-func (a *Aggregate) PushLabelPolicyAddedEvent(ctx context.Context, primaryColor, secondaryColor string) *Aggregate {
-	a.Aggregate = *a.PushEvents(label.NewAddedEvent(ctx, primaryColor, secondaryColor))
-	return a
-}
-
-func (a *Aggregate) PushLabelPolicyChangedFromExisting(ctx context.Context, current *label.WriteModel, primaryColor, secondaryColor string) *Aggregate {
-	e, err := label.ChangedEventFromExisting(ctx, current, primaryColor, secondaryColor)
-	if err != nil {
-		return a
-	}
-	a.Aggregate = *a.PushEvents(e)
-	return a
-}
-
-func (a *Aggregate) PushLoginPolicyAddedEvent(ctx context.Context, allowUsernamePassword, allowRegister, allowExternalIDP, forceMFA bool, passwordlessType login.PasswordlessType) *Aggregate {
-	a.Aggregate = *a.PushEvents(iam_login.NewAddedEvent(ctx, allowUsernamePassword, allowRegister, allowExternalIDP, forceMFA, passwordlessType))
-	return a
-}
-
-func (a *Aggregate) PushLoginPolicyChangedFromExisting(ctx context.Context, current *iam_login.WriteModel, allowUsernamePassword, allowRegister, allowExternalIDP, forceMFA bool, passwordlessType login.PasswordlessType) *Aggregate {
-	e, err := iam_login.ChangedEventFromExisting(ctx, current, allowUsernamePassword, allowRegister, allowExternalIDP, forceMFA, passwordlessType)
-	if err != nil {
-		return a
-	}
-	a.Aggregate = *a.PushEvents(e)
-	return a
-}
-
-func (a *Aggregate) PushLoginPolicySecondFactorAdded(ctx context.Context, mfaType factors.SecondFactorType) *Aggregate {
-	a.Aggregate = *a.PushEvents(iam_factors.NewLoginPolicySecondFactorAddedEvent(ctx, mfaType))
-	return a
-}
-
-func (a *Aggregate) PushLoginPolicySecondFactorRemoved(ctx context.Context, mfaType factors.SecondFactorType) *Aggregate {
-	a.Aggregate = *a.PushEvents(iam_factors.NewLoginPolicySecondFactorRemovedEvent(ctx, mfaType))
-	return a
-}
-
-func (a *Aggregate) PushLoginPolicyMultiFactorAdded(ctx context.Context, mfaType factors.MultiFactorType) *Aggregate {
-	a.Aggregate = *a.PushEvents(factors2.NewLoginPolicyMultiFactorAddedEvent(ctx, mfaType))
-	return a
-}
-
-func (a *Aggregate) PushLoginPolicyMultiFactorRemoved(ctx context.Context, mfaType factors.MultiFactorType) *Aggregate {
-	a.Aggregate = *a.PushEvents(factors2.NewLoginPolicyMultiFactorRemovedEvent(ctx, mfaType))
-	return a
-}
-
-func (a *Aggregate) PushIDPConfigAdded(
-	ctx context.Context,
-	configID,
-	name string,
-	configType idp.ConfigType,
-	stylingType idp.StylingType,
-) *Aggregate {
-
-	a.Aggregate = *a.PushEvents(NewIDPConfigAddedEvent(ctx, configID, name, configType, stylingType))
-	return a
-}
-
-func (a *Aggregate) PushIDPConfigChanged(
-	ctx context.Context,
-	current *IDPConfigWriteModel,
-	configID,
-	name string,
-	configType idp.ConfigType,
-	stylingType idp.StylingType,
-) *Aggregate {
-
-	event, err := NewIDPConfigChangedEvent(ctx, current, configID, name, configType, stylingType)
-	if err != nil {
-		return a
-	}
-	a.Aggregate = *a.PushEvents(event)
-	return a
-}
-
-func (a *Aggregate) PushIDPConfigDeactivated(ctx context.Context, configID string) *Aggregate {
-	a.Aggregate = *a.PushEvents(NewIDPConfigDeactivatedEvent(ctx, configID))
-	return a
-}
-
-func (a *Aggregate) PushIDPConfigReactivated(ctx context.Context, configID string) *Aggregate {
-	a.Aggregate = *a.PushEvents(NewIDPConfigReactivatedEvent(ctx, configID))
-	return a
-}
-
-func (a *Aggregate) PushIDPConfigRemoved(ctx context.Context, configID string) *Aggregate {
-	a.Aggregate = *a.PushEvents(NewIDPConfigRemovedEvent(ctx, configID))
-	return a
-}
-
-func (a *Aggregate) PushIDPOIDCConfigAdded(
-	ctx context.Context,
-	clientID,
-	idpConfigID,
-	issuer string,
-	clientSecret *crypto.CryptoValue,
-	idpDisplayNameMapping,
-	userNameMapping oidc.MappingField,
-	scopes ...string,
-) *Aggregate {
-
-	a.Aggregate = *a.PushEvents(NewIDPOIDCConfigAddedEvent(ctx, clientID, idpConfigID, issuer, clientSecret, idpDisplayNameMapping, userNameMapping, scopes...))
-	return a
-}
-
-func (a *Aggregate) PushIDPOIDCConfigChanged(
-	ctx context.Context,
-	current *IDPOIDCConfigWriteModel,
-	clientID,
-	issuer string,
-	clientSecret *crypto.CryptoValue,
-	idpDisplayNameMapping,
-	userNameMapping oidc.MappingField,
-	scopes ...string,
-) *Aggregate {
-
-	event, err := NewIDPOIDCConfigChangedEvent(ctx, current, clientID, issuer, clientSecret, idpDisplayNameMapping, userNameMapping, scopes...)
-	if err != nil {
-		return a
-	}
-
-	a.Aggregate = *a.PushEvents(event)
-	return a
-}
-
-func (a *Aggregate) PushLoginPolicyIDPProviderAddedEvent(
-	ctx context.Context,
-	idpConfigID string,
-	providerType idpprovider2.Type,
-) *Aggregate {
-
-	a.Aggregate = *a.PushEvents(idpprovider.NewAddedEvent(ctx, idpConfigID, providerType))
-	return a
-}
-
-func (a *Aggregate) PushLoginPolicyIDPProviderRemovedEvent(
-	ctx context.Context,
-	idpConfigID string,
-	providerType idpprovider2.Type,
-) *Aggregate {
-
-	a.Aggregate = *a.PushEvents(idpprovider.NewRemovedEvent(ctx, idpConfigID))
-	return a
-}

internal/v2/repository/iam/events_step.go

@@ -7,6 +7,7 @@ import (
 	"github.com/caos/zitadel/internal/errors"
 	"github.com/caos/zitadel/internal/eventstore/v2"
 	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/domain"
 )
 
 const (
@@ -14,13 +15,11 @@ const (
 	SetupStartedEventType eventstore.EventType = "iam.setup.started"
 )
 
-type Step int8
-
 type SetupStepEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
-	Step Step `json:"Step"`
-	Done bool `json:"-"`
+	Step domain.Step `json:"Step"`
+	Done bool        `json:"-"`
 }
 
 func (e *SetupStepEvent) Data() interface{} {
@@ -42,7 +41,7 @@ func SetupStepMapper(event *repository.Event) (eventstore.EventReader, error) {
 
 func NewSetupStepDoneEvent(
 	ctx context.Context,
-	step Step,
+	step domain.Step,
 ) *SetupStepEvent {
 
 	return &SetupStepEvent{
@@ -56,7 +55,7 @@ func NewSetupStepDoneEvent(
 
 func NewSetupStepStartedEvent(
 	ctx context.Context,
-	step Step,
+	step domain.Step,
 ) *SetupStepEvent {
 
 	return &SetupStepEvent{

internal/v2/repository/iam/eventstore.go

@@ -2,12 +2,6 @@ package iam
 
 import (
 	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/label"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/login"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/org_iam"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/password_age"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/password_complexity"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/password_lockout"
 )
 
 func RegisterEventMappers(es *eventstore.Eventstore) {
@@ -15,17 +9,17 @@ func RegisterEventMappers(es *eventstore.Eventstore) {
 		RegisterFilterEventMapper(SetupDoneEventType, SetupStepMapper).
 		RegisterFilterEventMapper(GlobalOrgSetEventType, GlobalOrgSetMapper).
 		RegisterFilterEventMapper(ProjectSetEventType, ProjectSetMapper).
-		RegisterFilterEventMapper(label.LabelPolicyAddedEventType, label.AddedEventMapper).
-		RegisterFilterEventMapper(label.LabelPolicyChangedEventType, label.ChangedEventMapper).
-		RegisterFilterEventMapper(login.LoginPolicyAddedEventType, login.AddedEventMapper).
-		RegisterFilterEventMapper(login.LoginPolicyChangedEventType, login.ChangedEventMapper).
-		RegisterFilterEventMapper(org_iam.OrgIAMPolicyAddedEventType, org_iam.AddedEventMapper).
-		RegisterFilterEventMapper(password_age.PasswordAgePolicyAddedEventType, password_age.AddedEventMapper).
-		RegisterFilterEventMapper(password_age.PasswordAgePolicyChangedEventType, password_age.ChangedEventMapper).
-		RegisterFilterEventMapper(password_complexity.PasswordComplexityPolicyAddedEventType, password_complexity.AddedEventMapper).
-		RegisterFilterEventMapper(password_complexity.PasswordComplexityPolicyChangedEventType, password_complexity.ChangedEventMapper).
-		RegisterFilterEventMapper(password_lockout.PasswordLockoutPolicyAddedEventType, password_lockout.AddedEventMapper).
-		RegisterFilterEventMapper(password_lockout.PasswordLockoutPolicyChangedEventType, password_lockout.ChangedEventMapper).
+		RegisterFilterEventMapper(LabelPolicyAddedEventType, LabelPolicyAddedEventMapper).
+		RegisterFilterEventMapper(LabelPolicyChangedEventType, LabelPolicyChangedEventMapper).
+		RegisterFilterEventMapper(LoginPolicyAddedEventType, LoginPolicyAddedEventMapper).
+		RegisterFilterEventMapper(LoginPolicyChangedEventType, LoginPolicyChangedEventMapper).
+		RegisterFilterEventMapper(OrgIAMPolicyAddedEventType, OrgIAMPolicyAddedEventMapper).
+		RegisterFilterEventMapper(PasswordAgePolicyAddedEventType, PasswordAgePolicyAddedEventMapper).
+		RegisterFilterEventMapper(PasswordAgePolicyChangedEventType, PasswordAgePolicyChangedEventMapper).
+		RegisterFilterEventMapper(PasswordComplexityPolicyAddedEventType, PasswordComplexityPolicyAddedEventMapper).
+		RegisterFilterEventMapper(PasswordComplexityPolicyChangedEventType, PasswordComplexityPolicyChangedEventMapper).
+		RegisterFilterEventMapper(PasswordLockoutPolicyAddedEventType, PasswordLockoutPolicyAddedEventMapper).
+		RegisterFilterEventMapper(PasswordLockoutPolicyChangedEventType, PasswordLockoutPolicyChangedEventMapper).
 		RegisterFilterEventMapper(MemberAddedEventType, MemberAddedEventMapper).
 		RegisterFilterEventMapper(MemberChangedEventType, MemberChangedEventMapper).
 		RegisterFilterEventMapper(MemberRemovedEventType, MemberRemovedEventMapper).

internal/v2/repository/iam/idp_config.go

@@ -2,10 +2,10 @@ package iam
 
 import (
 	"context"
-
 	"github.com/caos/zitadel/internal/eventstore/v2"
 	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-	"github.com/caos/zitadel/internal/v2/repository/idp"
+	"github.com/caos/zitadel/internal/v2/domain"
+	"github.com/caos/zitadel/internal/v2/repository/idpconfig"
 )
 
 const (
@@ -16,138 +16,20 @@ const (
 	IDPConfigReactivatedEventType eventstore.EventType = "iam.idp.config.reactivated"
 )
 
-type IDPConfigReadModel struct {
-	idp.ConfigReadModel
-
-	iamID    string
-	configID string
-}
-
-func NewIDPConfigReadModel(iamID, configID string) *IDPConfigReadModel {
-	return &IDPConfigReadModel{
-		iamID:    iamID,
-		configID: configID,
-	}
-}
-
-func (rm *IDPConfigReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *IDPConfigAddedEvent:
-			rm.ConfigReadModel.AppendEvents(&e.ConfigAddedEvent)
-		case *IDPConfigChangedEvent:
-			rm.ConfigReadModel.AppendEvents(&e.ConfigChangedEvent)
-		case *IDPConfigDeactivatedEvent:
-			rm.ConfigReadModel.AppendEvents(&e.ConfigDeactivatedEvent)
-		case *IDPConfigReactivatedEvent:
-			rm.ConfigReadModel.AppendEvents(&e.ConfigReactivatedEvent)
-		case *IDPConfigRemovedEvent:
-			rm.ConfigReadModel.AppendEvents(&e.ConfigRemovedEvent)
-		case *IDPOIDCConfigAddedEvent:
-			rm.ConfigReadModel.AppendEvents(&e.ConfigAddedEvent)
-		case *IDPOIDCConfigChangedEvent:
-			rm.ConfigReadModel.AppendEvents(&e.ConfigChangedEvent)
-		}
-	}
-}
-
-func (rm *IDPConfigReadModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(rm.iamID).
-		EventData(map[string]interface{}{
-			"idpConfigId": rm.configID,
-		})
-}
-
-type IDPConfigWriteModel struct {
-	eventstore.WriteModel
-	idp.ConfigWriteModel
-
-	iamID    string
-	configID string
-}
-
-func NewIDPConfigWriteModel(iamID, configID string) *IDPConfigWriteModel {
-	return &IDPConfigWriteModel{
-		iamID:    iamID,
-		configID: configID,
-	}
-}
-
-func (wm *IDPConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(wm.iamID)
-}
-
-func (wm *IDPConfigWriteModel) AppendEvents(events ...eventstore.EventReader) {
-	wm.WriteModel.AppendEvents(events...)
-	for _, event := range events {
-		switch e := event.(type) {
-		case *IDPConfigAddedEvent:
-			if wm.configID != e.ConfigID {
-				continue
-			}
-			wm.ConfigWriteModel.AppendEvents(&e.ConfigAddedEvent)
-		case *IDPConfigChangedEvent:
-			if wm.configID != e.ConfigID {
-				continue
-			}
-			wm.ConfigWriteModel.AppendEvents(&e.ConfigChangedEvent)
-		case *IDPConfigDeactivatedEvent:
-			if wm.configID != e.ConfigID {
-				continue
-			}
-			wm.ConfigWriteModel.AppendEvents(&e.ConfigDeactivatedEvent)
-		case *IDPConfigReactivatedEvent:
-			if wm.configID != e.ConfigID {
-				continue
-			}
-			wm.ConfigWriteModel.AppendEvents(&e.ConfigReactivatedEvent)
-		case *IDPConfigRemovedEvent:
-			if wm.configID != e.ConfigID {
-				continue
-			}
-			wm.ConfigWriteModel.AppendEvents(&e.ConfigRemovedEvent)
-		case *IDPOIDCConfigAddedEvent:
-			if wm.configID != e.IDPConfigID {
-				continue
-			}
-			wm.ConfigWriteModel.AppendEvents(&e.ConfigAddedEvent)
-		case *IDPOIDCConfigChangedEvent:
-			if wm.configID != e.IDPConfigID {
-				continue
-			}
-			wm.ConfigWriteModel.AppendEvents(&e.ConfigChangedEvent)
-		}
-	}
-}
-
-func (wm *IDPConfigWriteModel) Reduce() error {
-	if err := wm.ConfigWriteModel.Reduce(); err != nil {
-		return err
-	}
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *IDPConfigWriteModel) AppendAndReduce(events ...eventstore.EventReader) error {
-	wm.AppendEvents(events...)
-	return wm.Reduce()
-}
-
 type IDPConfigAddedEvent struct {
-	idp.ConfigAddedEvent
+	idpconfig.IDPConfigAddedEvent
 }
 
 func NewIDPConfigAddedEvent(
 	ctx context.Context,
 	configID string,
 	name string,
-	configType idp.ConfigType,
-	stylingType idp.StylingType,
+	configType domain.IDPConfigType,
+	stylingType domain.IDPConfigStylingType,
 ) *IDPConfigAddedEvent {
 
 	return &IDPConfigAddedEvent{
-		ConfigAddedEvent: *idp.NewConfigAddedEvent(
+		IDPConfigAddedEvent: *idpconfig.NewIDPConfigAddedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				IDPConfigAddedEventType,
@@ -161,57 +43,39 @@ func NewIDPConfigAddedEvent(
 }
 
 func IDPConfigAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := idp.ConfigAddedEventMapper(event)
+	e, err := idpconfig.IDPConfigAddedEventMapper(event)
 	if err != nil {
 		return nil, err
 	}
 
-	return &IDPConfigAddedEvent{ConfigAddedEvent: *e.(*idp.ConfigAddedEvent)}, nil
+	return &IDPConfigAddedEvent{IDPConfigAddedEvent: *e.(*idpconfig.IDPConfigAddedEvent)}, nil
 }
 
 type IDPConfigChangedEvent struct {
-	idp.ConfigChangedEvent
+	idpconfig.IDPConfigChangedEvent
 }
 
 func NewIDPConfigChangedEvent(
 	ctx context.Context,
-	current *IDPConfigWriteModel,
-	configID string,
-	name string,
-	configType idp.ConfigType,
-	stylingType idp.StylingType,
-) (*IDPConfigChangedEvent, error) {
-
-	event, err := idp.NewConfigChangedEvent(
-		eventstore.NewBaseEventForPush(
-			ctx,
-			IDPConfigChangedEventType,
-		),
-		&current.ConfigWriteModel,
-		name,
-		stylingType,
-	)
-
-	if err != nil {
-		return nil, err
-	}
-
+) *IDPConfigChangedEvent {
 	return &IDPConfigChangedEvent{
-		ConfigChangedEvent: *event,
-	}, nil
+		IDPConfigChangedEvent: *idpconfig.NewIDPConfigChangedEvent(
+			eventstore.NewBaseEventForPush(ctx, IDPConfigChangedEventType),
+		),
+	}
 }
 
 func IDPConfigChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := idp.ConfigChangedEventMapper(event)
+	e, err := idpconfig.IDPConfigChangedEventMapper(event)
 	if err != nil {
 		return nil, err
 	}
 
-	return &IDPConfigChangedEvent{ConfigChangedEvent: *e.(*idp.ConfigChangedEvent)}, nil
+	return &IDPConfigChangedEvent{IDPConfigChangedEvent: *e.(*idpconfig.IDPConfigChangedEvent)}, nil
 }
 
 type IDPConfigRemovedEvent struct {
-	idp.ConfigRemovedEvent
+	idpconfig.IDPConfigRemovedEvent
 }
 
 func NewIDPConfigRemovedEvent(
@@ -220,7 +84,7 @@ func NewIDPConfigRemovedEvent(
 ) *IDPConfigRemovedEvent {
 
 	return &IDPConfigRemovedEvent{
-		ConfigRemovedEvent: *idp.NewConfigRemovedEvent(
+		IDPConfigRemovedEvent: *idpconfig.NewIDPConfigRemovedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				IDPConfigRemovedEventType,
@@ -231,16 +95,16 @@ func NewIDPConfigRemovedEvent(
 }
 
 func IDPConfigRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := idp.ConfigRemovedEventMapper(event)
+	e, err := idpconfig.IDPConfigRemovedEventMapper(event)
 	if err != nil {
 		return nil, err
 	}
 
-	return &IDPConfigRemovedEvent{ConfigRemovedEvent: *e.(*idp.ConfigRemovedEvent)}, nil
+	return &IDPConfigRemovedEvent{IDPConfigRemovedEvent: *e.(*idpconfig.IDPConfigRemovedEvent)}, nil
 }
 
 type IDPConfigDeactivatedEvent struct {
-	idp.ConfigDeactivatedEvent
+	idpconfig.IDPConfigDeactivatedEvent
 }
 
 func NewIDPConfigDeactivatedEvent(
@@ -249,7 +113,7 @@ func NewIDPConfigDeactivatedEvent(
 ) *IDPConfigDeactivatedEvent {
 
 	return &IDPConfigDeactivatedEvent{
-		ConfigDeactivatedEvent: *idp.NewConfigDeactivatedEvent(
+		IDPConfigDeactivatedEvent: *idpconfig.NewIDPConfigDeactivatedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				IDPConfigDeactivatedEventType,
@@ -260,16 +124,16 @@ func NewIDPConfigDeactivatedEvent(
 }
 
 func IDPConfigDeactivatedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := idp.ConfigDeactivatedEventMapper(event)
+	e, err := idpconfig.IDPConfigDeactivatedEventMapper(event)
 	if err != nil {
 		return nil, err
 	}
 
-	return &IDPConfigDeactivatedEvent{ConfigDeactivatedEvent: *e.(*idp.ConfigDeactivatedEvent)}, nil
+	return &IDPConfigDeactivatedEvent{IDPConfigDeactivatedEvent: *e.(*idpconfig.IDPConfigDeactivatedEvent)}, nil
 }
 
 type IDPConfigReactivatedEvent struct {
-	idp.ConfigReactivatedEvent
+	idpconfig.IDPConfigReactivatedEvent
 }
 
 func NewIDPConfigReactivatedEvent(
@@ -278,7 +142,7 @@ func NewIDPConfigReactivatedEvent(
 ) *IDPConfigReactivatedEvent {
 
 	return &IDPConfigReactivatedEvent{
-		ConfigReactivatedEvent: *idp.NewConfigReactivatedEvent(
+		IDPConfigReactivatedEvent: *idpconfig.NewIDPConfigReactivatedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				IDPConfigReactivatedEventType,
@@ -289,10 +153,10 @@ func NewIDPConfigReactivatedEvent(
 }
 
 func IDPConfigReactivatedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := idp.ConfigReactivatedEventMapper(event)
+	e, err := idpconfig.IDPConfigReactivatedEventMapper(event)
 	if err != nil {
 		return nil, err
 	}
 
-	return &IDPConfigReactivatedEvent{ConfigReactivatedEvent: *e.(*idp.ConfigReactivatedEvent)}, nil
+	return &IDPConfigReactivatedEvent{IDPConfigReactivatedEvent: *e.(*idpconfig.IDPConfigReactivatedEvent)}, nil
 }

internal/v2/repository/iam/idp_configs.go

@@ -1,31 +0,0 @@
-package iam
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/idp"
-)
-
-type IDPConfigsReadModel struct {
-	idp.ConfigsReadModel
-}
-
-func (rm *IDPConfigsReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *IDPConfigAddedEvent:
-			rm.ConfigsReadModel.AppendEvents(&e.ConfigAddedEvent)
-		case *IDPConfigChangedEvent:
-			rm.ConfigsReadModel.AppendEvents(&e.ConfigChangedEvent)
-		case *IDPConfigDeactivatedEvent:
-			rm.ConfigsReadModel.AppendEvents(&e.ConfigDeactivatedEvent)
-		case *IDPConfigReactivatedEvent:
-			rm.ConfigsReadModel.AppendEvents(&e.ConfigReactivatedEvent)
-		case *IDPConfigRemovedEvent:
-			rm.ConfigsReadModel.AppendEvents(&e.ConfigRemovedEvent)
-		case *IDPOIDCConfigAddedEvent:
-			rm.ConfigsReadModel.AppendEvents(&e.ConfigAddedEvent)
-		case *IDPOIDCConfigChangedEvent:
-			rm.ConfigsReadModel.AppendEvents(&e.ConfigChangedEvent)
-		}
-	}
-}

internal/v2/repository/iam/idp_oidc_config.go

@@ -2,67 +2,20 @@ package iam
 
 import (
 	"context"
-
 	"github.com/caos/zitadel/internal/crypto"
 	"github.com/caos/zitadel/internal/eventstore/v2"
 	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-	"github.com/caos/zitadel/internal/v2/repository/idp/oidc"
+	"github.com/caos/zitadel/internal/v2/domain"
+	"github.com/caos/zitadel/internal/v2/repository/idpconfig"
 )
 
 const (
-	IDPOIDCConfigAddedEventType   eventstore.EventType = "iam.idp." + oidc.ConfigAddedEventType
-	IDPOIDCConfigChangedEventType eventstore.EventType = "iam.idp." + oidc.ConfigChangedEventType
+	IDPOIDCConfigAddedEventType   eventstore.EventType = "iam.idp." + idpconfig.OIDCConfigAddedEventType
+	IDPOIDCConfigChangedEventType eventstore.EventType = "iam.idp." + idpconfig.ConfigChangedEventType
 )
 
-type IDPOIDCConfigWriteModel struct {
-	eventstore.WriteModel
-	oidc.ConfigWriteModel
-
-	iamID       string
-	idpConfigID string
-}
-
-func NewIDPOIDCConfigWriteModel(iamID, idpConfigID string) *IDPOIDCConfigWriteModel {
-	return &IDPOIDCConfigWriteModel{
-		iamID:       iamID,
-		idpConfigID: idpConfigID,
-	}
-}
-
-func (wm *IDPOIDCConfigWriteModel) AppendEvents(events ...eventstore.EventReader) {
-	wm.WriteModel.AppendEvents(events...)
-	for _, event := range events {
-		switch e := event.(type) {
-		case *IDPOIDCConfigAddedEvent:
-			if wm.idpConfigID != e.IDPConfigID {
-				continue
-			}
-			wm.ConfigWriteModel.AppendEvents(&e.ConfigAddedEvent)
-		case *IDPOIDCConfigChangedEvent:
-			if wm.idpConfigID != e.IDPConfigID {
-				continue
-			}
-			wm.ConfigWriteModel.AppendEvents(&e.ConfigChangedEvent)
-		default:
-			wm.ConfigWriteModel.AppendEvents(e)
-		}
-	}
-}
-
-func (wm *IDPOIDCConfigWriteModel) Reduce() error {
-	if err := wm.ConfigWriteModel.Reduce(); err != nil {
-		return err
-	}
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *IDPOIDCConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(wm.iamID)
-}
-
 type IDPOIDCConfigAddedEvent struct {
-	oidc.ConfigAddedEvent
+	idpconfig.OIDCConfigAddedEvent
 }
 
 func NewIDPOIDCConfigAddedEvent(
@@ -72,12 +25,12 @@ func NewIDPOIDCConfigAddedEvent(
 	issuer string,
 	clientSecret *crypto.CryptoValue,
 	idpDisplayNameMapping,
-	userNameMapping oidc.MappingField,
+	userNameMapping domain.OIDCMappingField,
 	scopes ...string,
 ) *IDPOIDCConfigAddedEvent {
 
 	return &IDPOIDCConfigAddedEvent{
-		ConfigAddedEvent: *oidc.NewConfigAddedEvent(
+		OIDCConfigAddedEvent: *idpconfig.NewOIDCConfigAddedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				IDPOIDCConfigAddedEventType,
@@ -94,57 +47,33 @@ func NewIDPOIDCConfigAddedEvent(
 }
 
 func IDPOIDCConfigAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := oidc.ConfigAddedEventMapper(event)
+	e, err := idpconfig.OIDCConfigAddedEventMapper(event)
 	if err != nil {
 		return nil, err
 	}
 
-	return &IDPOIDCConfigAddedEvent{ConfigAddedEvent: *e.(*oidc.ConfigAddedEvent)}, nil
+	return &IDPOIDCConfigAddedEvent{OIDCConfigAddedEvent: *e.(*idpconfig.OIDCConfigAddedEvent)}, nil
 }
 
 type IDPOIDCConfigChangedEvent struct {
-	oidc.ConfigChangedEvent
+	idpconfig.OIDCConfigChangedEvent
 }
 
 func NewIDPOIDCConfigChangedEvent(
 	ctx context.Context,
-	current *IDPOIDCConfigWriteModel,
-	clientID,
-	issuer string,
-	clientSecret *crypto.CryptoValue,
-	idpDisplayNameMapping,
-	userNameMapping oidc.MappingField,
-	scopes ...string,
-) (*IDPOIDCConfigChangedEvent, error) {
-
-	event, err := oidc.NewConfigChangedEvent(
-		eventstore.NewBaseEventForPush(
-			ctx,
-			IDPOIDCConfigChangedEventType,
-		),
-		&current.ConfigWriteModel,
-		clientID,
-		issuer,
-		clientSecret,
-		idpDisplayNameMapping,
-		userNameMapping,
-		scopes...,
-	)
-
-	if err != nil {
-		return nil, err
-	}
-
+) *IDPOIDCConfigChangedEvent {
 	return &IDPOIDCConfigChangedEvent{
-		ConfigChangedEvent: *event,
-	}, nil
+		OIDCConfigChangedEvent: *idpconfig.NewOIDCConfigChangedEvent(
+			eventstore.NewBaseEventForPush(ctx, IDPOIDCConfigChangedEventType),
+		),
+	}
 }
 
 func IDPOIDCConfigChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := oidc.ConfigChangedEventMapper(event)
+	e, err := idpconfig.OIDCConfigChangedEventMapper(event)
 	if err != nil {
 		return nil, err
 	}
 
-	return &IDPOIDCConfigChangedEvent{ConfigChangedEvent: *e.(*oidc.ConfigChangedEvent)}, nil
+	return &IDPOIDCConfigChangedEvent{OIDCConfigChangedEvent: *e.(*idpconfig.OIDCConfigChangedEvent)}, nil
 }

internal/v2/repository/iam/member.go

@@ -2,101 +2,19 @@ package iam
 
 import (
 	"context"
-
 	"github.com/caos/zitadel/internal/eventstore/v2"
 	"github.com/caos/zitadel/internal/eventstore/v2/repository"
 	"github.com/caos/zitadel/internal/v2/repository/member"
 )
 
 var (
-	MemberAddedEventType   = IamEventTypePrefix + member.AddedEventType
-	MemberChangedEventType = IamEventTypePrefix + member.ChangedEventType
-	MemberRemovedEventType = IamEventTypePrefix + member.RemovedEventType
+	MemberAddedEventType   = iamEventTypePrefix + member.AddedEventType
+	MemberChangedEventType = iamEventTypePrefix + member.ChangedEventType
+	MemberRemovedEventType = iamEventTypePrefix + member.RemovedEventType
 )
 
-type MemberReadModel struct {
-	member.ReadModel
-
-	userID string
-	iamID  string
-}
-
-func NewMemberReadModel(iamID, userID string) *MemberReadModel {
-	return &MemberReadModel{
-		iamID:  iamID,
-		userID: userID,
-	}
-}
-
-func (rm *MemberReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *MemberAddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *MemberChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *member.AddedEvent, *member.ChangedEvent, *MemberRemovedEvent:
-			rm.ReadModel.AppendEvents(e)
-		}
-	}
-}
-
-func (rm *MemberReadModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(rm.iamID).
-		EventData(map[string]interface{}{
-			"userId": rm.userID,
-		})
-}
-
-type MemberWriteModel struct {
-	member.WriteModel
-}
-
-func NewMemberWriteModel(iamID, userID string) *MemberWriteModel {
-	return &MemberWriteModel{
-		member.WriteModel{
-			WriteModel: eventstore.WriteModel{
-				AggregateID: iamID,
-			},
-			UserID: userID,
-		},
-	}
-}
-
-func (wm *MemberWriteModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *MemberAddedEvent:
-			if e.UserID != wm.WriteModel.UserID {
-				continue
-			}
-			wm.WriteModel.AppendEvents(&e.AddedEvent)
-		case *MemberChangedEvent:
-			if e.UserID != wm.WriteModel.UserID {
-				continue
-			}
-			wm.WriteModel.AppendEvents(&e.ChangedEvent)
-		case *MemberRemovedEvent:
-			if e.UserID != wm.WriteModel.UserID {
-				continue
-			}
-			wm.WriteModel.AppendEvents(&e.RemovedEvent)
-		}
-	}
-}
-
-func (wm *MemberWriteModel) Reduce() error {
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *MemberWriteModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(wm.WriteModel.AggregateID)
-}
-
 type MemberAddedEvent struct {
-	member.AddedEvent
+	member.MemberAddedEvent
 }
 
 func NewMemberAddedEvent(
@@ -106,7 +24,7 @@ func NewMemberAddedEvent(
 ) *MemberAddedEvent {
 
 	return &MemberAddedEvent{
-		AddedEvent: *member.NewAddedEvent(
+		MemberAddedEvent: *member.NewMemberAddedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				MemberAddedEventType,
@@ -118,39 +36,33 @@ func NewMemberAddedEvent(
 }
 
 func MemberAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := member.AddedEventMapper(event)
+	e, err := member.MemberAddedEventMapper(event)
 	if err != nil {
 		return nil, err
 	}
 
-	return &MemberAddedEvent{AddedEvent: *e.(*member.AddedEvent)}, nil
+	return &MemberAddedEvent{MemberAddedEvent: *e.(*member.MemberAddedEvent)}, nil
 }
 
 type MemberChangedEvent struct {
-	member.ChangedEvent
+	member.MemberChangedEvent
 }
 
-func MemberChangedEventFromExisting(
+func NewMemberChangedEvent(
 	ctx context.Context,
-	current *MemberWriteModel,
+	userID string,
 	roles ...string,
-) (*MemberChangedEvent, error) {
-
-	event, err := member.ChangeEventFromExisting(
-		eventstore.NewBaseEventForPush(
-			ctx,
-			MemberChangedEventType,
-		),
-		&current.WriteModel,
-		roles...,
-	)
-	if err != nil {
-		return nil, err
-	}
-
+) *MemberChangedEvent {
 	return &MemberChangedEvent{
-		ChangedEvent: *event,
-	}, nil
+		MemberChangedEvent: *member.NewMemberChangedEvent(
+			eventstore.NewBaseEventForPush(
+				ctx,
+				MemberChangedEventType,
+			),
+			userID,
+			roles...,
+		),
+	}
 }
 
 func MemberChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
@@ -159,11 +71,11 @@ func MemberChangedEventMapper(event *repository.Event) (eventstore.EventReader,
 		return nil, err
 	}
 
-	return &MemberChangedEvent{ChangedEvent: *e.(*member.ChangedEvent)}, nil
+	return &MemberChangedEvent{MemberChangedEvent: *e.(*member.MemberChangedEvent)}, nil
 }
 
 type MemberRemovedEvent struct {
-	member.RemovedEvent
+	member.MemberRemovedEvent
 }
 
 func NewMemberRemovedEvent(
@@ -172,7 +84,7 @@ func NewMemberRemovedEvent(
 ) *MemberRemovedEvent {
 
 	return &MemberRemovedEvent{
-		RemovedEvent: *member.NewRemovedEvent(
+		MemberRemovedEvent: *member.NewRemovedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				MemberRemovedEventType,
@@ -188,5 +100,5 @@ func MemberRemovedEventMapper(event *repository.Event) (eventstore.EventReader,
 		return nil, err
 	}
 
-	return &MemberRemovedEvent{RemovedEvent: *e.(*member.RemovedEvent)}, nil
+	return &MemberRemovedEvent{MemberRemovedEvent: *e.(*member.MemberRemovedEvent)}, nil
 }

internal/v2/repository/iam/members.go

@@ -1,23 +0,0 @@
-package iam
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/members"
-)
-
-type MembersReadModel struct {
-	members.ReadModel
-}
-
-func (rm *MembersReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *MemberAddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *MemberChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *MemberRemovedEvent:
-			rm.ReadModel.AppendEvents(&e.RemovedEvent)
-		}
-	}
-}

internal/v2/repository/iam/policy/label/events.go

@@ -1,73 +0,0 @@
-package label
-
-import (
-	"context"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-	"github.com/caos/zitadel/internal/v2/repository/policy/label"
-)
-
-var (
-	iamEventPrefix              = eventstore.EventType("iam.")
-	LabelPolicyAddedEventType   = iamEventPrefix + label.LabelPolicyAddedEventType
-	LabelPolicyChangedEventType = iamEventPrefix + label.LabelPolicyChangedEventType
-)
-
-type AddedEvent struct {
-	label.AddedEvent
-}
-
-func NewAddedEvent(
-	ctx context.Context,
-	primaryColor,
-	secondaryColor string,
-) *AddedEvent {
-	return &AddedEvent{
-		AddedEvent: *label.NewAddedEvent(
-			eventstore.NewBaseEventForPush(ctx, LabelPolicyAddedEventType),
-			primaryColor,
-			secondaryColor),
-	}
-}
-
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := label.AddedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &AddedEvent{AddedEvent: *e.(*label.AddedEvent)}, nil
-}
-
-type ChangedEvent struct {
-	label.ChangedEvent
-}
-
-func ChangedEventFromExisting(
-	ctx context.Context,
-	current *WriteModel,
-	primaryColor,
-	secondaryColor string,
-) (*ChangedEvent, error) {
-	event := label.NewChangedEvent(
-		eventstore.NewBaseEventForPush(
-			ctx,
-			LabelPolicyChangedEventType,
-		),
-		&current.WriteModel,
-		primaryColor,
-		secondaryColor,
-	)
-	return &ChangedEvent{
-		*event,
-	}, nil
-}
-
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := label.ChangedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ChangedEvent{ChangedEvent: *e.(*label.ChangedEvent)}, nil
-}

internal/v2/repository/iam/policy/label/read_model.go

@@ -1,21 +0,0 @@
-package label
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/label"
-)
-
-type ReadModel struct{ label.ReadModel }
-
-func (rm *ReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *ChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *label.AddedEvent, *label.ChangedEvent:
-			rm.ReadModel.AppendEvents(e)
-		}
-	}
-}

internal/v2/repository/iam/policy/label/write_model.go

@@ -1,44 +0,0 @@
-package label
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/label"
-)
-
-const (
-	AggregateType = "iam"
-)
-
-type WriteModel struct {
-	label.WriteModel
-}
-
-func NewWriteModel(iamID string) *WriteModel {
-	return &WriteModel{
-		label.WriteModel{
-			WriteModel: eventstore.WriteModel{
-				AggregateID: iamID,
-			},
-		},
-	}
-}
-
-func (wm *WriteModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.WriteModel.AppendEvents(&e.AddedEvent)
-		case *ChangedEvent:
-			wm.WriteModel.AppendEvents(&e.ChangedEvent)
-		}
-	}
-}
-
-func (wm *WriteModel) Reduce() error {
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *WriteModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(wm.WriteModel.AggregateID)
-}

internal/v2/repository/iam/policy/login/events.go

@@ -1,89 +0,0 @@
-package login
-
-import (
-	"context"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login"
-)
-
-var (
-	iamEventPrefix              = eventstore.EventType("iam.")
-	LoginPolicyAddedEventType   = iamEventPrefix + login.LoginPolicyAddedEventType
-	LoginPolicyChangedEventType = iamEventPrefix + login.LoginPolicyChangedEventType
-
-	LoginPolicyIDPProviderAddedEventType   = iamEventPrefix + login.LoginPolicyIDPProviderAddedEventType
-	LoginPolicyIDPProviderRemovedEventType = iamEventPrefix + login.LoginPolicyIDPProviderRemovedEventType
-)
-
-type AddedEvent struct {
-	login.AddedEvent
-}
-
-func NewAddedEvent(
-	ctx context.Context,
-	allowUsernamePassword,
-	allowRegister,
-	allowExternalIDP,
-	forceMFA bool,
-	passwordlessType login.PasswordlessType,
-) *AddedEvent {
-	return &AddedEvent{
-		AddedEvent: *login.NewAddedEvent(
-			eventstore.NewBaseEventForPush(ctx, login.LoginPolicyAddedEventType),
-			allowUsernamePassword,
-			allowRegister,
-			allowExternalIDP,
-			forceMFA,
-			passwordlessType),
-	}
-}
-
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := login.AddedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &AddedEvent{AddedEvent: *e.(*login.AddedEvent)}, nil
-}
-
-type ChangedEvent struct {
-	login.ChangedEvent
-}
-
-func ChangedEventFromExisting(
-	ctx context.Context,
-	current *WriteModel,
-	allowUsernamePassword,
-	allowRegister,
-	allowExternalIDP,
-	forceMFA bool,
-	passwordlessType login.PasswordlessType,
-) (*ChangedEvent, error) {
-
-	event := login.NewChangedEvent(
-		eventstore.NewBaseEventForPush(
-			ctx,
-			LoginPolicyChangedEventType,
-		),
-		&current.WriteModel,
-		allowUsernamePassword,
-		allowRegister,
-		allowExternalIDP,
-		forceMFA,
-		passwordlessType,
-	)
-	return &ChangedEvent{
-		*event,
-	}, nil
-}
-
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := login.ChangedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ChangedEvent{ChangedEvent: *e.(*login.ChangedEvent)}, nil
-}

internal/v2/repository/iam/policy/login/factors/write_model.go

@@ -1,74 +0,0 @@
-package factors
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login/factors"
-)
-
-const (
-	AggregateType = "iam"
-)
-
-type SecondFactorWriteModel struct {
-	factors.SecondFactorWriteModel
-}
-
-func NewSecondFactorWriteModel(iamID string) *SecondFactorWriteModel {
-	return &SecondFactorWriteModel{
-		factors.SecondFactorWriteModel{
-			WriteModel: eventstore.WriteModel{
-				AggregateID: iamID,
-			},
-		},
-	}
-}
-
-func (wm *SecondFactorWriteModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *LoginPolicySecondFactorAddedEvent:
-			wm.WriteModel.AppendEvents(&e.SecondFactorAddedEvent)
-		}
-	}
-}
-
-func (wm *SecondFactorWriteModel) Reduce() error {
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *SecondFactorWriteModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(wm.WriteModel.AggregateID)
-}
-
-type MultiFactorWriteModel struct {
-	factors.MultiFactoryWriteModel
-}
-
-func NewMultiFactorWriteModel(iamID string) *MultiFactorWriteModel {
-	return &MultiFactorWriteModel{
-		factors.MultiFactoryWriteModel{
-			WriteModel: eventstore.WriteModel{
-				AggregateID: iamID,
-			},
-		},
-	}
-}
-
-func (wm *MultiFactorWriteModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *LoginPolicyMultiFactorAddedEvent:
-			wm.WriteModel.AppendEvents(&e.MultiFactorAddedEvent)
-		}
-	}
-}
-
-func (wm *MultiFactorWriteModel) Reduce() error {
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *MultiFactorWriteModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(wm.WriteModel.AggregateID)
-}

internal/v2/repository/iam/policy/login/idpprovider/events.go

@@ -1,65 +0,0 @@
-package idpprovider
-
-import (
-	"context"
-	"github.com/caos/zitadel/internal/v2/repository/iam/policy/login"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login/idpprovider"
-
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-type AddedEvent struct {
-	idpprovider.AddedEvent
-}
-
-func NewAddedEvent(
-	ctx context.Context,
-	idpConfigID string,
-	idpProviderType idpprovider.Type,
-) *AddedEvent {
-
-	return &AddedEvent{
-		AddedEvent: *idpprovider.NewAddedEvent(
-			eventstore.NewBaseEventForPush(ctx, login.LoginPolicyIDPProviderAddedEventType),
-			idpConfigID,
-			idpProviderType),
-	}
-}
-
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := idpprovider.AddedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &AddedEvent{
-		AddedEvent: *e.(*idpprovider.AddedEvent),
-	}, nil
-}
-
-type RemovedEvent struct {
-	idpprovider.RemovedEvent
-}
-
-func NewRemovedEvent(
-	ctx context.Context,
-	idpConfigID string,
-) *RemovedEvent {
-	return &RemovedEvent{
-		RemovedEvent: *idpprovider.NewRemovedEvent(
-			eventstore.NewBaseEventForPush(ctx, login.LoginPolicyIDPProviderRemovedEventType),
-			idpConfigID),
-	}
-}
-
-func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := idpprovider.RemovedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &RemovedEvent{
-		RemovedEvent: *e.(*idpprovider.RemovedEvent),
-	}, nil
-}

internal/v2/repository/iam/policy/login/idpprovider/write_model.go

@@ -1,48 +0,0 @@
-package idpprovider
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login/idpprovider"
-)
-
-const (
-	AggregateType = "iam"
-)
-
-type WriteModel struct {
-	idpprovider.WriteModel
-	IsRemoved bool
-}
-
-func NewWriteModel(iamID, idpConfigID string) *WriteModel {
-	return &WriteModel{
-		WriteModel: idpprovider.WriteModel{
-			WriteModel: eventstore.WriteModel{
-				AggregateID: iamID,
-			},
-			IDPConfigID: idpConfigID,
-		},
-		IsRemoved: false,
-	}
-}
-
-func (wm *WriteModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			if e.IDPConfigID != wm.IDPConfigID {
-				continue
-			}
-			wm.WriteModel.AppendEvents(&e.AddedEvent)
-		}
-	}
-}
-
-func (wm *WriteModel) Reduce() error {
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *WriteModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(wm.AggregateID)
-}

internal/v2/repository/iam/policy/login/read_model.go

@@ -1,21 +0,0 @@
-package login
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login"
-)
-
-type ReadModel struct{ login.ReadModel }
-
-func (rm *ReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *ChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *login.AddedEvent, *login.ChangedEvent:
-			rm.ReadModel.AppendEvents(e)
-		}
-	}
-}

internal/v2/repository/iam/policy/login/write_model.go

@@ -1,44 +0,0 @@
-package login
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login"
-)
-
-const (
-	AggregateType = "iam"
-)
-
-type WriteModel struct {
-	login.WriteModel
-}
-
-func NewWriteModel(iamID string) *WriteModel {
-	return &WriteModel{
-		login.WriteModel{
-			WriteModel: eventstore.WriteModel{
-				AggregateID: iamID,
-			},
-		},
-	}
-}
-
-func (wm *WriteModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.WriteModel.AppendEvents(&e.AddedEvent)
-		case *ChangedEvent:
-			wm.WriteModel.AppendEvents(&e.ChangedEvent)
-		}
-	}
-}
-
-func (wm *WriteModel) Reduce() error {
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *WriteModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(wm.WriteModel.AggregateID)
-}

internal/v2/repository/iam/policy/org_iam/events.go

@@ -1,70 +0,0 @@
-package org_iam
-
-import (
-	"context"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-	"github.com/caos/zitadel/internal/v2/repository/policy/org_iam"
-)
-
-var (
-	iamEventPrefix               = eventstore.EventType("iam.")
-	OrgIAMPolicyAddedEventType   = iamEventPrefix + org_iam.OrgIAMPolicyAddedEventType
-	OrgIAMPolicyChangedEventType = iamEventPrefix + org_iam.OrgIAMPolicyChangedEventType
-)
-
-type AddedEvent struct {
-	org_iam.AddedEvent
-}
-
-func NewAddedEvent(
-	ctx context.Context,
-	userLoginMustBeDomain bool,
-) *AddedEvent {
-	return &AddedEvent{
-		AddedEvent: *org_iam.NewAddedEvent(
-			eventstore.NewBaseEventForPush(ctx, OrgIAMPolicyAddedEventType),
-			userLoginMustBeDomain,
-		),
-	}
-}
-
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := org_iam.AddedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &AddedEvent{AddedEvent: *e.(*org_iam.AddedEvent)}, nil
-}
-
-type ChangedEvent struct {
-	org_iam.ChangedEvent
-}
-
-func ChangedEventFromExisting(
-	ctx context.Context,
-	current *WriteModel,
-	userLoginMustBeDomain bool,
-) (*ChangedEvent, error) {
-	event := org_iam.NewChangedEvent(
-		eventstore.NewBaseEventForPush(
-			ctx,
-			OrgIAMPolicyChangedEventType,
-		),
-		&current.WriteModel,
-		userLoginMustBeDomain,
-	)
-	return &ChangedEvent{
-		*event,
-	}, nil
-}
-
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := org_iam.ChangedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ChangedEvent{ChangedEvent: *e.(*org_iam.ChangedEvent)}, nil
-}

internal/v2/repository/iam/policy/org_iam/read_model.go

@@ -1,19 +0,0 @@
-package org_iam
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/org_iam"
-)
-
-type ReadModel struct{ org_iam.ReadModel }
-
-func (rm *ReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *org_iam.AddedEvent:
-			rm.ReadModel.AppendEvents(e)
-		}
-	}
-}

internal/v2/repository/iam/policy/org_iam/write_model.go

@@ -1,44 +0,0 @@
-package org_iam
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/org_iam"
-)
-
-const (
-	AggregateType = "iam"
-)
-
-type WriteModel struct {
-	org_iam.WriteModel
-}
-
-func NewWriteModel(iamID string) *WriteModel {
-	return &WriteModel{
-		org_iam.WriteModel{
-			WriteModel: eventstore.WriteModel{
-				AggregateID: iamID,
-			},
-		},
-	}
-}
-
-func (wm *WriteModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.WriteModel.AppendEvents(&e.AddedEvent)
-		case *ChangedEvent:
-			wm.WriteModel.AppendEvents(&e.ChangedEvent)
-		}
-	}
-}
-
-func (wm *WriteModel) Reduce() error {
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *WriteModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(wm.WriteModel.AggregateID)
-}

internal/v2/repository/iam/policy/password_age/events.go

@@ -1,73 +0,0 @@
-package password_age
-
-import (
-	"context"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_age"
-)
-
-var (
-	iamEventPrefix                    = eventstore.EventType("iam.")
-	PasswordAgePolicyAddedEventType   = iamEventPrefix + password_age.PasswordAgePolicyAddedEventType
-	PasswordAgePolicyChangedEventType = iamEventPrefix + password_age.PasswordAgePolicyChangedEventType
-)
-
-type AddedEvent struct {
-	password_age.AddedEvent
-}
-
-func NewAddedEvent(
-	ctx context.Context,
-	expireWarnDays,
-	maxAgeDays uint64,
-) *AddedEvent {
-	return &AddedEvent{
-		AddedEvent: *password_age.NewAddedEvent(
-			eventstore.NewBaseEventForPush(ctx, PasswordAgePolicyAddedEventType),
-			expireWarnDays,
-			maxAgeDays),
-	}
-}
-
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := password_age.AddedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &AddedEvent{AddedEvent: *e.(*password_age.AddedEvent)}, nil
-}
-
-type ChangedEvent struct {
-	password_age.ChangedEvent
-}
-
-func ChangedEventFromExisting(
-	ctx context.Context,
-	current *WriteModel,
-	expireWarnDays,
-	maxAgeDays uint64,
-) (*ChangedEvent, error) {
-	event := password_age.NewChangedEvent(
-		eventstore.NewBaseEventForPush(
-			ctx,
-			PasswordAgePolicyChangedEventType,
-		),
-		&current.WriteModel,
-		expireWarnDays,
-		maxAgeDays,
-	)
-	return &ChangedEvent{
-		*event,
-	}, nil
-}
-
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := password_age.ChangedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ChangedEvent{ChangedEvent: *e.(*password_age.ChangedEvent)}, nil
-}

internal/v2/repository/iam/policy/password_age/read_model.go

@@ -1,25 +0,0 @@
-package password_age
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_age"
-)
-
-type ReadModel struct {
-	password_age.ReadModel
-}
-
-func (rm *ReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *ChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *password_age.AddedEvent,
-			*password_age.ChangedEvent:
-
-			rm.ReadModel.AppendEvents(e)
-		}
-	}
-}

internal/v2/repository/iam/policy/password_age/write_model.go

@@ -1,44 +0,0 @@
-package password_age
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_age"
-)
-
-const (
-	AggregateType = "iam"
-)
-
-type WriteModel struct {
-	password_age.WriteModel
-}
-
-func NewWriteModel(iamID string) *WriteModel {
-	return &WriteModel{
-		password_age.WriteModel{
-			WriteModel: eventstore.WriteModel{
-				AggregateID: iamID,
-			},
-		},
-	}
-}
-
-func (wm *WriteModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.WriteModel.AppendEvents(&e.AddedEvent)
-		case *ChangedEvent:
-			wm.WriteModel.AppendEvents(&e.ChangedEvent)
-		}
-	}
-}
-
-func (wm *WriteModel) Reduce() error {
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *WriteModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(wm.WriteModel.AggregateID)
-}

internal/v2/repository/iam/policy/password_complexity/events.go

@@ -1,85 +0,0 @@
-package password_complexity
-
-import (
-	"context"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_complexity"
-)
-
-const (
-	iamEventPrefix                           = eventstore.EventType("iam.")
-	PasswordComplexityPolicyAddedEventType   = iamEventPrefix + password_complexity.PasswordComplexityPolicyAddedEventType
-	PasswordComplexityPolicyChangedEventType = iamEventPrefix + password_complexity.PasswordComplexityPolicyChangedEventType
-)
-
-type AddedEvent struct {
-	password_complexity.AddedEvent
-}
-
-func NewAddedEvent(
-	ctx context.Context,
-	minLength uint64,
-	hasLowercase,
-	hasUppercase,
-	hasNumber,
-	hasSymbol bool,
-) *AddedEvent {
-	return &AddedEvent{
-		AddedEvent: *password_complexity.NewAddedEvent(
-			eventstore.NewBaseEventForPush(ctx, PasswordComplexityPolicyAddedEventType),
-			minLength,
-			hasLowercase,
-			hasUppercase,
-			hasNumber,
-			hasSymbol),
-	}
-}
-
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := password_complexity.AddedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &AddedEvent{AddedEvent: *e.(*password_complexity.AddedEvent)}, nil
-}
-
-type ChangedEvent struct {
-	password_complexity.ChangedEvent
-}
-
-func ChangedEventFromExisting(
-	ctx context.Context,
-	current *WriteModel,
-	minLength uint64,
-	hasLowerCase,
-	hasUpperCase,
-	hasNumber,
-	hasSymbol bool,
-) (*ChangedEvent, error) {
-	event := password_complexity.NewChangedEvent(
-		eventstore.NewBaseEventForPush(
-			ctx,
-			PasswordComplexityPolicyChangedEventType,
-		),
-		&current.WriteModel,
-		minLength,
-		hasLowerCase,
-		hasUpperCase,
-		hasNumber,
-		hasSymbol,
-	)
-	return &ChangedEvent{
-		*event,
-	}, nil
-}
-
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := password_complexity.ChangedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ChangedEvent{ChangedEvent: *e.(*password_complexity.ChangedEvent)}, nil
-}

internal/v2/repository/iam/policy/password_complexity/read_model.go

@@ -1,25 +0,0 @@
-package password_complexity
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_complexity"
-)
-
-type ReadModel struct {
-	password_complexity.ReadModel
-}
-
-func (rm *ReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *ChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *password_complexity.AddedEvent,
-			*password_complexity.ChangedEvent:
-
-			rm.ReadModel.AppendEvents(e)
-		}
-	}
-}

internal/v2/repository/iam/policy/password_complexity/write_model.go

@@ -1,44 +0,0 @@
-package password_complexity
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_complexity"
-)
-
-const (
-	AggregateType = "iam"
-)
-
-type WriteModel struct {
-	password_complexity.WriteModel
-}
-
-func NewWriteModel(iamID string) *WriteModel {
-	return &WriteModel{
-		password_complexity.WriteModel{
-			WriteModel: eventstore.WriteModel{
-				AggregateID: iamID,
-			},
-		},
-	}
-}
-
-func (wm *WriteModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.WriteModel.AppendEvents(&e.AddedEvent)
-		case *ChangedEvent:
-			wm.WriteModel.AppendEvents(&e.ChangedEvent)
-		}
-	}
-}
-
-func (wm *WriteModel) Reduce() error {
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *WriteModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(wm.WriteModel.AggregateID)
-}

internal/v2/repository/iam/policy/password_lockout/events.go

@@ -1,73 +0,0 @@
-package password_lockout
-
-import (
-	"context"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_lockout"
-)
-
-var (
-	iamEventPrefix                        = eventstore.EventType("iam.")
-	PasswordLockoutPolicyAddedEventType   = iamEventPrefix + password_lockout.PasswordLockoutPolicyAddedEventType
-	PasswordLockoutPolicyChangedEventType = iamEventPrefix + password_lockout.PasswordLockoutPolicyChangedEventType
-)
-
-type AddedEvent struct {
-	password_lockout.AddedEvent
-}
-
-func NewAddedEvent(
-	ctx context.Context,
-	maxAttempts uint64,
-	showLockoutFailure bool,
-) *AddedEvent {
-	return &AddedEvent{
-		AddedEvent: *password_lockout.NewAddedEvent(
-			eventstore.NewBaseEventForPush(ctx, PasswordLockoutPolicyAddedEventType),
-			maxAttempts,
-			showLockoutFailure),
-	}
-}
-
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := password_lockout.AddedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &AddedEvent{AddedEvent: *e.(*password_lockout.AddedEvent)}, nil
-}
-
-type ChangedEvent struct {
-	password_lockout.ChangedEvent
-}
-
-func ChangedEventFromExisting(
-	ctx context.Context,
-	current *WriteModel,
-	maxAttempts uint64,
-	showLockoutFailure bool,
-) (*ChangedEvent, error) {
-	event := password_lockout.NewChangedEvent(
-		eventstore.NewBaseEventForPush(
-			ctx,
-			PasswordLockoutPolicyChangedEventType,
-		),
-		&current.WriteModel,
-		maxAttempts,
-		showLockoutFailure,
-	)
-	return &ChangedEvent{
-		*event,
-	}, nil
-}
-
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := password_lockout.ChangedEventMapper(event)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ChangedEvent{ChangedEvent: *e.(*password_lockout.ChangedEvent)}, nil
-}

internal/v2/repository/iam/policy/password_lockout/read_model.go

@@ -1,23 +0,0 @@
-package password_lockout
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_lockout"
-)
-
-type ReadModel struct {
-	password_lockout.ReadModel
-}
-
-func (rm *ReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *ChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *password_lockout.AddedEvent, *password_lockout.ChangedEvent:
-			rm.ReadModel.AppendEvents(e)
-		}
-	}
-}

internal/v2/repository/iam/policy/password_lockout/write_model.go

@@ -1,44 +0,0 @@
-package password_lockout
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_lockout"
-)
-
-const (
-	AggregateType = "iam"
-)
-
-type WriteModel struct {
-	password_lockout.WriteModel
-}
-
-func NewWriteModel(iamID string) *WriteModel {
-	return &WriteModel{
-		password_lockout.WriteModel{
-			WriteModel: eventstore.WriteModel{
-				AggregateID: iamID,
-			},
-		},
-	}
-}
-
-func (wm *WriteModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.WriteModel.AppendEvents(&e.AddedEvent)
-		case *ChangedEvent:
-			wm.WriteModel.AppendEvents(&e.ChangedEvent)
-		}
-	}
-}
-
-func (wm *WriteModel) Reduce() error {
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *WriteModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).
-		AggregateIDs(wm.WriteModel.AggregateID)
-}

internal/v2/repository/iam/policy_label.go

@@ -0,0 +1,62 @@
+package iam
+
+import (
+	"context"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+var (
+	LabelPolicyAddedEventType   = iamEventTypePrefix + policy.LabelPolicyAddedEventType
+	LabelPolicyChangedEventType = iamEventTypePrefix + policy.LabelPolicyChangedEventType
+)
+
+type LabelPolicyAddedEvent struct {
+	policy.LabelPolicyAddedEvent
+}
+
+func NewLabelPolicyAddedEvent(
+	ctx context.Context,
+	primaryColor,
+	secondaryColor string,
+) *LabelPolicyAddedEvent {
+	return &LabelPolicyAddedEvent{
+		LabelPolicyAddedEvent: *policy.NewLabelPolicyAddedEvent(
+			eventstore.NewBaseEventForPush(ctx, LabelPolicyAddedEventType),
+			primaryColor,
+			secondaryColor),
+	}
+}
+
+func LabelPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.LabelPolicyAddedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &LabelPolicyAddedEvent{LabelPolicyAddedEvent: *e.(*policy.LabelPolicyAddedEvent)}, nil
+}
+
+type LabelPolicyChangedEvent struct {
+	policy.LabelPolicyChangedEvent
+}
+
+func NewLabelPolicyChangedEvent(
+	ctx context.Context,
+) *LabelPolicyChangedEvent {
+	return &LabelPolicyChangedEvent{
+		LabelPolicyChangedEvent: *policy.NewLabelPolicyChangedEvent(
+			eventstore.NewBaseEventForPush(ctx, LabelPolicyChangedEventType),
+		),
+	}
+}
+
+func LabelPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.LabelPolicyChangedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &LabelPolicyChangedEvent{LabelPolicyChangedEvent: *e.(*policy.LabelPolicyChangedEvent)}, nil
+}

internal/v2/repository/iam/policy_login.go

@@ -0,0 +1,69 @@
+package iam
+
+import (
+	"context"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/domain"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+var (
+	LoginPolicyAddedEventType   = iamEventTypePrefix + policy.LoginPolicyAddedEventType
+	LoginPolicyChangedEventType = iamEventTypePrefix + policy.LoginPolicyChangedEventType
+)
+
+type LoginPolicyAddedEvent struct {
+	policy.LoginPolicyAddedEvent
+}
+
+func NewLoginPolicyAddedEvent(
+	ctx context.Context,
+	allowUsernamePassword,
+	allowRegister,
+	allowExternalIDP,
+	forceMFA bool,
+	passwordlessType domain.PasswordlessType,
+) *LoginPolicyAddedEvent {
+	return &LoginPolicyAddedEvent{
+		LoginPolicyAddedEvent: *policy.NewLoginPolicyAddedEvent(
+			eventstore.NewBaseEventForPush(ctx, LoginPolicyAddedEventType),
+			allowUsernamePassword,
+			allowRegister,
+			allowExternalIDP,
+			forceMFA,
+			passwordlessType),
+	}
+}
+
+func LoginPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.LoginPolicyAddedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &LoginPolicyAddedEvent{LoginPolicyAddedEvent: *e.(*policy.LoginPolicyAddedEvent)}, nil
+}
+
+type LoginPolicyChangedEvent struct {
+	policy.LoginPolicyChangedEvent
+}
+
+func NewLoginPolicyChangedEvent(
+	ctx context.Context,
+) *LoginPolicyChangedEvent {
+	return &LoginPolicyChangedEvent{
+		LoginPolicyChangedEvent: *policy.NewLoginPolicyChangedEvent(
+			eventstore.NewBaseEventForPush(ctx, LoginPolicyChangedEventType),
+		),
+	}
+}
+
+func LoginPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.LoginPolicyChangedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &LoginPolicyChangedEvent{LoginPolicyChangedEvent: *e.(*policy.LoginPolicyChangedEvent)}, nil
+}

internal/v2/repository/iam/policy_login_factors.go

@@ -1,123 +1,123 @@
-package factors
+package iam
 
 import (
 	"context"
 	"github.com/caos/zitadel/internal/eventstore/v2"
 	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login/factors"
+	"github.com/caos/zitadel/internal/v2/domain"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
 )
 
 var (
-	iamEventPrefix                          = eventstore.EventType("iam.")
-	LoginPolicySecondFactorAddedEventType   = iamEventPrefix + factors.LoginPolicySecondFactorAddedEventType
-	LoginPolicySecondFactorRemovedEventType = iamEventPrefix + factors.LoginPolicySecondFactorRemovedEventType
+	LoginPolicySecondFactorAddedEventType   = iamEventTypePrefix + policy.LoginPolicySecondFactorAddedEventType
+	LoginPolicySecondFactorRemovedEventType = iamEventTypePrefix + policy.LoginPolicySecondFactorRemovedEventType
 
-	LoginPolicyMultiFactorAddedEventType   = iamEventPrefix + factors.LoginPolicyMultiFactorAddedEventType
-	LoginPolicyMultiFactorRemovedEventType = iamEventPrefix + factors.LoginPolicyMultiFactorRemovedEventType
+	LoginPolicyMultiFactorAddedEventType   = iamEventTypePrefix + policy.LoginPolicyMultiFactorAddedEventType
+	LoginPolicyMultiFactorRemovedEventType = iamEventTypePrefix + policy.LoginPolicyMultiFactorRemovedEventType
 )
 
 type LoginPolicySecondFactorAddedEvent struct {
-	factors.SecondFactorAddedEvent
+	policy.SecondFactorAddedEvent
 }
 
 func NewLoginPolicySecondFactorAddedEvent(
 	ctx context.Context,
-	mfaType factors.SecondFactorType,
+	mfaType domain.SecondFactorType,
 ) *LoginPolicySecondFactorAddedEvent {
 	return &LoginPolicySecondFactorAddedEvent{
-		SecondFactorAddedEvent: *factors.NewSecondFactorAddedEvent(
+		SecondFactorAddedEvent: *policy.NewSecondFactorAddedEvent(
 			eventstore.NewBaseEventForPush(ctx, LoginPolicySecondFactorAddedEventType),
 			mfaType),
 	}
 }
 
 func SecondFactorAddedEventEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := factors.SecondFactorAddedEventMapper(event)
+	e, err := policy.SecondFactorAddedEventMapper(event)
 	if err != nil {
 		return nil, err
 	}
 
 	return &LoginPolicySecondFactorAddedEvent{
-		SecondFactorAddedEvent: *e.(*factors.SecondFactorAddedEvent),
+		SecondFactorAddedEvent: *e.(*policy.SecondFactorAddedEvent),
 	}, nil
 }
 
 type LoginPolicySecondFactorRemovedEvent struct {
-	factors.SecondFactorRemovedEvent
+	policy.SecondFactorRemovedEvent
 }
 
 func NewLoginPolicySecondFactorRemovedEvent(
 	ctx context.Context,
-	mfaType factors.SecondFactorType,
+	mfaType domain.SecondFactorType,
 ) *LoginPolicySecondFactorRemovedEvent {
 
 	return &LoginPolicySecondFactorRemovedEvent{
-		SecondFactorRemovedEvent: *factors.NewSecondFactorRemovedEvent(
+		SecondFactorRemovedEvent: *policy.NewSecondFactorRemovedEvent(
 			eventstore.NewBaseEventForPush(ctx, LoginPolicySecondFactorRemovedEventType),
 			mfaType),
 	}
 }
 
 func SecondFactorRemovedEventEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := factors.SecondFactorRemovedEventMapper(event)
+	e, err := policy.SecondFactorRemovedEventMapper(event)
 	if err != nil {
 		return nil, err
 	}
 
 	return &LoginPolicySecondFactorRemovedEvent{
-		SecondFactorRemovedEvent: *e.(*factors.SecondFactorRemovedEvent),
+		SecondFactorRemovedEvent: *e.(*policy.SecondFactorRemovedEvent),
 	}, nil
 }
 
 type LoginPolicyMultiFactorAddedEvent struct {
-	factors.MultiFactorAddedEvent
+	policy.MultiFactorAddedEvent
 }
 
 func NewLoginPolicyMultiFactorAddedEvent(
 	ctx context.Context,
-	mfaType factors.MultiFactorType,
+	mfaType domain.MultiFactorType,
 ) *LoginPolicyMultiFactorAddedEvent {
 	return &LoginPolicyMultiFactorAddedEvent{
-		MultiFactorAddedEvent: *factors.NewMultiFactorAddedEvent(
+		MultiFactorAddedEvent: *policy.NewMultiFactorAddedEvent(
 			eventstore.NewBaseEventForPush(ctx, LoginPolicyMultiFactorAddedEventType),
 			mfaType),
 	}
 }
 
 func MultiFactorAddedEventEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := factors.MultiFactorAddedEventMapper(event)
+	e, err := policy.MultiFactorAddedEventMapper(event)
 	if err != nil {
 		return nil, err
 	}
 
 	return &LoginPolicyMultiFactorAddedEvent{
-		MultiFactorAddedEvent: *e.(*factors.MultiFactorAddedEvent),
+		MultiFactorAddedEvent: *e.(*policy.MultiFactorAddedEvent),
 	}, nil
 }
 
 type LoginPolicyMultiFactorRemovedEvent struct {
-	factors.MultiFactorRemovedEvent
+	policy.MultiFactorRemovedEvent
 }
 
 func NewLoginPolicyMultiFactorRemovedEvent(
 	ctx context.Context,
-	mfaType factors.MultiFactorType,
+	mfaType domain.MultiFactorType,
 ) *LoginPolicyMultiFactorRemovedEvent {
 
 	return &LoginPolicyMultiFactorRemovedEvent{
-		MultiFactorRemovedEvent: *factors.NewMultiFactorRemovedEvent(
+		MultiFactorRemovedEvent: *policy.NewMultiFactorRemovedEvent(
 			eventstore.NewBaseEventForPush(ctx, LoginPolicyMultiFactorRemovedEventType),
 			mfaType),
 	}
 }
 
 func MultiFactorRemovedEventEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e, err := factors.MultiFactorRemovedEventMapper(event)
+	e, err := policy.MultiFactorRemovedEventMapper(event)
 	if err != nil {
 		return nil, err
 	}
 
 	return &LoginPolicyMultiFactorRemovedEvent{
-		MultiFactorRemovedEvent: *e.(*factors.MultiFactorRemovedEvent),
+		MultiFactorRemovedEvent: *e.(*policy.MultiFactorRemovedEvent),
 	}, nil
 }

internal/v2/repository/iam/policy_login_identity_provider.go

@@ -0,0 +1,69 @@
+package iam
+
+import (
+	"context"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/domain"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+var (
+	LoginPolicyIDPProviderAddedEventType   = iamEventTypePrefix + policy.LoginPolicyIDPProviderAddedType
+	LoginPolicyIDPProviderRemovedEventType = iamEventTypePrefix + policy.LoginPolicyIDPProviderRemovedType
+)
+
+type IdentityProviderAddedEvent struct {
+	policy.IdentityProviderAddedEvent
+}
+
+func NewIdentityProviderAddedEvent(
+	ctx context.Context,
+	idpConfigID string,
+	idpProviderType domain.IdentityProviderType,
+) *IdentityProviderAddedEvent {
+
+	return &IdentityProviderAddedEvent{
+		IdentityProviderAddedEvent: *policy.NewIdentityProviderAddedEvent(
+			eventstore.NewBaseEventForPush(ctx, LoginPolicyIDPProviderAddedEventType),
+			idpConfigID,
+			idpProviderType),
+	}
+}
+
+func IdentityProviderAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.IdentityProviderAddedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &IdentityProviderAddedEvent{
+		IdentityProviderAddedEvent: *e.(*policy.IdentityProviderAddedEvent),
+	}, nil
+}
+
+type IdentityProviderRemovedEvent struct {
+	policy.IdentityProviderRemovedEvent
+}
+
+func NewIdentityProviderRemovedEvent(
+	ctx context.Context,
+	idpConfigID string,
+) *IdentityProviderRemovedEvent {
+	return &IdentityProviderRemovedEvent{
+		IdentityProviderRemovedEvent: *policy.NewIdentityProviderRemovedEvent(
+			eventstore.NewBaseEventForPush(ctx, LoginPolicyIDPProviderRemovedEventType),
+			idpConfigID),
+	}
+}
+
+func IdentityProviderRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.IdentityProviderRemovedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &IdentityProviderRemovedEvent{
+		IdentityProviderRemovedEvent: *e.(*policy.IdentityProviderRemovedEvent),
+	}, nil
+}

internal/v2/repository/iam/policy_org_iam.go

@@ -0,0 +1,61 @@
+package iam
+
+import (
+	"context"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+var (
+	OrgIAMPolicyAddedEventType   = iamEventTypePrefix + policy.OrgIAMPolicyAddedEventType
+	OrgIAMPolicyChangedEventType = iamEventTypePrefix + policy.OrgIAMPolicyChangedEventType
+)
+
+type OrgIAMPolicyAddedEvent struct {
+	policy.OrgIAMPolicyAddedEvent
+}
+
+func NewOrgIAMPolicyAddedEvent(
+	ctx context.Context,
+	userLoginMustBeDomain bool,
+) *OrgIAMPolicyAddedEvent {
+	return &OrgIAMPolicyAddedEvent{
+		OrgIAMPolicyAddedEvent: *policy.NewOrgIAMPolicyAddedEvent(
+			eventstore.NewBaseEventForPush(ctx, OrgIAMPolicyAddedEventType),
+			userLoginMustBeDomain,
+		),
+	}
+}
+
+func OrgIAMPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.OrgIAMPolicyAddedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &OrgIAMPolicyAddedEvent{OrgIAMPolicyAddedEvent: *e.(*policy.OrgIAMPolicyAddedEvent)}, nil
+}
+
+type OrgIAMPolicyChangedEvent struct {
+	policy.OrgIAMPolicyChangedEvent
+}
+
+func NewOrgIAMPolicyChangedEvent(
+	ctx context.Context,
+) *OrgIAMPolicyChangedEvent {
+	return &OrgIAMPolicyChangedEvent{
+		OrgIAMPolicyChangedEvent: *policy.NewOrgIAMPolicyChangedEvent(
+			eventstore.NewBaseEventForPush(ctx, OrgIAMPolicyChangedEventType),
+		),
+	}
+}
+
+func OrgIAMPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.OrgIAMPolicyChangedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &OrgIAMPolicyChangedEvent{OrgIAMPolicyChangedEvent: *e.(*policy.OrgIAMPolicyChangedEvent)}, nil
+}

internal/v2/repository/iam/policy_password_age.go

@@ -0,0 +1,62 @@
+package iam
+
+import (
+	"context"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+var (
+	PasswordAgePolicyAddedEventType   = iamEventTypePrefix + policy.PasswordAgePolicyAddedEventType
+	PasswordAgePolicyChangedEventType = iamEventTypePrefix + policy.PasswordAgePolicyChangedEventType
+)
+
+type PasswordAgePolicyAddedEvent struct {
+	policy.PasswordAgePolicyAddedEvent
+}
+
+func NewPasswordAgePolicyAddedEvent(
+	ctx context.Context,
+	expireWarnDays,
+	maxAgeDays uint64,
+) *PasswordAgePolicyAddedEvent {
+	return &PasswordAgePolicyAddedEvent{
+		PasswordAgePolicyAddedEvent: *policy.NewPasswordAgePolicyAddedEvent(
+			eventstore.NewBaseEventForPush(ctx, PasswordAgePolicyAddedEventType),
+			expireWarnDays,
+			maxAgeDays),
+	}
+}
+
+func PasswordAgePolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.PasswordAgePolicyAddedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &PasswordAgePolicyAddedEvent{PasswordAgePolicyAddedEvent: *e.(*policy.PasswordAgePolicyAddedEvent)}, nil
+}
+
+type PasswordAgePolicyChangedEvent struct {
+	policy.PasswordAgePolicyChangedEvent
+}
+
+func NewPasswordAgePolicyChangedEvent(
+	ctx context.Context,
+) *PasswordAgePolicyChangedEvent {
+	return &PasswordAgePolicyChangedEvent{
+		PasswordAgePolicyChangedEvent: *policy.NewPasswordAgePolicyChangedEvent(
+			eventstore.NewBaseEventForPush(ctx, PasswordAgePolicyChangedEventType),
+		),
+	}
+}
+
+func PasswordAgePolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.PasswordAgePolicyChangedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &PasswordAgePolicyChangedEvent{PasswordAgePolicyChangedEvent: *e.(*policy.PasswordAgePolicyChangedEvent)}, nil
+}

internal/v2/repository/iam/policy_password_complexity.go

@@ -0,0 +1,68 @@
+package iam
+
+import (
+	"context"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+const (
+	PasswordComplexityPolicyAddedEventType   = iamEventTypePrefix + policy.PasswordComplexityPolicyAddedEventType
+	PasswordComplexityPolicyChangedEventType = iamEventTypePrefix + policy.PasswordComplexityPolicyChangedEventType
+)
+
+type PasswordComplexityPolicyAddedEvent struct {
+	policy.PasswordComplexityPolicyAddedEvent
+}
+
+func NewPasswordComplexityPolicyAddedEvent(
+	ctx context.Context,
+	minLength uint64,
+	hasLowercase,
+	hasUppercase,
+	hasNumber,
+	hasSymbol bool,
+) *PasswordComplexityPolicyAddedEvent {
+	return &PasswordComplexityPolicyAddedEvent{
+		PasswordComplexityPolicyAddedEvent: *policy.NewPasswordComplexityPolicyAddedEvent(
+			eventstore.NewBaseEventForPush(ctx, PasswordComplexityPolicyAddedEventType),
+			minLength,
+			hasLowercase,
+			hasUppercase,
+			hasNumber,
+			hasSymbol),
+	}
+}
+
+func PasswordComplexityPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.PasswordComplexityPolicyAddedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &PasswordComplexityPolicyAddedEvent{PasswordComplexityPolicyAddedEvent: *e.(*policy.PasswordComplexityPolicyAddedEvent)}, nil
+}
+
+type PasswordComplexityPolicyChangedEvent struct {
+	policy.PasswordComplexityPolicyChangedEvent
+}
+
+func NewPasswordComplexityPolicyChangedEvent(
+	ctx context.Context,
+) *PasswordComplexityPolicyChangedEvent {
+	return &PasswordComplexityPolicyChangedEvent{
+		PasswordComplexityPolicyChangedEvent: *policy.NewPasswordComplexityPolicyChangedEvent(
+			eventstore.NewBaseEventForPush(ctx, PasswordComplexityPolicyAddedEventType),
+		),
+	}
+}
+
+func PasswordComplexityPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.PasswordComplexityPolicyChangedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &PasswordComplexityPolicyChangedEvent{PasswordComplexityPolicyChangedEvent: *e.(*policy.PasswordComplexityPolicyChangedEvent)}, nil
+}

internal/v2/repository/iam/policy_password_lockout.go

@@ -0,0 +1,62 @@
+package iam
+
+import (
+	"context"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+var (
+	PasswordLockoutPolicyAddedEventType   = iamEventTypePrefix + policy.PasswordLockoutPolicyAddedEventType
+	PasswordLockoutPolicyChangedEventType = iamEventTypePrefix + policy.PasswordLockoutPolicyChangedEventType
+)
+
+type PasswordLockoutPolicyAddedEvent struct {
+	policy.PasswordLockoutPolicyAddedEvent
+}
+
+func NewPasswordLockoutPolicyAddedEvent(
+	ctx context.Context,
+	maxAttempts uint64,
+	showLockoutFailure bool,
+) *PasswordLockoutPolicyAddedEvent {
+	return &PasswordLockoutPolicyAddedEvent{
+		PasswordLockoutPolicyAddedEvent: *policy.NewPasswordLockoutPolicyAddedEvent(
+			eventstore.NewBaseEventForPush(ctx, PasswordLockoutPolicyAddedEventType),
+			maxAttempts,
+			showLockoutFailure),
+	}
+}
+
+func PasswordLockoutPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.PasswordLockoutPolicyAddedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &PasswordLockoutPolicyAddedEvent{PasswordLockoutPolicyAddedEvent: *e.(*policy.PasswordLockoutPolicyAddedEvent)}, nil
+}
+
+type PasswordLockoutPolicyChangedEvent struct {
+	policy.PasswordLockoutPolicyChangedEvent
+}
+
+func NewPasswordLockoutPolicyChangedEvent(
+	ctx context.Context,
+) *PasswordLockoutPolicyChangedEvent {
+	return &PasswordLockoutPolicyChangedEvent{
+		PasswordLockoutPolicyChangedEvent: *policy.NewPasswordLockoutPolicyChangedEvent(
+			eventstore.NewBaseEventForPush(ctx, PasswordLockoutPolicyChangedEventType),
+		),
+	}
+}
+
+func PasswordLockoutPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.PasswordLockoutPolicyChangedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &PasswordLockoutPolicyChangedEvent{PasswordLockoutPolicyChangedEvent: *e.(*policy.PasswordLockoutPolicyChangedEvent)}, nil
+}

internal/v2/repository/iam/read_model.go

@@ -1,141 +0,0 @@
-package iam
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	iam_label "github.com/caos/zitadel/internal/v2/repository/iam/policy/label"
-	iam_login "github.com/caos/zitadel/internal/v2/repository/iam/policy/login"
-	iam_org_iam "github.com/caos/zitadel/internal/v2/repository/iam/policy/org_iam"
-	iam_password_age "github.com/caos/zitadel/internal/v2/repository/iam/policy/password_age"
-	iam_password_complexity "github.com/caos/zitadel/internal/v2/repository/iam/policy/password_complexity"
-	iam_password_lockout "github.com/caos/zitadel/internal/v2/repository/iam/policy/password_lockout"
-	"github.com/caos/zitadel/internal/v2/repository/member"
-	"github.com/caos/zitadel/internal/v2/repository/policy/label"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login"
-	"github.com/caos/zitadel/internal/v2/repository/policy/org_iam"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_age"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_complexity"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_lockout"
-)
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	SetUpStarted Step
-	SetUpDone    Step
-
-	Members MembersReadModel
-	IDPs    IDPConfigsReadModel
-
-	GlobalOrgID string
-	ProjectID   string
-
-	DefaultLoginPolicy              iam_login.ReadModel
-	DefaultLabelPolicy              iam_label.ReadModel
-	DefaultOrgIAMPolicy             iam_org_iam.ReadModel
-	DefaultPasswordComplexityPolicy iam_password_complexity.ReadModel
-	DefaultPasswordAgePolicy        iam_password_age.ReadModel
-	DefaultPasswordLockoutPolicy    iam_password_lockout.ReadModel
-}
-
-func NewReadModel(id string) *ReadModel {
-	return &ReadModel{
-		ReadModel: eventstore.ReadModel{
-			AggregateID: id,
-		},
-	}
-}
-
-func (rm *ReadModel) IDPByID(idpID string) *IDPConfigReadModel {
-	_, config := rm.IDPs.ConfigByID(idpID)
-	if config == nil {
-		return nil
-	}
-	return &IDPConfigReadModel{ConfigReadModel: *config}
-}
-
-func (rm *ReadModel) AppendEvents(events ...eventstore.EventReader) {
-	rm.ReadModel.AppendEvents(events...)
-	for _, event := range events {
-		switch event.(type) {
-		case *member.AddedEvent,
-			*member.ChangedEvent,
-			*member.RemovedEvent:
-
-			rm.Members.AppendEvents(event)
-		case *IDPConfigAddedEvent,
-			*IDPConfigChangedEvent,
-			*IDPConfigDeactivatedEvent,
-			*IDPConfigReactivatedEvent,
-			*IDPConfigRemovedEvent,
-			*IDPOIDCConfigAddedEvent,
-			*IDPOIDCConfigChangedEvent:
-
-			rm.IDPs.AppendEvents(event)
-		case *label.AddedEvent,
-			*label.ChangedEvent:
-
-			rm.DefaultLabelPolicy.AppendEvents(event)
-		case *login.AddedEvent,
-			*login.ChangedEvent:
-
-			rm.DefaultLoginPolicy.AppendEvents(event)
-		case *org_iam.AddedEvent:
-			rm.DefaultOrgIAMPolicy.AppendEvents(event)
-		case *password_complexity.AddedEvent,
-			*password_complexity.ChangedEvent:
-
-			rm.DefaultPasswordComplexityPolicy.AppendEvents(event)
-		case *password_age.AddedEvent,
-			*password_age.ChangedEvent:
-
-			rm.DefaultPasswordAgePolicy.AppendEvents(event)
-		case *password_lockout.AddedEvent,
-			*password_lockout.ChangedEvent:
-
-			rm.DefaultPasswordLockoutPolicy.AppendEvents(event)
-		}
-	}
-}
-
-func (rm *ReadModel) Reduce() (err error) {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *ProjectSetEvent:
-			rm.ProjectID = e.ProjectID
-		case *GlobalOrgSetEvent:
-			rm.GlobalOrgID = e.OrgID
-		case *SetupStepEvent:
-			if e.Done {
-				rm.SetUpDone = e.Step
-			} else {
-				rm.SetUpStarted = e.Step
-			}
-		}
-	}
-	for _, reduce := range []func() error{
-		rm.Members.Reduce,
-		rm.IDPs.Reduce,
-		rm.DefaultLoginPolicy.Reduce,
-		rm.DefaultLabelPolicy.Reduce,
-		rm.DefaultOrgIAMPolicy.Reduce,
-		rm.DefaultPasswordComplexityPolicy.Reduce,
-		rm.DefaultPasswordAgePolicy.Reduce,
-		rm.DefaultPasswordLockoutPolicy.Reduce,
-		rm.ReadModel.Reduce,
-	} {
-		if err = reduce(); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (rm *ReadModel) AppendAndReduce(events ...eventstore.EventReader) error {
-	rm.AppendEvents(events...)
-	return rm.Reduce()
-}
-
-func (rm *ReadModel) Query() *eventstore.SearchQueryBuilder {
-	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent, AggregateType).AggregateIDs(rm.AggregateID)
-}

internal/v2/repository/idp/config.go

@@ -1,49 +0,0 @@
-package idp
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type ConfigAggregate struct {
-	eventstore.Aggregate
-}
-
-type ConfigType int32
-
-const (
-	ConfigTypeOIDC ConfigType = iota
-	ConfigTypeSAML
-
-	//count is for validation
-	configTypeCount
-)
-
-func (f ConfigType) Valid() bool {
-	return f >= 0 && f < configTypeCount
-}
-
-type ConfigState int32
-
-const (
-	ConfigStateActive ConfigState = iota
-	ConfigStateInactive
-	ConfigStateRemoved
-
-	configStateCount
-)
-
-func (f ConfigState) Valid() bool {
-	return f >= 0 && f < configStateCount
-}
-
-type StylingType int32
-
-const (
-	StylingTypeGoogle StylingType = iota + 1
-
-	stylingTypeCount
-)
-
-func (f StylingType) Valid() bool {
-	return f >= 0 && f < stylingTypeCount
-}

internal/v2/repository/idp/config_read_model.go

@@ -1,93 +0,0 @@
-package idp
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/idp/oidc"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login/idpprovider"
-)
-
-type ConfigReadModel struct {
-	eventstore.ReadModel
-
-	State        ConfigState
-	ConfigID     string
-	Name         string
-	StylingType  StylingType
-	ProviderType idpprovider.Type
-
-	OIDCConfig *oidc.ConfigReadModel
-}
-
-func NewConfigReadModel(configID string) *ConfigReadModel {
-	return &ConfigReadModel{
-		ConfigID: configID,
-	}
-}
-
-func (rm *ConfigReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *ConfigAddedEvent:
-			rm.ReadModel.AppendEvents(e)
-		case *ConfigChangedEvent:
-			rm.ReadModel.AppendEvents(e)
-		case *ConfigDeactivatedEvent:
-			rm.ReadModel.AppendEvents(e)
-		case *ConfigReactivatedEvent:
-			rm.ReadModel.AppendEvents(e)
-		case *ConfigRemovedEvent:
-			rm.ReadModel.AppendEvents(e)
-		case *oidc.ConfigAddedEvent:
-			rm.OIDCConfig = &oidc.ConfigReadModel{}
-			rm.ReadModel.AppendEvents(e)
-			rm.OIDCConfig.AppendEvents(event)
-		case *oidc.ConfigChangedEvent:
-			rm.ReadModel.AppendEvents(e)
-			rm.OIDCConfig.AppendEvents(event)
-		}
-	}
-}
-
-func (rm *ConfigReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *ConfigAddedEvent:
-			rm.reduceConfigAddedEvent(e)
-		case *ConfigChangedEvent:
-			rm.reduceConfigChangedEvent(e)
-		case *ConfigDeactivatedEvent:
-			rm.reduceConfigStateChanged(e.ConfigID, ConfigStateInactive)
-		case *ConfigReactivatedEvent:
-			rm.reduceConfigStateChanged(e.ConfigID, ConfigStateActive)
-		case *ConfigRemovedEvent:
-			rm.reduceConfigStateChanged(e.ConfigID, ConfigStateRemoved)
-		}
-	}
-
-	if rm.OIDCConfig != nil {
-		if err := rm.OIDCConfig.Reduce(); err != nil {
-			return err
-		}
-	}
-	return rm.ReadModel.Reduce()
-}
-
-func (rm *ConfigReadModel) reduceConfigAddedEvent(e *ConfigAddedEvent) {
-	rm.ConfigID = e.ConfigID
-	rm.Name = e.Name
-	rm.StylingType = e.StylingType
-	rm.State = ConfigStateActive
-}
-
-func (rm *ConfigReadModel) reduceConfigChangedEvent(e *ConfigChangedEvent) {
-	if e.Name != "" {
-		rm.Name = e.Name
-	}
-	if e.StylingType.Valid() {
-		rm.StylingType = e.StylingType
-	}
-}
-
-func (rm *ConfigReadModel) reduceConfigStateChanged(configID string, state ConfigState) {
-	rm.State = state
-}

internal/v2/repository/idp/config_write_model.go

@@ -1,74 +0,0 @@
-package idp
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/idp/oidc"
-)
-
-type ConfigWriteModel struct {
-	eventstore.WriteModel
-
-	State ConfigState
-
-	ConfigID    string
-	Name        string
-	StylingType StylingType
-
-	OIDCConfig *oidc.ConfigWriteModel
-}
-
-func (rm *ConfigWriteModel) AppendEvents(events ...eventstore.EventReader) {
-	rm.WriteModel.AppendEvents(events...)
-	for _, event := range events {
-		switch event.(type) {
-		case *oidc.ConfigAddedEvent:
-			rm.OIDCConfig = new(oidc.ConfigWriteModel)
-			rm.OIDCConfig.AppendEvents(event)
-		case *oidc.ConfigChangedEvent:
-			rm.OIDCConfig.AppendEvents(event)
-		}
-	}
-}
-
-func (rm *ConfigWriteModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *ConfigAddedEvent:
-			rm.reduceConfigAddedEvent(e)
-		case *ConfigChangedEvent:
-			rm.reduceConfigChangedEvent(e)
-		case *ConfigDeactivatedEvent:
-			rm.reduceConfigStateChanged(e.ConfigID, ConfigStateInactive)
-		case *ConfigReactivatedEvent:
-			rm.reduceConfigStateChanged(e.ConfigID, ConfigStateActive)
-		case *ConfigRemovedEvent:
-			rm.reduceConfigStateChanged(e.ConfigID, ConfigStateRemoved)
-		}
-	}
-	if rm.OIDCConfig != nil {
-		if err := rm.OIDCConfig.Reduce(); err != nil {
-			return err
-		}
-	}
-	return rm.WriteModel.Reduce()
-}
-
-func (rm *ConfigWriteModel) reduceConfigAddedEvent(e *ConfigAddedEvent) {
-	rm.ConfigID = e.ConfigID
-	rm.Name = e.Name
-	rm.StylingType = e.StylingType
-	rm.State = ConfigStateActive
-}
-
-func (rm *ConfigWriteModel) reduceConfigChangedEvent(e *ConfigChangedEvent) {
-	if e.Name != "" {
-		rm.Name = e.Name
-	}
-	if e.StylingType.Valid() {
-		rm.StylingType = e.StylingType
-	}
-}
-
-func (rm *ConfigWriteModel) reduceConfigStateChanged(configID string, state ConfigState) {
-	rm.State = state
-}

internal/v2/repository/idp/configs_read_model.go

@@ -1,64 +0,0 @@
-package idp
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/idp/oidc"
-)
-
-type ConfigsReadModel struct {
-	eventstore.ReadModel
-
-	Configs []*ConfigReadModel
-}
-
-func (rm *ConfigsReadModel) ConfigByID(id string) (idx int, config *ConfigReadModel) {
-	for idx, config = range rm.Configs {
-		if config.ConfigID == id {
-			return idx, config
-		}
-	}
-	return -1, nil
-}
-
-func (rm *ConfigsReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *ConfigAddedEvent:
-			config := NewConfigReadModel(e.ConfigID)
-			rm.Configs = append(rm.Configs, config)
-			config.AppendEvents(event)
-		case *ConfigChangedEvent:
-			_, config := rm.ConfigByID(e.ConfigID)
-			config.AppendEvents(e)
-		case *ConfigDeactivatedEvent:
-			_, config := rm.ConfigByID(e.ConfigID)
-			config.AppendEvents(e)
-		case *ConfigReactivatedEvent:
-			_, config := rm.ConfigByID(e.ConfigID)
-			config.AppendEvents(e)
-		case *oidc.ConfigAddedEvent:
-			_, config := rm.ConfigByID(e.IDPConfigID)
-			config.AppendEvents(e)
-		case *oidc.ConfigChangedEvent:
-			_, config := rm.ConfigByID(e.IDPConfigID)
-			config.AppendEvents(e)
-		case *ConfigRemovedEvent:
-			idx, _ := rm.ConfigByID(e.ConfigID)
-			if idx < 0 {
-				continue
-			}
-			copy(rm.Configs[idx:], rm.Configs[idx+1:])
-			rm.Configs[len(rm.Configs)-1] = nil
-			rm.Configs = rm.Configs[:len(rm.Configs)-1]
-		}
-	}
-}
-
-func (rm *ConfigsReadModel) Reduce() error {
-	for _, config := range rm.Configs {
-		if err := config.Reduce(); err != nil {
-			return err
-		}
-	}
-	return nil
-}

internal/v2/repository/idp/event_config_added.go

@@ -1,52 +0,0 @@
-package idp
-
-import (
-	"encoding/json"
-
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-type ConfigAddedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	ConfigID    string      `json:"idpConfigId"`
-	Name        string      `json:"name,omitempty"`
-	Typ         ConfigType  `json:"idpType,omitempty"`
-	StylingType StylingType `json:"stylingType,omitempty"`
-}
-
-func NewConfigAddedEvent(
-	base *eventstore.BaseEvent,
-	configID string,
-	name string,
-	configType ConfigType,
-	stylingType StylingType,
-) *ConfigAddedEvent {
-
-	return &ConfigAddedEvent{
-		BaseEvent:   *base,
-		ConfigID:    configID,
-		Name:        name,
-		StylingType: stylingType,
-		Typ:         configType,
-	}
-}
-
-func (e *ConfigAddedEvent) Data() interface{} {
-	return e
-}
-
-func ConfigAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ConfigAddedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
-	}
-
-	return e, nil
-}

internal/v2/repository/idp/event_config_changed.go

@@ -1,63 +0,0 @@
-package idp
-
-import (
-	"encoding/json"
-
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-type ConfigChangedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	ConfigID    string      `json:"idpConfigId"`
-	Name        string      `json:"name,omitempty"`
-	StylingType StylingType `json:"stylingType,omitempty"`
-}
-
-func NewConfigChangedEvent(
-	base *eventstore.BaseEvent,
-	current *ConfigWriteModel,
-	name string,
-	stylingType StylingType,
-) (*ConfigChangedEvent, error) {
-
-	change := &ConfigChangedEvent{
-		BaseEvent: *base,
-		ConfigID:  current.ConfigID,
-	}
-	hasChanged := false
-
-	if current.Name != name {
-		change.Name = name
-		hasChanged = true
-	}
-	if stylingType != current.StylingType {
-		change.StylingType = stylingType
-		hasChanged = true
-	}
-
-	if !hasChanged {
-		return nil, errors.ThrowPreconditionFailed(nil, "IDP-UBJbB", "Errors.NoChanges")
-	}
-
-	return change, nil
-}
-
-func (e *ConfigChangedEvent) Data() interface{} {
-	return e
-}
-
-func ConfigChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ConfigChangedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
-	}
-
-	return e, nil
-}

internal/v2/repository/idp/event_config_deactivated.go

@@ -1,43 +0,0 @@
-package idp
-
-import (
-	"encoding/json"
-
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-type ConfigDeactivatedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	ConfigID string `idpConfigId`
-}
-
-func NewConfigDeactivatedEvent(
-	base *eventstore.BaseEvent,
-	configID string,
-) *ConfigDeactivatedEvent {
-
-	return &ConfigDeactivatedEvent{
-		BaseEvent: *base,
-		ConfigID:  configID,
-	}
-}
-
-func (e *ConfigDeactivatedEvent) Data() interface{} {
-	return e
-}
-
-func ConfigDeactivatedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ConfigDeactivatedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
-	}
-
-	return e, nil
-}

internal/v2/repository/idp/event_config_reactivated.go

@@ -1,43 +0,0 @@
-package idp
-
-import (
-	"encoding/json"
-
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-type ConfigReactivatedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	ConfigID string `idpConfigId`
-}
-
-func NewConfigReactivatedEvent(
-	base *eventstore.BaseEvent,
-	configID string,
-) *ConfigReactivatedEvent {
-
-	return &ConfigReactivatedEvent{
-		BaseEvent: *base,
-		ConfigID:  configID,
-	}
-}
-
-func (e *ConfigReactivatedEvent) Data() interface{} {
-	return e
-}
-
-func ConfigReactivatedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ConfigReactivatedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
-	}
-
-	return e, nil
-}

internal/v2/repository/idp/event_config_removed.go

@@ -1,43 +0,0 @@
-package idp
-
-import (
-	"encoding/json"
-
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-type ConfigRemovedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	ConfigID string `idpConfigId`
-}
-
-func NewConfigRemovedEvent(
-	base *eventstore.BaseEvent,
-	configID string,
-) *ConfigRemovedEvent {
-
-	return &ConfigRemovedEvent{
-		BaseEvent: *base,
-		ConfigID:  configID,
-	}
-}
-
-func (e *ConfigRemovedEvent) Data() interface{} {
-	return e
-}
-
-func ConfigRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ConfigRemovedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
-	}
-
-	return e, nil
-}

internal/v2/repository/idp/oidc/config_read_model.go

@@ -1,59 +0,0 @@
-package oidc
-
-import (
-	"github.com/caos/zitadel/internal/crypto"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type ConfigReadModel struct {
-	eventstore.ReadModel
-
-	IDPConfigID           string
-	ClientID              string
-	ClientSecret          *crypto.CryptoValue
-	Issuer                string
-	Scopes                []string
-	IDPDisplayNameMapping MappingField
-	UserNameMapping       MappingField
-}
-
-func (rm *ConfigReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *ConfigAddedEvent:
-			rm.reduceConfigAddedEvent(e)
-		case *ConfigChangedEvent:
-			rm.reduceConfigChangedEvent(e)
-		}
-	}
-
-	return rm.ReadModel.Reduce()
-}
-
-func (rm *ConfigReadModel) reduceConfigAddedEvent(e *ConfigAddedEvent) {
-	rm.IDPConfigID = e.IDPConfigID
-	rm.ClientID = e.ClientID
-	rm.ClientSecret = e.ClientSecret
-	rm.Issuer = e.Issuer
-	rm.Scopes = e.Scopes
-	rm.IDPDisplayNameMapping = e.IDPDisplayNameMapping
-	rm.UserNameMapping = e.UserNameMapping
-}
-
-func (rm *ConfigReadModel) reduceConfigChangedEvent(e *ConfigChangedEvent) {
-	if e.ClientID != "" {
-		rm.ClientID = e.ClientID
-	}
-	if e.Issuer != "" {
-		rm.Issuer = e.Issuer
-	}
-	if len(e.Scopes) > 0 {
-		rm.Scopes = e.Scopes
-	}
-	if e.IDPDisplayNameMapping.Valid() {
-		rm.IDPDisplayNameMapping = e.IDPDisplayNameMapping
-	}
-	if e.UserNameMapping.Valid() {
-		rm.UserNameMapping = e.UserNameMapping
-	}
-}

internal/v2/repository/idp/oidc/config_write_model.go

@@ -1,60 +0,0 @@
-package oidc
-
-import (
-	"github.com/caos/zitadel/internal/crypto"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type ConfigWriteModel struct {
-	eventstore.WriteModel
-
-	IDPConfigID  string
-	ClientID     string
-	ClientSecret *crypto.CryptoValue
-	Issuer       string
-	Scopes       []string
-
-	IDPDisplayNameMapping MappingField
-	UserNameMapping       MappingField
-}
-
-func (wm *ConfigWriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *ConfigAddedEvent:
-			wm.reduceConfigAddedEvent(e)
-		case *ConfigChangedEvent:
-			wm.reduceConfigChangedEvent(e)
-		}
-	}
-
-	return wm.WriteModel.Reduce()
-}
-
-func (wm *ConfigWriteModel) reduceConfigAddedEvent(e *ConfigAddedEvent) {
-	wm.IDPConfigID = e.IDPConfigID
-	wm.ClientID = e.ClientID
-	wm.ClientSecret = e.ClientSecret
-	wm.Issuer = e.Issuer
-	wm.Scopes = e.Scopes
-	wm.IDPDisplayNameMapping = e.IDPDisplayNameMapping
-	wm.UserNameMapping = e.UserNameMapping
-}
-
-func (wm *ConfigWriteModel) reduceConfigChangedEvent(e *ConfigChangedEvent) {
-	if e.ClientID != "" {
-		wm.ClientID = e.ClientID
-	}
-	if e.Issuer != "" {
-		wm.Issuer = e.Issuer
-	}
-	if len(e.Scopes) > 0 {
-		wm.Scopes = e.Scopes
-	}
-	if e.IDPDisplayNameMapping.Valid() {
-		wm.IDPDisplayNameMapping = e.IDPDisplayNameMapping
-	}
-	if e.UserNameMapping.Valid() {
-		wm.UserNameMapping = e.UserNameMapping
-	}
-}

internal/v2/repository/idp/oidc/event_added.go

@@ -1,67 +0,0 @@
-package oidc
-
-import (
-	"encoding/json"
-
-	"github.com/caos/zitadel/internal/crypto"
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-const (
-	ConfigAddedEventType eventstore.EventType = "oidc.config.added"
-)
-
-type ConfigAddedEvent struct {
-	eventstore.BaseEvent
-
-	IDPConfigID  string              `json:"idpConfigId"`
-	ClientID     string              `json:"clientId,omitempty"`
-	ClientSecret *crypto.CryptoValue `json:"clientSecret,omitempty"`
-	Issuer       string              `json:"issuer,omitempty"`
-	Scopes       []string            `json:"scpoes,omitempty"`
-
-	IDPDisplayNameMapping MappingField `json:"idpDisplayNameMapping,omitempty"`
-	UserNameMapping       MappingField `json:"usernameMapping,omitempty"`
-}
-
-func (e *ConfigAddedEvent) Data() interface{} {
-	return e
-}
-
-func NewConfigAddedEvent(
-	base *eventstore.BaseEvent,
-	clientID,
-	idpConfigID,
-	issuer string,
-	clientSecret *crypto.CryptoValue,
-	idpDisplayNameMapping,
-	userNameMapping MappingField,
-	scopes ...string,
-) *ConfigAddedEvent {
-
-	return &ConfigAddedEvent{
-		BaseEvent:             *base,
-		IDPConfigID:           idpConfigID,
-		ClientID:              clientID,
-		ClientSecret:          clientSecret,
-		Issuer:                issuer,
-		Scopes:                scopes,
-		IDPDisplayNameMapping: idpDisplayNameMapping,
-		UserNameMapping:       userNameMapping,
-	}
-}
-
-func ConfigAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ConfigAddedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
-	}
-
-	return e, nil
-}

internal/v2/repository/idp/oidc/event_changed.go

@@ -1,105 +0,0 @@
-package oidc
-
-import (
-	"encoding/json"
-	"reflect"
-	"sort"
-
-	"github.com/caos/zitadel/internal/crypto"
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-const (
-	ConfigChangedEventType eventstore.EventType = "oidc.config.changed"
-)
-
-type ConfigChangedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	IDPConfigID string `json:"idpConfigId"`
-
-	ClientID     string              `json:"clientId,omitempty"`
-	ClientSecret *crypto.CryptoValue `json:"clientSecret,omitempty"`
-	Issuer       string              `json:"issuer,omitempty"`
-	Scopes       []string            `json:"scpoes,omitempty"`
-
-	IDPDisplayNameMapping MappingField `json:"idpDisplayNameMapping,omitempty"`
-	UserNameMapping       MappingField `json:"usernameMapping,omitempty"`
-}
-
-func (e *ConfigChangedEvent) Data() interface{} {
-	return e
-}
-
-func NewConfigChangedEvent(
-	base *eventstore.BaseEvent,
-	current *ConfigWriteModel,
-	clientID,
-	issuer string,
-	clientSecret *crypto.CryptoValue,
-	idpDisplayNameMapping,
-	userNameMapping MappingField,
-	scopes ...string,
-) (*ConfigChangedEvent, error) {
-
-	event := &ConfigChangedEvent{
-		BaseEvent:   *base,
-		IDPConfigID: current.IDPConfigID,
-	}
-	hasChanged := false
-
-	if clientID != "" && clientID != current.ClientID {
-		event.ClientID = clientID
-		hasChanged = true
-	}
-
-	if issuer != "" && issuer != current.Issuer {
-		event.Issuer = issuer
-		hasChanged = true
-	}
-
-	if clientSecret != nil {
-		event.ClientSecret = clientSecret
-		hasChanged = true
-	}
-
-	if idpDisplayNameMapping.Valid() && idpDisplayNameMapping != current.IDPDisplayNameMapping {
-		event.IDPDisplayNameMapping = idpDisplayNameMapping
-		hasChanged = true
-	}
-
-	if userNameMapping.Valid() && userNameMapping != current.UserNameMapping {
-		event.UserNameMapping = userNameMapping
-		hasChanged = true
-	}
-
-	if len(scopes) > 0 {
-		sort.Strings(scopes)
-		sort.Strings(current.Scopes)
-		if !reflect.DeepEqual(scopes, current.Scopes) {
-			event.Scopes = scopes
-			hasChanged = true
-		}
-	}
-
-	if !hasChanged {
-		return nil, errors.ThrowPreconditionFailed(nil, "OIDC-zPDOL", "Errors.NoChanges")
-	}
-
-	return event, nil
-}
-
-func ConfigChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ConfigChangedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
-	}
-
-	return e, nil
-}

internal/v2/repository/idp/oidc/mapping_field.go

@@ -1,14 +0,0 @@
-package oidc
-
-type MappingField int32
-
-const (
-	MappingFieldPreferredLoginName MappingField = iota + 1
-	MappingFieldEmail
-	// count is for validation purposes
-	mappingFieldCount
-)
-
-func (f MappingField) Valid() bool {
-	return f > 0 && f < mappingFieldCount
-}

internal/v2/repository/idpconfig/idp_config.go

@@ -0,0 +1,187 @@
+package idpconfig
+
+import (
+	"encoding/json"
+	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/domain"
+)
+
+type IDPConfigAddedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	ConfigID    string                      `json:"idpConfigId"`
+	Name        string                      `json:"name,omitempty"`
+	Typ         domain.IDPConfigType        `json:"idpType,omitempty"`
+	StylingType domain.IDPConfigStylingType `json:"stylingType,omitempty"`
+}
+
+func NewIDPConfigAddedEvent(
+	base *eventstore.BaseEvent,
+	configID string,
+	name string,
+	configType domain.IDPConfigType,
+	stylingType domain.IDPConfigStylingType,
+) *IDPConfigAddedEvent {
+
+	return &IDPConfigAddedEvent{
+		BaseEvent:   *base,
+		ConfigID:    configID,
+		Name:        name,
+		StylingType: stylingType,
+		Typ:         configType,
+	}
+}
+
+func (e *IDPConfigAddedEvent) Data() interface{} {
+	return e
+}
+
+func IDPConfigAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &IDPConfigAddedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
+	}
+
+	return e, nil
+}
+
+type IDPConfigChangedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	ConfigID    string                      `json:"idpConfigId"`
+	Name        string                      `json:"name,omitempty"`
+	StylingType domain.IDPConfigStylingType `json:"stylingType,omitempty"`
+}
+
+func (e *IDPConfigChangedEvent) Data() interface{} {
+	return e
+}
+
+func NewIDPConfigChangedEvent(
+	base *eventstore.BaseEvent,
+) *IDPConfigChangedEvent {
+	return &IDPConfigChangedEvent{
+		BaseEvent: *base,
+	}
+}
+
+func IDPConfigChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &IDPConfigChangedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
+	}
+
+	return e, nil
+}
+
+type IDPConfigDeactivatedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	ConfigID string `idpConfigId`
+}
+
+func NewIDPConfigDeactivatedEvent(
+	base *eventstore.BaseEvent,
+	configID string,
+) *IDPConfigDeactivatedEvent {
+
+	return &IDPConfigDeactivatedEvent{
+		BaseEvent: *base,
+		ConfigID:  configID,
+	}
+}
+
+func (e *IDPConfigDeactivatedEvent) Data() interface{} {
+	return e
+}
+
+func IDPConfigDeactivatedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &IDPConfigDeactivatedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
+	}
+
+	return e, nil
+}
+
+type IDPConfigReactivatedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	ConfigID string `idpConfigId`
+}
+
+func NewIDPConfigReactivatedEvent(
+	base *eventstore.BaseEvent,
+	configID string,
+) *IDPConfigReactivatedEvent {
+
+	return &IDPConfigReactivatedEvent{
+		BaseEvent: *base,
+		ConfigID:  configID,
+	}
+}
+
+func (e *IDPConfigReactivatedEvent) Data() interface{} {
+	return e
+}
+
+func IDPConfigReactivatedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &IDPConfigReactivatedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
+	}
+
+	return e, nil
+}
+
+type IDPConfigRemovedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	ConfigID string `idpConfigId`
+}
+
+func NewIDPConfigRemovedEvent(
+	base *eventstore.BaseEvent,
+	configID string,
+) *IDPConfigRemovedEvent {
+
+	return &IDPConfigRemovedEvent{
+		BaseEvent: *base,
+		ConfigID:  configID,
+	}
+}
+
+func (e *IDPConfigRemovedEvent) Data() interface{} {
+	return e
+}
+
+func IDPConfigRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &IDPConfigRemovedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
+	}
+
+	return e, nil
+}

internal/v2/repository/idpconfig/oidc_config.go

@@ -0,0 +1,107 @@
+package idpconfig
+
+import (
+	"encoding/json"
+	"github.com/caos/zitadel/internal/crypto"
+	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/domain"
+)
+
+const (
+	OIDCConfigAddedEventType eventstore.EventType = "oidc.config.added"
+	ConfigChangedEventType   eventstore.EventType = "oidc.config.changed"
+)
+
+type OIDCConfigAddedEvent struct {
+	eventstore.BaseEvent
+
+	IDPConfigID  string              `json:"idpConfigId"`
+	ClientID     string              `json:"clientId,omitempty"`
+	ClientSecret *crypto.CryptoValue `json:"clientSecret,omitempty"`
+	Issuer       string              `json:"issuer,omitempty"`
+	Scopes       []string            `json:"scpoes,omitempty"`
+
+	IDPDisplayNameMapping domain.OIDCMappingField `json:"idpDisplayNameMapping,omitempty"`
+	UserNameMapping       domain.OIDCMappingField `json:"usernameMapping,omitempty"`
+}
+
+func (e *OIDCConfigAddedEvent) Data() interface{} {
+	return e
+}
+
+func NewOIDCConfigAddedEvent(
+	base *eventstore.BaseEvent,
+	clientID,
+	idpConfigID,
+	issuer string,
+	clientSecret *crypto.CryptoValue,
+	idpDisplayNameMapping,
+	userNameMapping domain.OIDCMappingField,
+	scopes ...string,
+) *OIDCConfigAddedEvent {
+
+	return &OIDCConfigAddedEvent{
+		BaseEvent:             *base,
+		IDPConfigID:           idpConfigID,
+		ClientID:              clientID,
+		ClientSecret:          clientSecret,
+		Issuer:                issuer,
+		Scopes:                scopes,
+		IDPDisplayNameMapping: idpDisplayNameMapping,
+		UserNameMapping:       userNameMapping,
+	}
+}
+
+func OIDCConfigAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &OIDCConfigAddedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
+	}
+
+	return e, nil
+}
+
+type OIDCConfigChangedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	IDPConfigID string `json:"idpConfigId"`
+
+	ClientID     string              `json:"clientId,omitempty"`
+	ClientSecret *crypto.CryptoValue `json:"clientSecret,omitempty"`
+	Issuer       string              `json:"issuer,omitempty"`
+	Scopes       []string            `json:"scpoes,omitempty"`
+
+	IDPDisplayNameMapping domain.OIDCMappingField `json:"idpDisplayNameMapping,omitempty"`
+	UserNameMapping       domain.OIDCMappingField `json:"usernameMapping,omitempty"`
+}
+
+func (e *OIDCConfigChangedEvent) Data() interface{} {
+	return e
+}
+
+func NewOIDCConfigChangedEvent(
+	base *eventstore.BaseEvent,
+) *OIDCConfigChangedEvent {
+	return &OIDCConfigChangedEvent{
+		BaseEvent: *base,
+	}
+}
+
+func OIDCConfigChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &OIDCConfigChangedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "OIDC-plaBZ", "unable to unmarshal event")
+	}
+
+	return e, nil
+}

internal/v2/repository/member/event_added.go

@@ -1,50 +0,0 @@
-package member
-
-import (
-	"encoding/json"
-
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	es_repo "github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-const (
-	AddedEventType = "member.added"
-)
-
-type AddedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	Roles  []string `json:"roles"`
-	UserID string   `json:"userId"`
-}
-
-func (e *AddedEvent) Data() interface{} {
-	return e
-}
-
-func NewAddedEvent(
-	base *eventstore.BaseEvent,
-	userID string,
-	roles ...string,
-) *AddedEvent {
-
-	return &AddedEvent{
-		BaseEvent: *base,
-		Roles:     roles,
-		UserID:    userID,
-	}
-}
-
-func AddedEventMapper(event *es_repo.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "POLIC-puqv4", "unable to unmarshal label policy")
-	}
-
-	return e, nil
-}

internal/v2/repository/member/event_changed.go

@@ -1,75 +0,0 @@
-package member
-
-import (
-	"encoding/json"
-	"reflect"
-	"sort"
-
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-const (
-	ChangedEventType = "member.changed"
-)
-
-type ChangedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	Roles  []string `json:"roles,omitempty"`
-	UserID string   `json:"userId,omitempty"`
-}
-
-func (e *ChangedEvent) Data() interface{} {
-	return e
-}
-
-func ChangeEventFromExisting(
-	base *eventstore.BaseEvent,
-	current *WriteModel,
-	roles ...string,
-) (*ChangedEvent, error) {
-
-	change := NewChangedEvent(base, current.UserID)
-	hasChanged := false
-
-	sort.Strings(current.Roles)
-	sort.Strings(roles)
-	if !reflect.DeepEqual(current.Roles, roles) {
-		change.Roles = roles
-		hasChanged = true
-	}
-
-	if !hasChanged {
-		return nil, errors.ThrowPreconditionFailed(nil, "MEMBE-SeKlD", "Errors.NoChanges")
-	}
-
-	return change, nil
-}
-
-func NewChangedEvent(
-	base *eventstore.BaseEvent,
-	userID string,
-	roles ...string,
-) *ChangedEvent {
-
-	return &ChangedEvent{
-		BaseEvent: *base,
-		UserID:    userID,
-		Roles:     roles,
-	}
-}
-
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "POLIC-puqv4", "unable to unmarshal label policy")
-	}
-
-	return e, nil
-}

internal/v2/repository/member/event_removed.go

@@ -1,47 +0,0 @@
-package member
-
-import (
-	"encoding/json"
-
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-const (
-	RemovedEventType = "member.removed"
-)
-
-type RemovedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	UserID string `json:"userId"`
-}
-
-func (e *RemovedEvent) Data() interface{} {
-	return e
-}
-
-func NewRemovedEvent(
-	base *eventstore.BaseEvent,
-	userID string,
-) *RemovedEvent {
-
-	return &RemovedEvent{
-		BaseEvent: *base,
-		UserID:    userID,
-	}
-}
-
-func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &RemovedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "POLIC-Ep4ip", "unable to unmarshal label policy")
-	}
-
-	return e, nil
-}

internal/v2/repository/member/events.go

@@ -0,0 +1,121 @@
+package member
+
+import (
+	"encoding/json"
+	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+)
+
+const (
+	AddedEventType   = "member.added"
+	ChangedEventType = "member.changed"
+	RemovedEventType = "member.removed"
+)
+
+type MemberAddedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	Roles  []string `json:"roles"`
+	UserID string   `json:"userId"`
+}
+
+func (e *MemberAddedEvent) Data() interface{} {
+	return e
+}
+
+func NewMemberAddedEvent(
+	base *eventstore.BaseEvent,
+	userID string,
+	roles ...string,
+) *MemberAddedEvent {
+
+	return &MemberAddedEvent{
+		BaseEvent: *base,
+		Roles:     roles,
+		UserID:    userID,
+	}
+}
+
+func MemberAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &MemberAddedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "POLIC-puqv4", "unable to unmarshal label policy")
+	}
+
+	return e, nil
+}
+
+type MemberChangedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	Roles  []string `json:"roles,omitempty"`
+	UserID string   `json:"userId,omitempty"`
+}
+
+func (e *MemberChangedEvent) Data() interface{} {
+	return e
+}
+
+func NewMemberChangedEvent(
+	base *eventstore.BaseEvent,
+	userID string,
+	roles ...string,
+) *MemberChangedEvent {
+	return &MemberChangedEvent{
+		BaseEvent: *base,
+		Roles:     roles,
+		UserID:    userID,
+	}
+}
+
+func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &MemberChangedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "POLIC-puqv4", "unable to unmarshal label policy")
+	}
+
+	return e, nil
+}
+
+type MemberRemovedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	UserID string `json:"userId"`
+}
+
+func (e *MemberRemovedEvent) Data() interface{} {
+	return e
+}
+
+func NewRemovedEvent(
+	base *eventstore.BaseEvent,
+	userID string,
+) *MemberRemovedEvent {
+
+	return &MemberRemovedEvent{
+		BaseEvent: *base,
+		UserID:    userID,
+	}
+}
+
+func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &MemberRemovedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "POLIC-Ep4ip", "unable to unmarshal label policy")
+	}
+
+	return e, nil
+}

internal/v2/repository/member/read_model.go

@@ -1,32 +0,0 @@
-package member
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-//ReadModel represenets the default member view.
-// It's computed from events.
-type ReadModel struct {
-	eventstore.ReadModel
-
-	UserID string
-	Roles  []string
-}
-
-//NewReadModel is the default constructor of ReadModel
-func NewReadModel(userID string) *ReadModel {
-	return &ReadModel{
-		UserID: userID,
-	}
-}
-
-//Reduce extends eventstore.ReadModel
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.Roles = e.Roles
-		case *ChangedEvent:
-			rm.Roles = e.Roles
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/member/write_model.go

@@ -1,43 +0,0 @@
-package member
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-//WriteModel is used to create events
-// It has no computed fields and represents the data
-// which can be changed
-type WriteModel struct {
-	eventstore.WriteModel
-
-	UserID   string
-	Roles    []string
-	IsActive bool
-}
-
-func NewWriteModel(userID string) *WriteModel {
-	return &WriteModel{
-		UserID: userID,
-	}
-}
-
-//Reduce extends eventstore.ReadModel
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.UserID = e.UserID
-			wm.Roles = e.Roles
-			wm.IsActive = true
-		case *ChangedEvent:
-			wm.Roles = e.Roles
-		case *RemovedEvent:
-			wm.Roles = nil
-			wm.IsActive = false
-		}
-	}
-	return wm.WriteModel.Reduce()
-}
-
-// func (wm *WriteModel) Query() *eventstore.SearchQueryFactory {
-// 	return eventstore.NewSearchQueryFactory(eventstore.ColumnsEvent, wm.aggregateType).
-// 		AggregateIDs(wm.aggregateID)
-// }

internal/v2/repository/members/read_models.go

@@ -1,53 +0,0 @@
-package members
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/member"
-)
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	Members []*member.ReadModel
-}
-
-func (rm *ReadModel) MemberByUserID(id string) (idx int, member *member.ReadModel) {
-	for idx, member = range rm.Members {
-		if member.UserID == id {
-			return idx, member
-		}
-	}
-	return -1, nil
-}
-
-func (rm *ReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *member.AddedEvent:
-			m := member.NewReadModel(e.UserID)
-			rm.Members = append(rm.Members, m)
-			m.AppendEvents(e)
-		case *member.ChangedEvent:
-			_, m := rm.MemberByUserID(e.UserID)
-			m.AppendEvents(e)
-		case *member.RemovedEvent:
-			idx, _ := rm.MemberByUserID(e.UserID)
-			if idx < 0 {
-				continue
-			}
-			copy(rm.Members[idx:], rm.Members[idx+1:])
-			rm.Members[len(rm.Members)-1] = nil
-			rm.Members = rm.Members[:len(rm.Members)-1]
-		}
-	}
-}
-
-func (rm *ReadModel) Reduce() (err error) {
-	for _, m := range rm.Members {
-		err = m.Reduce()
-		if err != nil {
-			return err
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/org/aggregate.go

@@ -0,0 +1,35 @@
+package org
+
+import (
+	"github.com/caos/zitadel/internal/eventstore/v2"
+)
+
+const (
+	iamEventTypePrefix = eventstore.EventType("org.")
+)
+
+const (
+	AggregateType    = "org"
+	AggregateVersion = "v1"
+)
+
+type Aggregate struct {
+	eventstore.Aggregate
+}
+
+func NewAggregate(
+	id,
+	resourceOwner string,
+	previousSequence uint64,
+) *Aggregate {
+
+	return &Aggregate{
+		Aggregate: *eventstore.NewAggregate(
+			id,
+			AggregateType,
+			resourceOwner,
+			AggregateVersion,
+			previousSequence,
+		),
+	}
+}

internal/v2/repository/org/member.go

@@ -2,10 +2,8 @@ package org
 
 import (
 	"context"
-
 	"github.com/caos/zitadel/internal/eventstore/v2"
 	"github.com/caos/zitadel/internal/v2/repository/member"
-	"github.com/caos/zitadel/internal/v2/repository/members"
 )
 
 const (
@@ -18,58 +16,8 @@ var (
 	MemberRemovedEventType = orgEventTypePrefix + member.RemovedEventType
 )
 
-type MemberWriteModel struct {
-	member.WriteModel
-}
-
-// func NewMemberAggregate(userID string) *MemberAggregate {
-// 	return &MemberAggregate{
-// 		Aggregate: member.NewAggregate(
-// 			eventstore.NewAggregate(userID, MemberAggregateType, "RO", AggregateVersion, 0),
-// 		),
-// 		// Aggregate: member.NewMemberAggregate(userID),
-// 	}
-// }
-
-type MembersReadModel struct {
-	members.ReadModel
-}
-
-func (rm *MembersReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *MemberAddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *MemberChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *MemberRemovedEvent:
-			rm.ReadModel.AppendEvents(&e.RemovedEvent)
-		}
-	}
-}
-
-type MemberReadModel member.ReadModel
-
-func (rm *MemberReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *MemberAddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *MemberChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		}
-	}
-}
-
 type MemberAddedEvent struct {
-	member.AddedEvent
-}
-
-type MemberChangedEvent struct {
-	member.ChangedEvent
-}
-type MemberRemovedEvent struct {
-	member.RemovedEvent
+	member.MemberAddedEvent
 }
 
 func NewMemberAddedEvent(
@@ -77,9 +25,8 @@ func NewMemberAddedEvent(
 	userID string,
 	roles ...string,
 ) *MemberAddedEvent {
-
 	return &MemberAddedEvent{
-		AddedEvent: *member.NewAddedEvent(
+		MemberAddedEvent: *member.NewMemberAddedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				MemberAddedEventType,
@@ -90,27 +37,8 @@ func NewMemberAddedEvent(
 	}
 }
 
-func MemberChangedEventFromExisting(
-	ctx context.Context,
-	current *MemberWriteModel,
-	roles ...string,
-) (*MemberChangedEvent, error) {
-
-	m, err := member.ChangeEventFromExisting(
-		eventstore.NewBaseEventForPush(
-			ctx,
-			MemberChangedEventType,
-		),
-		&current.WriteModel,
-		roles...,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return &MemberChangedEvent{
-		ChangedEvent: *m,
-	}, nil
+type MemberChangedEvent struct {
+	member.MemberChangedEvent
 }
 
 func NewMemberChangedEvent(
@@ -120,7 +48,7 @@ func NewMemberChangedEvent(
 ) *MemberChangedEvent {
 
 	return &MemberChangedEvent{
-		ChangedEvent: *member.NewChangedEvent(
+		MemberChangedEvent: *member.NewMemberChangedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				MemberChangedEventType,
@@ -131,13 +59,17 @@ func NewMemberChangedEvent(
 	}
 }
 
+type MemberRemovedEvent struct {
+	member.MemberRemovedEvent
+}
+
 func NewMemberRemovedEvent(
 	ctx context.Context,
 	userID string,
 ) *MemberRemovedEvent {
 
 	return &MemberRemovedEvent{
-		RemovedEvent: *member.NewRemovedEvent(
+		MemberRemovedEvent: *member.NewRemovedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				MemberRemovedEventType,

internal/v2/repository/org/policy_label.go

@@ -1,64 +1,18 @@
 package org
 
 import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/label"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
 )
 
 var (
-	LabelPolicyAddedEventType   = orgEventTypePrefix + label.LabelPolicyAddedEventType
-	LabelPolicyChangedEventType = orgEventTypePrefix + label.LabelPolicyChangedEventType
+	LabelPolicyAddedEventType   = orgEventTypePrefix + policy.LabelPolicyAddedEventType
+	LabelPolicyChangedEventType = orgEventTypePrefix + policy.LabelPolicyChangedEventType
 )
 
-type LabelPolicyReadModel struct{ label.ReadModel }
-
-func (rm *LabelPolicyReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *LabelPolicyAddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *LabelPolicyChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *label.AddedEvent, *label.ChangedEvent:
-			rm.ReadModel.AppendEvents(e)
-		}
-	}
-}
-
 type LabelPolicyAddedEvent struct {
-	label.AddedEvent
+	policy.LabelPolicyAddedEvent
 }
 
 type LabelPolicyChangedEvent struct {
-	label.ChangedEvent
+	policy.LabelPolicyChangedEvent
 }
-
-// func NewAddedEvent(
-// 	ctx context.Context,
-// 	primaryColor,
-// 	secondaryColor string,
-// ) *AddedEvent {
-
-// 	return &AddedEvent{
-// 		AddedEvent: *policy.NewAddedEvent(
-// 			ctx,
-// 			primaryColor,
-// 			secondaryColor,
-// 		),
-// 	}
-// }
-
-// func NewChangedEvent(
-// 	ctx context.Context,
-// 	primaryColor,
-// 	secondaryColor string,
-// ) *MemberChangedEvent {
-
-// 	return &ChangedEvent{
-// 		ChangedEvent: *policy.NewChangedEvent(
-// 			ctx,
-// 			primaryColor,
-// 			secondaryColor,
-// 		),
-// 	}
-// }

internal/v2/repository/org/policy_login.go

@@ -1,34 +1,18 @@
 package org
 
 import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
 )
 
 var (
-	LoginPolicyAddedEventType   = orgEventTypePrefix + login.LoginPolicyAddedEventType
-	LoginPolicyChangedEventType = orgEventTypePrefix + login.LoginPolicyChangedEventType
+	LoginPolicyAddedEventType   = orgEventTypePrefix + policy.LoginPolicyAddedEventType
+	LoginPolicyChangedEventType = orgEventTypePrefix + policy.LoginPolicyChangedEventType
 )
 
-type LoginPolicyReadModel struct{ login.ReadModel }
-
-func (rm *LoginPolicyReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *LoginPolicyAddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *LoginPolicyChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *login.AddedEvent, *login.ChangedEvent:
-			rm.ReadModel.AppendEvents(e)
-		}
-	}
-}
-
 type LoginPolicyAddedEvent struct {
-	login.AddedEvent
+	policy.LoginPolicyAddedEvent
 }
 
 type LoginPolicyChangedEvent struct {
-	login.ChangedEvent
+	policy.LoginPolicyChangedEvent
 }

internal/v2/repository/org/policy_org_iam.go

@@ -1,27 +1,40 @@
 package org
 
 import (
+	"context"
 	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/org_iam"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
 )
 
 var (
-	OrgIAMPolicyAddedEventType = orgEventTypePrefix + org_iam.OrgIAMPolicyAddedEventType
+	OrgIAMPolicyAddedEventType   = orgEventTypePrefix + policy.OrgIAMPolicyAddedEventType
+	OrgIAMPolicyChangedEventType = orgEventTypePrefix + policy.OrgIAMPolicyChangedEventType
 )
 
-type OrgIAMPolicyReadModel struct{ org_iam.ReadModel }
+type OrgIAMPolicyAddedEvent struct {
+	policy.OrgIAMPolicyAddedEvent
+}
 
-func (rm *OrgIAMPolicyReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *OrgIAMPolicyAddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *org_iam.AddedEvent:
-			rm.ReadModel.AppendEvents(e)
-		}
+type OrgIAMPolicyChangedEvent struct {
+	policy.OrgIAMPolicyChangedEvent
+}
+
+func NewOrgIAMPolicyChangedEvent(
+	ctx context.Context,
+) *OrgIAMPolicyChangedEvent {
+	return &OrgIAMPolicyChangedEvent{
+		OrgIAMPolicyChangedEvent: *policy.NewOrgIAMPolicyChangedEvent(
+			eventstore.NewBaseEventForPush(ctx, OrgIAMPolicyChangedEventType),
+		),
 	}
 }
 
-type OrgIAMPolicyAddedEvent struct {
-	org_iam.AddedEvent
+func OrgIAMPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.OrgIAMPolicyChangedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &OrgIAMPolicyChangedEvent{OrgIAMPolicyChangedEvent: *e.(*policy.OrgIAMPolicyChangedEvent)}, nil
 }

internal/v2/repository/org/policy_password_age.go

@@ -1,36 +1,18 @@
 package org
 
 import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_age"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
 )
 
 var (
-	PasswordAgePolicyAddedEventType   = orgEventTypePrefix + password_age.PasswordAgePolicyAddedEventType
-	PasswordAgePolicyChangedEventType = orgEventTypePrefix + password_age.PasswordAgePolicyChangedEventType
+	PasswordAgePolicyAddedEventType   = orgEventTypePrefix + policy.PasswordAgePolicyAddedEventType
+	PasswordAgePolicyChangedEventType = orgEventTypePrefix + policy.PasswordAgePolicyChangedEventType
 )
 
-type PasswordAgePolicyReadModel struct {
-	password_age.ReadModel
-}
-
-func (rm *PasswordAgePolicyReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *PasswordAgePolicyAddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *PasswordAgePolicyChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *password_age.AddedEvent, *password_age.ChangedEvent:
-			rm.ReadModel.AppendEvents(e)
-		}
-	}
-}
-
 type PasswordAgePolicyAddedEvent struct {
-	password_age.AddedEvent
+	policy.PasswordAgePolicyAddedEvent
 }
 
 type PasswordAgePolicyChangedEvent struct {
-	password_age.ChangedEvent
+	policy.PasswordAgePolicyChangedEvent
 }

internal/v2/repository/org/policy_password_complexity.go

@@ -1,36 +1,68 @@
 package org
 
 import (
+	"context"
 	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_complexity"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
 )
 
 var (
-	PasswordComplexityPolicyAddedEventType   = orgEventTypePrefix + password_complexity.PasswordComplexityPolicyAddedEventType
-	PasswordComplexityPolicyChangedEventType = orgEventTypePrefix + password_complexity.PasswordComplexityPolicyChangedEventType
+	PasswordComplexityPolicyAddedEventType   = orgEventTypePrefix + policy.PasswordComplexityPolicyAddedEventType
+	PasswordComplexityPolicyChangedEventType = orgEventTypePrefix + policy.PasswordComplexityPolicyChangedEventType
 )
 
-type PasswordComplexityPolicyReadModel struct {
-	password_complexity.ReadModel
+type PasswordComplexityPolicyAddedEvent struct {
+	policy.PasswordComplexityPolicyAddedEvent
 }
 
-func (rm *PasswordComplexityPolicyReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *PasswordComplexityPolicyAddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *PasswordComplexityPolicyChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *password_complexity.AddedEvent, *password_complexity.ChangedEvent:
-			rm.ReadModel.AppendEvents(e)
-		}
+func NewPasswordComplexityPolicyAddedEvent(
+	ctx context.Context,
+	minLength uint64,
+	hasLowercase,
+	hasUppercase,
+	hasNumber,
+	hasSymbol bool,
+) *PasswordComplexityPolicyAddedEvent {
+	return &PasswordComplexityPolicyAddedEvent{
+		PasswordComplexityPolicyAddedEvent: *policy.NewPasswordComplexityPolicyAddedEvent(
+			eventstore.NewBaseEventForPush(ctx, PasswordComplexityPolicyAddedEventType),
+			minLength,
+			hasLowercase,
+			hasUppercase,
+			hasNumber,
+			hasSymbol),
 	}
 }
 
-type PasswordComplexityPolicyAddedEvent struct {
-	password_complexity.AddedEvent
+func PasswordComplexityPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.PasswordComplexityPolicyAddedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &PasswordComplexityPolicyAddedEvent{PasswordComplexityPolicyAddedEvent: *e.(*policy.PasswordComplexityPolicyAddedEvent)}, nil
 }
 
 type PasswordComplexityPolicyChangedEvent struct {
-	password_complexity.ChangedEvent
+	policy.PasswordComplexityPolicyChangedEvent
+}
+
+func NewPasswordComplexityPolicyChangedEvent(
+	ctx context.Context,
+) *PasswordComplexityPolicyChangedEvent {
+	return &PasswordComplexityPolicyChangedEvent{
+		PasswordComplexityPolicyChangedEvent: *policy.NewPasswordComplexityPolicyChangedEvent(
+			eventstore.NewBaseEventForPush(ctx, PasswordComplexityPolicyAddedEventType),
+		),
+	}
+}
+
+func PasswordComplexityPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e, err := policy.PasswordComplexityPolicyChangedEventMapper(event)
+	if err != nil {
+		return nil, err
+	}
+
+	return &PasswordComplexityPolicyChangedEvent{PasswordComplexityPolicyChangedEvent: *e.(*policy.PasswordComplexityPolicyChangedEvent)}, nil
 }

internal/v2/repository/org/policy_password_lockout.go

@@ -1,36 +1,18 @@
 package org
 
 import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/policy/password_lockout"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
 )
 
 var (
-	PasswordLockoutPolicyAddedEventType   = orgEventTypePrefix + password_lockout.PasswordLockoutPolicyAddedEventType
-	PasswordLockoutPolicyChangedEventType = orgEventTypePrefix + password_lockout.PasswordLockoutPolicyChangedEventType
+	PasswordLockoutPolicyAddedEventType   = orgEventTypePrefix + policy.PasswordLockoutPolicyAddedEventType
+	PasswordLockoutPolicyChangedEventType = orgEventTypePrefix + policy.PasswordLockoutPolicyChangedEventType
 )
 
-type PasswordLockoutPolicyReadModel struct {
-	password_lockout.ReadModel
-}
-
-func (rm *PasswordLockoutPolicyReadModel) AppendEvents(events ...eventstore.EventReader) {
-	for _, event := range events {
-		switch e := event.(type) {
-		case *PasswordLockoutPolicyAddedEvent:
-			rm.ReadModel.AppendEvents(&e.AddedEvent)
-		case *PasswordLockoutPolicyChangedEvent:
-			rm.ReadModel.AppendEvents(&e.ChangedEvent)
-		case *password_lockout.AddedEvent, *password_lockout.ChangedEvent:
-			rm.ReadModel.AppendEvents(e)
-		}
-	}
-}
-
 type PasswordLockoutPolicyAddedEvent struct {
-	password_lockout.AddedEvent
+	policy.PasswordLockoutPolicyAddedEvent
 }
 
 type PasswordLockoutPolicyChangedEvent struct {
-	password_lockout.ChangedEvent
+	policy.PasswordLockoutPolicyChangedEvent
 }

internal/v2/repository/policy/label.go

@@ -1,4 +1,4 @@
-package label
+package policy
 
 import (
 	"encoding/json"
@@ -13,32 +13,32 @@ const (
 	LabelPolicyRemovedEventType = "policy.label.removed"
 )
 
-type AddedEvent struct {
+type LabelPolicyAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	PrimaryColor   string `json:"primaryColor,omitempty"`
 	SecondaryColor string `json:"secondaryColor,omitempty"`
 }
 
-func (e *AddedEvent) Data() interface{} {
+func (e *LabelPolicyAddedEvent) Data() interface{} {
 	return e
 }
 
-func NewAddedEvent(
+func NewLabelPolicyAddedEvent(
 	base *eventstore.BaseEvent,
 	primaryColor,
 	secondaryColor string,
-) *AddedEvent {
+) *LabelPolicyAddedEvent {
 
-	return &AddedEvent{
+	return &LabelPolicyAddedEvent{
 		BaseEvent:      *base,
 		PrimaryColor:   primaryColor,
 		SecondaryColor: secondaryColor,
 	}
 }
 
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
+func LabelPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &LabelPolicyAddedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -50,39 +50,27 @@ func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
 	return e, nil
 }
 
-type ChangedEvent struct {
+type LabelPolicyChangedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	PrimaryColor   string `json:"primaryColor,omitempty"`
 	SecondaryColor string `json:"secondaryColor,omitempty"`
 }
 
-func (e *ChangedEvent) Data() interface{} {
+func (e *LabelPolicyChangedEvent) Data() interface{} {
 	return e
 }
 
-func NewChangedEvent(
+func NewLabelPolicyChangedEvent(
 	base *eventstore.BaseEvent,
-	current *WriteModel,
-	primaryColor,
-	secondaryColor string,
-) *ChangedEvent {
-
-	e := &ChangedEvent{
+) *LabelPolicyChangedEvent {
+	return &LabelPolicyChangedEvent{
 		BaseEvent: *base,
 	}
-	if primaryColor != "" && current.PrimaryColor != primaryColor {
-		e.PrimaryColor = primaryColor
-	}
-	if secondaryColor != "" && current.SecondaryColor != secondaryColor {
-		e.SecondaryColor = secondaryColor
-	}
-
-	return e
 }
 
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
+func LabelPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &LabelPolicyChangedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -94,22 +82,22 @@ func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error)
 	return e, nil
 }
 
-type RemovedEvent struct {
+type LabelPolicyRemovedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 }
 
-func (e *RemovedEvent) Data() interface{} {
+func (e *LabelPolicyRemovedEvent) Data() interface{} {
 	return nil
 }
 
-func NewRemovedEvent(base *eventstore.BaseEvent) *RemovedEvent {
-	return &RemovedEvent{
+func NewRemovedEvent(base *eventstore.BaseEvent) *LabelPolicyRemovedEvent {
+	return &LabelPolicyRemovedEvent{
 		BaseEvent: *base,
 	}
 }
 
 func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	return &RemovedEvent{
+	return &LabelPolicyRemovedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}, nil
 }

internal/v2/repository/policy/label/read_model.go

@@ -1,24 +0,0 @@
-package label
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	PrimaryColor   string
-	SecondaryColor string
-}
-
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.PrimaryColor = e.PrimaryColor
-			rm.SecondaryColor = e.SecondaryColor
-		case *ChangedEvent:
-			rm.PrimaryColor = e.PrimaryColor
-			rm.SecondaryColor = e.SecondaryColor
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/policy/label/write_model.go

@@ -1,26 +0,0 @@
-package label
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	PrimaryColor   string
-	SecondaryColor string
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.PrimaryColor = e.PrimaryColor
-			wm.SecondaryColor = e.SecondaryColor
-		case *ChangedEvent:
-			wm.PrimaryColor = e.PrimaryColor
-			wm.SecondaryColor = e.SecondaryColor
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/login.go

@@ -0,0 +1,119 @@
+package policy
+
+import (
+	"encoding/json"
+	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/domain"
+)
+
+const (
+	loginPolicyPrefix           = "policy.login."
+	LoginPolicyAddedEventType   = loginPolicyPrefix + "added"
+	LoginPolicyChangedEventType = loginPolicyPrefix + "changed"
+	LoginPolicyRemovedEventType = loginPolicyPrefix + "removed"
+)
+
+type LoginPolicyAddedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	AllowUserNamePassword bool                    `json:"allowUsernamePassword"`
+	AllowRegister         bool                    `json:"allowRegister"`
+	AllowExternalIDP      bool                    `json:"allowExternalIdp"`
+	ForceMFA              bool                    `json:"forceMFA"`
+	PasswordlessType      domain.PasswordlessType `json:"passwordlessType"`
+}
+
+func (e *LoginPolicyAddedEvent) Data() interface{} {
+	return e
+}
+
+func NewLoginPolicyAddedEvent(
+	base *eventstore.BaseEvent,
+	allowUserNamePassword,
+	allowRegister,
+	allowExternalIDP,
+	forceMFA bool,
+	passwordlessType domain.PasswordlessType,
+) *LoginPolicyAddedEvent {
+	return &LoginPolicyAddedEvent{
+		BaseEvent:             *base,
+		AllowExternalIDP:      allowExternalIDP,
+		AllowRegister:         allowRegister,
+		AllowUserNamePassword: allowUserNamePassword,
+		ForceMFA:              forceMFA,
+		PasswordlessType:      passwordlessType,
+	}
+}
+
+func LoginPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &LoginPolicyAddedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "POLIC-nWndT", "unable to unmarshal policy")
+	}
+
+	return e, nil
+}
+
+type LoginPolicyChangedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	AllowUserNamePassword bool                    `json:"allowUsernamePassword,omitempty"`
+	AllowRegister         bool                    `json:"allowRegister"`
+	AllowExternalIDP      bool                    `json:"allowExternalIdp"`
+	ForceMFA              bool                    `json:"forceMFA"`
+	PasswordlessType      domain.PasswordlessType `json:"passwordlessType"`
+}
+
+type LoginPolicyEventData struct {
+}
+
+func (e *LoginPolicyChangedEvent) Data() interface{} {
+	return e
+}
+
+func NewLoginPolicyChangedEvent(
+	base *eventstore.BaseEvent,
+) *LoginPolicyChangedEvent {
+	return &LoginPolicyChangedEvent{
+		BaseEvent: *base,
+	}
+}
+
+func LoginPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &LoginPolicyChangedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "POLIC-ehssl", "unable to unmarshal policy")
+	}
+
+	return e, nil
+}
+
+type LoginPolicyRemovedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+}
+
+func (e *LoginPolicyRemovedEvent) Data() interface{} {
+	return nil
+}
+
+func NewLoginPolicyRemovedEvent(base *eventstore.BaseEvent) *LoginPolicyRemovedEvent {
+	return &LoginPolicyRemovedEvent{
+		BaseEvent: *base,
+	}
+}
+
+func LoginPolicyRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	return &LoginPolicyRemovedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}, nil
+}

internal/v2/repository/policy/login/events.go

@@ -1,143 +0,0 @@
-package login
-
-import (
-	"encoding/json"
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login/idpprovider"
-)
-
-const (
-	loginPolicyPrefix                      = "policy.login."
-	LoginPolicyAddedEventType              = loginPolicyPrefix + "added"
-	LoginPolicyChangedEventType            = loginPolicyPrefix + "changed"
-	LoginPolicyRemovedEventType            = loginPolicyPrefix + "removed"
-	LoginPolicyIDPProviderAddedEventType   = loginPolicyPrefix + idpprovider.AddedEventType
-	LoginPolicyIDPProviderRemovedEventType = loginPolicyPrefix + idpprovider.RemovedEventType
-)
-
-type AddedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	AllowUserNamePassword bool             `json:"allowUsernamePassword"`
-	AllowRegister         bool             `json:"allowRegister"`
-	AllowExternalIDP      bool             `json:"allowExternalIdp"`
-	ForceMFA              bool             `json:"forceMFA"`
-	PasswordlessType      PasswordlessType `json:"passwordlessType"`
-}
-
-func (e *AddedEvent) Data() interface{} {
-	return e
-}
-
-func NewAddedEvent(
-	base *eventstore.BaseEvent,
-	allowUserNamePassword,
-	allowRegister,
-	allowExternalIDP,
-	forceMFA bool,
-	passwordlessType PasswordlessType,
-) *AddedEvent {
-	return &AddedEvent{
-		BaseEvent:             *base,
-		AllowExternalIDP:      allowExternalIDP,
-		AllowRegister:         allowRegister,
-		AllowUserNamePassword: allowUserNamePassword,
-		ForceMFA:              forceMFA,
-		PasswordlessType:      passwordlessType,
-	}
-}
-
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "POLIC-nWndT", "unable to unmarshal policy")
-	}
-
-	return e, nil
-}
-
-type ChangedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	AllowUserNamePassword bool             `json:"allowUsernamePassword,omitempty"`
-	AllowRegister         bool             `json:"allowRegister"`
-	AllowExternalIDP      bool             `json:"allowExternalIdp"`
-	ForceMFA              bool             `json:"forceMFA"`
-	PasswordlessType      PasswordlessType `json:"passwordlessType"`
-}
-
-func (e *ChangedEvent) Data() interface{} {
-	return e
-}
-
-func NewChangedEvent(
-	base *eventstore.BaseEvent,
-	current *WriteModel,
-	allowUserNamePassword,
-	allowRegister,
-	allowExternalIDP,
-	forceMFA bool,
-	passwordlessType PasswordlessType,
-) *ChangedEvent {
-
-	e := &ChangedEvent{
-		BaseEvent: *base,
-	}
-
-	if current.AllowUserNamePassword != allowUserNamePassword {
-		e.AllowUserNamePassword = allowUserNamePassword
-	}
-	if current.AllowRegister != allowRegister {
-		e.AllowRegister = allowRegister
-	}
-	if current.AllowExternalIDP != allowExternalIDP {
-		e.AllowExternalIDP = allowExternalIDP
-	}
-	if current.ForceMFA != forceMFA {
-		e.ForceMFA = forceMFA
-	}
-	if current.PasswordlessType != passwordlessType {
-		e.PasswordlessType = passwordlessType
-	}
-
-	return e
-}
-
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "POLIC-ehssl", "unable to unmarshal policy")
-	}
-
-	return e, nil
-}
-
-type RemovedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-}
-
-func (e *RemovedEvent) Data() interface{} {
-	return nil
-}
-
-func NewRemovedEvent(base *eventstore.BaseEvent) *RemovedEvent {
-	return &RemovedEvent{
-		BaseEvent: *base,
-	}
-}
-
-func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	return &RemovedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}, nil
-}

internal/v2/repository/policy/login/factors/factors.go

@@ -1,16 +0,0 @@
-package factors
-
-type SecondFactorType int32
-
-const (
-	SecondFactorTypeUnspecified SecondFactorType = iota
-	SecondFactorTypeOTP
-	SecondFactorTypeU2F
-)
-
-type MultiFactorType int32
-
-const (
-	MultiFactorTypeUnspecified MultiFactorType = iota
-	MultiFactorTypeU2FWithPIN
-)

internal/v2/repository/policy/login/factors/write_model.go

@@ -1,37 +0,0 @@
-package factors
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type SecondFactorWriteModel struct {
-	eventstore.WriteModel
-	MFAType SecondFactorType
-}
-
-func (wm *SecondFactorWriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *SecondFactorAddedEvent:
-			wm.MFAType = e.MFAType
-		case *SecondFactorRemovedEvent:
-			wm.MFAType = e.MFAType
-		}
-	}
-	return wm.WriteModel.Reduce()
-}
-
-type MultiFactoryWriteModel struct {
-	eventstore.WriteModel
-	MFAType MultiFactorType
-}
-
-func (wm *MultiFactoryWriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *MultiFactorAddedEvent:
-			wm.MFAType = e.MFAType
-		case *MultiFactorRemovedEvent:
-			wm.MFAType = e.MFAType
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/login/idpprovider/events.go

@@ -1,83 +0,0 @@
-package idpprovider
-
-import (
-	"encoding/json"
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-const (
-	AddedEventType   = "idpprovider.added"
-	RemovedEventType = "idpprovider.removed"
-)
-
-type AddedEvent struct {
-	eventstore.BaseEvent
-
-	IDPConfigID     string `json:"idpConfigId"`
-	IDPProviderType Type   `json:"idpProviderType"`
-}
-
-func (e *AddedEvent) Data() interface{} {
-	return e
-}
-
-func NewAddedEvent(
-	base *eventstore.BaseEvent,
-	idpConfigID string,
-	idpProviderType Type,
-) *AddedEvent {
-
-	return &AddedEvent{
-		*base,
-		idpConfigID,
-		idpProviderType,
-	}
-}
-
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "PROVI-bfNnp", "Errors.Internal")
-	}
-
-	return e, nil
-}
-
-type RemovedEvent struct {
-	eventstore.BaseEvent
-
-	IDPConfigID string `json:"idpConfigId"`
-}
-
-func (e *RemovedEvent) Data() interface{} {
-	return e
-}
-
-func NewRemovedEvent(
-	base *eventstore.BaseEvent,
-	idpConfigID string,
-) *RemovedEvent {
-	return &RemovedEvent{
-		BaseEvent:   *base,
-		IDPConfigID: idpConfigID,
-	}
-}
-
-func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &RemovedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "PROVI-6H0KQ", "Errors.Internal")
-	}
-
-	return e, nil
-}

internal/v2/repository/policy/login/idpprovider/provider.go

@@ -1,14 +0,0 @@
-package idpprovider
-
-type Type int8
-
-const (
-	TypeSystem Type = iota
-	TypeOrg
-
-	typeCount
-)
-
-func (f Type) Valid() bool {
-	return f >= 0 && f < typeCount
-}

internal/v2/repository/policy/login/idpprovider/write_model.go

@@ -1,23 +0,0 @@
-package idpprovider
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	IDPConfigID     string
-	IDPProviderType Type
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.IDPConfigID = e.IDPConfigID
-			wm.IDPProviderType = e.IDPProviderType
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/login/login.go

@@ -1,8 +0,0 @@
-package login
-
-type PasswordlessType int32
-
-const (
-	PasswordlessTypeNotAllowed PasswordlessType = iota
-	PasswordlessTypeAllowed
-)

internal/v2/repository/policy/login/read_model.go

@@ -1,35 +0,0 @@
-package login
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	AllowUserNamePassword bool
-	AllowRegister         bool
-	AllowExternalIDP      bool
-	ForceMFA              bool
-	PasswordlessType      PasswordlessType
-}
-
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.AllowUserNamePassword = e.AllowUserNamePassword
-			rm.AllowExternalIDP = e.AllowExternalIDP
-			rm.AllowRegister = e.AllowRegister
-			rm.ForceMFA = e.ForceMFA
-			rm.PasswordlessType = e.PasswordlessType
-		case *ChangedEvent:
-			rm.AllowUserNamePassword = e.AllowUserNamePassword
-			rm.AllowExternalIDP = e.AllowExternalIDP
-			rm.AllowRegister = e.AllowRegister
-			rm.ForceMFA = e.ForceMFA
-			rm.PasswordlessType = e.PasswordlessType
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/policy/login/write_model.go

@@ -1,35 +0,0 @@
-package login
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	AllowUserNamePassword bool
-	AllowRegister         bool
-	AllowExternalIDP      bool
-	ForceMFA              bool
-	PasswordlessType      PasswordlessType
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.AllowRegister = e.AllowRegister
-			wm.AllowUserNamePassword = e.AllowUserNamePassword
-			wm.AllowExternalIDP = e.AllowExternalIDP
-			wm.ForceMFA = e.ForceMFA
-			wm.PasswordlessType = e.PasswordlessType
-		case *ChangedEvent:
-			wm.AllowRegister = e.AllowRegister
-			wm.AllowUserNamePassword = e.AllowUserNamePassword
-			wm.AllowExternalIDP = e.AllowExternalIDP
-			wm.ForceMFA = e.ForceMFA
-			wm.PasswordlessType = e.PasswordlessType
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/org_iam/read_model.go

@@ -1,21 +0,0 @@
-package org_iam
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	UserLoginMustBeDomain bool
-}
-
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.UserLoginMustBeDomain = e.UserLoginMustBeDomain
-		case *ChangedEvent:
-			rm.UserLoginMustBeDomain = e.UserLoginMustBeDomain
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/policy/org_iam/write_model.go

@@ -1,21 +0,0 @@
-package org_iam
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	UserLoginMustBeDomain bool
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.UserLoginMustBeDomain = e.UserLoginMustBeDomain
-		case *ChangedEvent:
-			wm.UserLoginMustBeDomain = e.UserLoginMustBeDomain
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/password_age/read_model.go

@@ -1,24 +0,0 @@
-package password_age
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	ExpireWarnDays uint64
-	MaxAgeDays     uint64
-}
-
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.ExpireWarnDays = e.ExpireWarnDays
-			rm.MaxAgeDays = e.MaxAgeDays
-		case *ChangedEvent:
-			rm.ExpireWarnDays = e.ExpireWarnDays
-			rm.MaxAgeDays = e.MaxAgeDays
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/policy/password_age/write_model.go

@@ -1,26 +0,0 @@
-package password_age
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	ExpireWarnDays uint64
-	MaxAgeDays     uint64
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.ExpireWarnDays = e.ExpireWarnDays
-			wm.MaxAgeDays = e.MaxAgeDays
-		case *ChangedEvent:
-			wm.ExpireWarnDays = e.ExpireWarnDays
-			wm.MaxAgeDays = e.MaxAgeDays
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/password_complexity/read_model.go

@@ -1,33 +0,0 @@
-package password_complexity
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	MinLength    uint64
-	HasLowercase bool
-	HasUpperCase bool
-	HasNumber    bool
-	HasSymbol    bool
-}
-
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.MinLength = e.MinLength
-			rm.HasLowercase = e.HasLowercase
-			rm.HasUpperCase = e.HasUpperCase
-			rm.HasNumber = e.HasNumber
-			rm.HasSymbol = e.HasSymbol
-		case *ChangedEvent:
-			rm.MinLength = e.MinLength
-			rm.HasLowercase = e.HasLowercase
-			rm.HasUpperCase = e.HasUpperCase
-			rm.HasNumber = e.HasNumber
-			rm.HasSymbol = e.HasSymbol
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/policy/password_complexity/write_model.go

@@ -1,35 +0,0 @@
-package password_complexity
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	MinLength    uint64
-	HasLowercase bool
-	HasUpperCase bool
-	HasNumber    bool
-	HasSymbol    bool
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.MinLength = e.MinLength
-			wm.HasLowercase = e.HasLowercase
-			wm.HasUpperCase = e.HasUpperCase
-			wm.HasNumber = e.HasNumber
-			wm.HasSymbol = e.HasSymbol
-		case *ChangedEvent:
-			wm.MinLength = e.MinLength
-			wm.HasLowercase = e.HasLowercase
-			wm.HasUpperCase = e.HasUpperCase
-			wm.HasNumber = e.HasNumber
-			wm.HasSymbol = e.HasSymbol
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/password_lockout/read_model.go

@@ -1,24 +0,0 @@
-package password_lockout
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	MaxAttempts         uint64
-	ShowLockOutFailures bool
-}
-
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.MaxAttempts = e.MaxAttempts
-			rm.ShowLockOutFailures = e.ShowLockOutFailures
-		case *ChangedEvent:
-			rm.MaxAttempts = e.MaxAttempts
-			rm.ShowLockOutFailures = e.ShowLockOutFailures
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/policy/password_lockout/write_model.go

@@ -1,26 +0,0 @@
-package password_lockout
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	MaxAttempts         uint64
-	ShowLockOutFailures bool
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.MaxAttempts = e.MaxAttempts
-			wm.ShowLockOutFailures = e.ShowLockOutFailures
-		case *ChangedEvent:
-			wm.MaxAttempts = e.MaxAttempts
-			wm.ShowLockOutFailures = e.ShowLockOutFailures
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/policy_login_factors.go

@@ -1,14 +1,15 @@
-package factors
+package policy
 
 import (
 	"encoding/json"
 	"github.com/caos/zitadel/internal/errors"
 	"github.com/caos/zitadel/internal/eventstore/v2"
 	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/domain"
 )
 
 const (
-	loginPolicySecondFactorPrefix           = "policy.login.secondfactor."
+	loginPolicySecondFactorPrefix           = loginPolicyPrefix + "secondfactor."
 	LoginPolicySecondFactorAddedEventType   = loginPolicySecondFactorPrefix + "added"
 	LoginPolicySecondFactorRemovedEventType = loginPolicySecondFactorPrefix + "removed"
 
@@ -20,12 +21,12 @@ const (
 type SecondFactorAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
-	MFAType SecondFactorType `json:"mfaType"`
+	MFAType domain.SecondFactorType `json:"mfaType"`
 }
 
 func NewSecondFactorAddedEvent(
 	base *eventstore.BaseEvent,
-	mfaType SecondFactorType,
+	mfaType domain.SecondFactorType,
 ) *SecondFactorAddedEvent {
 	return &SecondFactorAddedEvent{
 		BaseEvent: *base,
@@ -52,12 +53,12 @@ func (e *SecondFactorAddedEvent) Data() interface{} {
 
 type SecondFactorRemovedEvent struct {
 	eventstore.BaseEvent `json:"-"`
-	MFAType              SecondFactorType `json:"mfaType"`
+	MFAType              domain.SecondFactorType `json:"mfaType"`
 }
 
 func NewSecondFactorRemovedEvent(
 	base *eventstore.BaseEvent,
-	mfaType SecondFactorType,
+	mfaType domain.SecondFactorType,
 ) *SecondFactorRemovedEvent {
 	return &SecondFactorRemovedEvent{
 		BaseEvent: *base,
@@ -85,12 +86,12 @@ func (e *SecondFactorRemovedEvent) Data() interface{} {
 type MultiFactorAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
-	MFAType MultiFactorType `json:"mfaType"`
+	MFAType domain.MultiFactorType `json:"mfaType"`
 }
 
 func NewMultiFactorAddedEvent(
 	base *eventstore.BaseEvent,
-	mfaType MultiFactorType,
+	mfaType domain.MultiFactorType,
 ) *MultiFactorAddedEvent {
 	return &MultiFactorAddedEvent{
 		BaseEvent: *base,
@@ -117,12 +118,12 @@ func (e *MultiFactorAddedEvent) Data() interface{} {
 
 type MultiFactorRemovedEvent struct {
 	eventstore.BaseEvent `json:"-"`
-	MFAType              MultiFactorType `json:"mfaType"`
+	MFAType              domain.MultiFactorType `json:"mfaType"`
 }
 
 func NewMultiFactorRemovedEvent(
 	base *eventstore.BaseEvent,
-	mfaType MultiFactorType,
+	mfaType domain.MultiFactorType,
 ) *MultiFactorRemovedEvent {
 	return &MultiFactorRemovedEvent{
 		BaseEvent: *base,

internal/v2/repository/policy/policy_login_identity_provider.go

@@ -0,0 +1,85 @@
+package policy
+
+import (
+	"encoding/json"
+	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/domain"
+)
+
+const (
+	loginPolicyIDPProviderPrevix      = loginPolicyPrefix + "idpprovider."
+	LoginPolicyIDPProviderAddedType   = loginPolicyIDPProviderPrevix + "added"
+	LoginPolicyIDPProviderRemovedType = loginPolicyIDPProviderPrevix + "removed"
+)
+
+type IdentityProviderAddedEvent struct {
+	eventstore.BaseEvent
+
+	IDPConfigID     string                      `json:"idpConfigId"`
+	IDPProviderType domain.IdentityProviderType `json:"idpProviderType"`
+}
+
+func (e *IdentityProviderAddedEvent) Data() interface{} {
+	return e
+}
+
+func NewIdentityProviderAddedEvent(
+	base *eventstore.BaseEvent,
+	idpConfigID string,
+	idpProviderType domain.IdentityProviderType,
+) *IdentityProviderAddedEvent {
+
+	return &IdentityProviderAddedEvent{
+		*base,
+		idpConfigID,
+		idpProviderType,
+	}
+}
+
+func IdentityProviderAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &IdentityProviderAddedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "PROVI-bfNnp", "Errors.Internal")
+	}
+
+	return e, nil
+}
+
+type IdentityProviderRemovedEvent struct {
+	eventstore.BaseEvent
+
+	IDPConfigID string `json:"idpConfigId"`
+}
+
+func (e *IdentityProviderRemovedEvent) Data() interface{} {
+	return e
+}
+
+func NewIdentityProviderRemovedEvent(
+	base *eventstore.BaseEvent,
+	idpConfigID string,
+) *IdentityProviderRemovedEvent {
+	return &IdentityProviderRemovedEvent{
+		BaseEvent:   *base,
+		IDPConfigID: idpConfigID,
+	}
+}
+
+func IdentityProviderRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &IdentityProviderRemovedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "PROVI-6H0KQ", "Errors.Internal")
+	}
+
+	return e, nil
+}

internal/v2/repository/policy/policy_org_iam.go

@@ -1,4 +1,4 @@
-package org_iam
+package policy
 
 import (
 	"encoding/json"
@@ -12,29 +12,29 @@ const (
 	OrgIAMPolicyChangedEventType = "policy.org.iam.changed"
 )
 
-type AddedEvent struct {
+type OrgIAMPolicyAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	UserLoginMustBeDomain bool `json:"userLoginMustBeDomain"`
 }
 
-func (e *AddedEvent) Data() interface{} {
+func (e *OrgIAMPolicyAddedEvent) Data() interface{} {
 	return e
 }
 
-func NewAddedEvent(
+func NewOrgIAMPolicyAddedEvent(
 	base *eventstore.BaseEvent,
 	userLoginMustBeDomain bool,
-) *AddedEvent {
+) *OrgIAMPolicyAddedEvent {
 
-	return &AddedEvent{
+	return &OrgIAMPolicyAddedEvent{
 		BaseEvent:             *base,
 		UserLoginMustBeDomain: userLoginMustBeDomain,
 	}
 }
 
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
+func OrgIAMPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &OrgIAMPolicyAddedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -46,32 +46,26 @@ func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
 	return e, nil
 }
 
-type ChangedEvent struct {
+type OrgIAMPolicyChangedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	UserLoginMustBeDomain bool `json:"userLoginMustBeDomain"`
 }
 
-func (e *ChangedEvent) Data() interface{} {
+func (e *OrgIAMPolicyChangedEvent) Data() interface{} {
 	return e
 }
 
-func NewChangedEvent(
+func NewOrgIAMPolicyChangedEvent(
 	base *eventstore.BaseEvent,
-	current *WriteModel,
-	userLoginMustBeDomain bool,
-) *ChangedEvent {
-	e := &ChangedEvent{
+) *OrgIAMPolicyChangedEvent {
+	return &OrgIAMPolicyChangedEvent{
 		BaseEvent: *base,
 	}
-	if current.UserLoginMustBeDomain != userLoginMustBeDomain {
-		e.UserLoginMustBeDomain = userLoginMustBeDomain
-	}
-	return e
 }
 
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
+func OrgIAMPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &OrgIAMPolicyChangedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 

internal/v2/repository/policy/policy_password_age.go

@@ -1,4 +1,4 @@
-package password_age
+package policy
 
 import (
 	"encoding/json"
@@ -13,32 +13,32 @@ const (
 	PasswordAgePolicyRemovedEventType = "policy.password.age.removed"
 )
 
-type AddedEvent struct {
+type PasswordAgePolicyAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	ExpireWarnDays uint64 `json:"expireWarnDays"`
 	MaxAgeDays     uint64 `json:"maxAgeDays"`
 }
 
-func (e *AddedEvent) Data() interface{} {
+func (e *PasswordAgePolicyAddedEvent) Data() interface{} {
 	return e
 }
 
-func NewAddedEvent(
+func NewPasswordAgePolicyAddedEvent(
 	base *eventstore.BaseEvent,
 	expireWarnDays,
 	maxAgeDays uint64,
-) *AddedEvent {
+) *PasswordAgePolicyAddedEvent {
 
-	return &AddedEvent{
+	return &PasswordAgePolicyAddedEvent{
 		BaseEvent:      *base,
 		ExpireWarnDays: expireWarnDays,
 		MaxAgeDays:     maxAgeDays,
 	}
 }
 
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
+func PasswordAgePolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordAgePolicyAddedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -50,40 +50,27 @@ func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
 	return e, nil
 }
 
-type ChangedEvent struct {
+type PasswordAgePolicyChangedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	ExpireWarnDays uint64 `json:"expireWarnDays,omitempty"`
 	MaxAgeDays     uint64 `json:"maxAgeDays,omitempty"`
 }
 
-func (e *ChangedEvent) Data() interface{} {
+func (e *PasswordAgePolicyChangedEvent) Data() interface{} {
 	return e
 }
 
-func NewChangedEvent(
+func NewPasswordAgePolicyChangedEvent(
 	base *eventstore.BaseEvent,
-	current *WriteModel,
-	expireWarnDays,
-	maxAgeDays uint64,
-) *ChangedEvent {
-
-	e := &ChangedEvent{
+) *PasswordAgePolicyChangedEvent {
+	return &PasswordAgePolicyChangedEvent{
 		BaseEvent: *base,
 	}
-
-	if current.ExpireWarnDays != expireWarnDays {
-		e.ExpireWarnDays = expireWarnDays
-	}
-	if current.MaxAgeDays != maxAgeDays {
-		e.MaxAgeDays = maxAgeDays
-	}
-
-	return e
 }
 
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
+func PasswordAgePolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordAgePolicyChangedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -95,24 +82,24 @@ func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error)
 	return e, nil
 }
 
-type RemovedEvent struct {
+type PasswordAgePolicyRemovedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 }
 
-func (e *RemovedEvent) Data() interface{} {
+func (e *PasswordAgePolicyRemovedEvent) Data() interface{} {
 	return nil
 }
 
-func NewRemovedEvent(
+func NewPasswordAgePolicyRemovedEvent(
 	base *eventstore.BaseEvent,
-) *RemovedEvent {
-	return &RemovedEvent{
+) *PasswordAgePolicyRemovedEvent {
+	return &PasswordAgePolicyRemovedEvent{
 		BaseEvent: *base,
 	}
 }
 
-func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &RemovedEvent{
+func PasswordAgePolicyRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordAgePolicyRemovedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 

internal/v2/repository/policy/policy_password_complexity.go

@@ -1,4 +1,4 @@
-package password_complexity
+package policy
 
 import (
 	"encoding/json"
@@ -13,7 +13,7 @@ const (
 	PasswordComplexityPolicyRemovedEventType = "policy.password.complexity.removed"
 )
 
-type AddedEvent struct {
+type PasswordComplexityPolicyAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	MinLength    uint64 `json:"minLength,omitempty"`
@@ -23,19 +23,19 @@ type AddedEvent struct {
 	HasSymbol    bool   `json:"hasSymbol"`
 }
 
-func (e *AddedEvent) Data() interface{} {
+func (e *PasswordComplexityPolicyAddedEvent) Data() interface{} {
 	return e
 }
 
-func NewAddedEvent(
+func NewPasswordComplexityPolicyAddedEvent(
 	base *eventstore.BaseEvent,
 	minLength uint64,
 	hasLowerCase,
 	hasUpperCase,
 	hasNumber,
 	hasSymbol bool,
-) *AddedEvent {
-	return &AddedEvent{
+) *PasswordComplexityPolicyAddedEvent {
+	return &PasswordComplexityPolicyAddedEvent{
 		BaseEvent:    *base,
 		MinLength:    minLength,
 		HasLowercase: hasLowerCase,
@@ -45,8 +45,8 @@ func NewAddedEvent(
 	}
 }
 
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
+func PasswordComplexityPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordComplexityPolicyAddedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -58,7 +58,7 @@ func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
 	return e, nil
 }
 
-type ChangedEvent struct {
+type PasswordComplexityPolicyChangedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	MinLength    uint64 `json:"minLength"`
@@ -68,45 +68,20 @@ type ChangedEvent struct {
 	HasSymbol    bool   `json:"hasSymbol"`
 }
 
-func (e *ChangedEvent) Data() interface{} {
+func (e *PasswordComplexityPolicyChangedEvent) Data() interface{} {
 	return e
 }
 
-func NewChangedEvent(
+func NewPasswordComplexityPolicyChangedEvent(
 	base *eventstore.BaseEvent,
-	current *WriteModel,
-	minLength uint64,
-	hasLowerCase,
-	hasUpperCase,
-	hasNumber,
-	hasSymbol bool,
-) *ChangedEvent {
-
-	e := &ChangedEvent{
+) *PasswordComplexityPolicyChangedEvent {
+	return &PasswordComplexityPolicyChangedEvent{
 		BaseEvent: *base,
 	}
-
-	if current.MinLength != minLength {
-		e.MinLength = minLength
-	}
-	if current.HasLowercase != hasLowerCase {
-		e.HasLowercase = hasLowerCase
-	}
-	if current.HasUpperCase != hasUpperCase {
-		e.HasUpperCase = hasUpperCase
-	}
-	if current.HasNumber != hasNumber {
-		e.HasNumber = hasNumber
-	}
-	if current.HasSymbol != hasSymbol {
-		e.HasSymbol = hasSymbol
-	}
-
-	return e
 }
 
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
+func PasswordComplexityPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordComplexityPolicyChangedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -118,22 +93,22 @@ func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error)
 	return e, nil
 }
 
-type RemovedEvent struct {
+type PasswordComplexityPolicyRemovedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 }
 
-func (e *RemovedEvent) Data() interface{} {
+func (e *PasswordComplexityPolicyRemovedEvent) Data() interface{} {
 	return nil
 }
 
-func NewRemovedEvent(base *eventstore.BaseEvent) *RemovedEvent {
-	return &RemovedEvent{
+func NewPasswordComplexityPolicyRemovedEvent(base *eventstore.BaseEvent) *PasswordComplexityPolicyRemovedEvent {
+	return &PasswordComplexityPolicyRemovedEvent{
 		BaseEvent: *base,
 	}
 }
 
-func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	return &RemovedEvent{
+func PasswordComplexityPolicyRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	return &PasswordComplexityPolicyRemovedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}, nil
 }

internal/v2/repository/policy/policy_password_lockout.go

@@ -1,4 +1,4 @@
-package password_lockout
+package policy
 
 import (
 	"encoding/json"
@@ -13,32 +13,32 @@ const (
 	PasswordLockoutPolicyRemovedEventType = "policy.password.lockout.removed"
 )
 
-type AddedEvent struct {
+type PasswordLockoutPolicyAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	MaxAttempts         uint64 `json:"maxAttempts,omitempty"`
 	ShowLockOutFailures bool   `json:"showLockOutFailures"`
 }
 
-func (e *AddedEvent) Data() interface{} {
+func (e *PasswordLockoutPolicyAddedEvent) Data() interface{} {
 	return e
 }
 
-func NewAddedEvent(
+func NewPasswordLockoutPolicyAddedEvent(
 	base *eventstore.BaseEvent,
 	maxAttempts uint64,
 	showLockOutFailures bool,
-) *AddedEvent {
+) *PasswordLockoutPolicyAddedEvent {
 
-	return &AddedEvent{
+	return &PasswordLockoutPolicyAddedEvent{
 		BaseEvent:           *base,
 		MaxAttempts:         maxAttempts,
 		ShowLockOutFailures: showLockOutFailures,
 	}
 }
 
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
+func PasswordLockoutPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordLockoutPolicyAddedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -50,40 +50,27 @@ func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
 	return e, nil
 }
 
-type ChangedEvent struct {
+type PasswordLockoutPolicyChangedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	MaxAttempts         uint64 `json:"maxAttempts,omitempty"`
 	ShowLockOutFailures bool   `json:"showLockOutFailures,omitempty"`
 }
 
-func (e *ChangedEvent) Data() interface{} {
+func (e *PasswordLockoutPolicyChangedEvent) Data() interface{} {
 	return e
 }
 
-func NewChangedEvent(
+func NewPasswordLockoutPolicyChangedEvent(
 	base *eventstore.BaseEvent,
-	current *WriteModel,
-	maxAttempts uint64,
-	showLockOutFailures bool,
-) *ChangedEvent {
-
-	e := &ChangedEvent{
+) *PasswordLockoutPolicyChangedEvent {
+	return &PasswordLockoutPolicyChangedEvent{
 		BaseEvent: *base,
 	}
-
-	if current.MaxAttempts != maxAttempts {
-		e.MaxAttempts = maxAttempts
-	}
-	if current.ShowLockOutFailures != showLockOutFailures {
-		e.ShowLockOutFailures = showLockOutFailures
-	}
-
-	return e
 }
 
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
+func PasswordLockoutPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordLockoutPolicyChangedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -95,25 +82,25 @@ func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error)
 	return e, nil
 }
 
-type RemovedEvent struct {
+type PasswordLockoutPolicyRemovedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 }
 
-func (e *RemovedEvent) Data() interface{} {
+func (e *PasswordLockoutPolicyRemovedEvent) Data() interface{} {
 	return nil
 }
 
-func NewRemovedEvent(
+func NewPasswordLockoutPolicyRemovedEvent(
 	base *eventstore.BaseEvent,
-) *RemovedEvent {
+) *PasswordLockoutPolicyRemovedEvent {
 
-	return &RemovedEvent{
+	return &PasswordLockoutPolicyRemovedEvent{
 		BaseEvent: *base,
 	}
 }
 
-func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	return &RemovedEvent{
+func PasswordLockoutPolicyRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	return &PasswordLockoutPolicyRemovedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}, nil
 }

internal/v2/repository/user/aggregate.go

@@ -29,21 +29,3 @@ func NewAggregate(
 		),
 	}
 }
-
-func AggregateFromWriteModel(wm *eventstore.WriteModel) *Aggregate {
-	return &Aggregate{
-		Aggregate: *eventstore.AggregateFromWriteModel(wm, AggregateType, AggregateVersion),
-	}
-}
-
-func AggregateFromReadModel(rm *ReadModel) *Aggregate {
-	return &Aggregate{
-		Aggregate: *eventstore.NewAggregate(
-			rm.AggregateID,
-			AggregateType,
-			rm.ResourceOwner,
-			AggregateVersion,
-			rm.ProcessedSequence,
-		),
-	}
-}

internal/v2/repository/user/eventstore.go

@@ -2,113 +2,100 @@ package user
 
 import (
 	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/v2/repository/user/human"
-	"github.com/caos/zitadel/internal/v2/repository/user/human/address"
-	"github.com/caos/zitadel/internal/v2/repository/user/human/email"
-	"github.com/caos/zitadel/internal/v2/repository/user/human/external_idp"
-	"github.com/caos/zitadel/internal/v2/repository/user/human/mfa"
-	"github.com/caos/zitadel/internal/v2/repository/user/human/mfa/otp"
-	"github.com/caos/zitadel/internal/v2/repository/user/human/mfa/web_auth_n"
-	"github.com/caos/zitadel/internal/v2/repository/user/human/password"
-	"github.com/caos/zitadel/internal/v2/repository/user/human/phone"
-	"github.com/caos/zitadel/internal/v2/repository/user/human/profile"
-	"github.com/caos/zitadel/internal/v2/repository/user/machine"
-	"github.com/caos/zitadel/internal/v2/repository/user/machine/keys"
-	"github.com/caos/zitadel/internal/v2/repository/user/v1"
 )
 
 func RegisterEventMappers(es *eventstore.Eventstore) {
-	es.RegisterFilterEventMapper(v1.UserV1AddedType, human.AddedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1RegisteredType, human.RegisteredEventMapper).
-		RegisterFilterEventMapper(v1.UserV1InitialCodeAddedType, human.InitialCodeAddedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1InitialCodeSentType, human.InitialCodeSentEventMapper).
-		RegisterFilterEventMapper(v1.UserV1InitializedCheckSucceededType, human.InitializedCheckSucceededEventMapper).
-		RegisterFilterEventMapper(v1.UserV1InitializedCheckFailedType, human.InitializedCheckFailedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1SignedOutType, human.SignedOutEventMapper).
-		RegisterFilterEventMapper(v1.UserV1PasswordChangedType, password.ChangedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1PasswordCodeAddedType, password.CodeAddedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1PasswordCodeSentType, password.CodeSentEventMapper).
-		RegisterFilterEventMapper(v1.UserV1PasswordCheckSucceededType, password.CheckSucceededEventMapper).
-		RegisterFilterEventMapper(v1.UserV1PasswordCheckFailedType, password.CheckFailedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1EmailChangedType, email.ChangedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1EmailVerifiedType, email.VerifiedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1EmailVerificationFailedType, email.VerificationFailedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1EmailCodeAddedType, email.CodeAddedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1EmailCodeSentType, email.CodeSentEventMapper).
-		RegisterFilterEventMapper(v1.UserV1PhoneChangedType, phone.ChangedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1PhoneRemovedType, phone.RemovedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1PhoneVerifiedType, phone.VerifiedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1PhoneVerificationFailedType, phone.VerificationFailedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1PhoneCodeAddedType, phone.CodeAddedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1PhoneCodeSentType, phone.CodeSentEventMapper).
-		RegisterFilterEventMapper(v1.UserV1ProfileChangedType, profile.ChangedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1AddressChangedType, address.ChangedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1MFAInitSkippedType, mfa.InitSkippedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1MFAOTPAddedType, otp.AddedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1MFAOTPVerifiedType, otp.VerifiedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1MFAOTPRemovedType, otp.RemovedEventMapper).
-		RegisterFilterEventMapper(v1.UserV1MFAOTPCheckSucceededType, otp.CheckSucceededEventMapper).
-		RegisterFilterEventMapper(v1.UserV1MFAOTPCheckFailedType, otp.CheckFailedEventMapper).
-		RegisterFilterEventMapper(UserLockedType, LockedEventMapper).
-		RegisterFilterEventMapper(UserUnlockedType, LockedEventMapper).
-		RegisterFilterEventMapper(UserDeactivatedType, DeactivatedEventMapper).
-		RegisterFilterEventMapper(UserReactivatedType, ReactivatedEventMapper).
-		RegisterFilterEventMapper(UserRemovedType, RemovedEventMapper).
-		RegisterFilterEventMapper(UserTokenAddedType, TokenAddedEventMapper).
+	es.RegisterFilterEventMapper(UserV1AddedType, HumanAddedEventMapper).
+		RegisterFilterEventMapper(UserV1RegisteredType, HumanRegisteredEventMapper).
+		RegisterFilterEventMapper(UserV1InitialCodeAddedType, HumanInitialCodeAddedEventMapper).
+		RegisterFilterEventMapper(UserV1InitialCodeSentType, HumanInitialCodeSentEventMapper).
+		RegisterFilterEventMapper(UserV1InitializedCheckSucceededType, HumanInitializedCheckSucceededEventMapper).
+		RegisterFilterEventMapper(UserV1InitializedCheckFailedType, HumanInitializedCheckFailedEventMapper).
+		RegisterFilterEventMapper(UserV1SignedOutType, HumanSignedOutEventMapper).
+		RegisterFilterEventMapper(UserV1PasswordChangedType, HumanPasswordChangedEventMapper).
+		RegisterFilterEventMapper(UserV1PasswordCodeAddedType, HumanPasswordCodeAddedEventMapper).
+		RegisterFilterEventMapper(UserV1PasswordCodeSentType, HumanPasswordCodeSentEventMapper).
+		RegisterFilterEventMapper(UserV1PasswordCheckSucceededType, HumanPasswordCheckSucceededEventMapper).
+		RegisterFilterEventMapper(UserV1PasswordCheckFailedType, HumanPasswordCheckFailedEventMapper).
+		RegisterFilterEventMapper(UserV1EmailChangedType, HumanEmailChangedEventMapper).
+		RegisterFilterEventMapper(UserV1EmailVerifiedType, HumanEmailVerifiedEventMapper).
+		RegisterFilterEventMapper(UserV1EmailVerificationFailedType, HumanEmailVerificationFailedEventMapper).
+		RegisterFilterEventMapper(UserV1EmailCodeAddedType, HumanEmailCodeAddedEventMapper).
+		RegisterFilterEventMapper(UserV1EmailCodeSentType, HumanEmailCodeSentEventMapper).
+		RegisterFilterEventMapper(UserV1PhoneChangedType, HumanPhoneChangedEventMapper).
+		RegisterFilterEventMapper(UserV1PhoneRemovedType, HumanPhoneRemovedEventMapper).
+		RegisterFilterEventMapper(UserV1PhoneVerifiedType, HumanPhoneVerifiedEventMapper).
+		RegisterFilterEventMapper(UserV1PhoneVerificationFailedType, HumanPhoneVerificationFailedEventMapper).
+		RegisterFilterEventMapper(UserV1PhoneCodeAddedType, HumanPhoneCodeAddedEventMapper).
+		RegisterFilterEventMapper(UserV1PhoneCodeSentType, HumanPhoneCodeSentEventMapper).
+		RegisterFilterEventMapper(UserV1ProfileChangedType, HumanProfileChangedEventMapper).
+		RegisterFilterEventMapper(UserV1AddressChangedType, HumanAddressChangedEventMapper).
+		RegisterFilterEventMapper(UserV1MFAInitSkippedType, HumanMFAInitSkippedEventMapper).
+		RegisterFilterEventMapper(UserV1MFAOTPAddedType, HumanOTPAddedEventMapper).
+		RegisterFilterEventMapper(UserV1MFAOTPVerifiedType, HumanOTPVerifiedEventMapper).
+		RegisterFilterEventMapper(UserV1MFAOTPRemovedType, HumanOTPRemovedEventMapper).
+		RegisterFilterEventMapper(UserV1MFAOTPCheckSucceededType, HumanOTPCheckSucceededEventMapper).
+		RegisterFilterEventMapper(UserV1MFAOTPCheckFailedType, HumanOTPCheckFailedEventMapper).
+		RegisterFilterEventMapper(UserLockedType, UserLockedEventMapper).
+		RegisterFilterEventMapper(UserUnlockedType, UserLockedEventMapper).
+		RegisterFilterEventMapper(UserDeactivatedType, UserDeactivatedEventMapper).
+		RegisterFilterEventMapper(UserReactivatedType, UserReactivatedEventMapper).
+		RegisterFilterEventMapper(UserRemovedType, UserRemovedEventMapper).
+		RegisterFilterEventMapper(UserTokenAddedType, UserTokenAddedEventMapper).
 		RegisterFilterEventMapper(UserDomainClaimedType, DomainClaimedEventMapper).
 		RegisterFilterEventMapper(UserDomainClaimedSentType, DomainClaimedEventMapper).
 		RegisterFilterEventMapper(UserUserNameChangedType, UsernameChangedEventMapper).
-		RegisterFilterEventMapper(human.HumanAddedType, human.AddedEventMapper).
-		RegisterFilterEventMapper(human.HumanRegisteredType, human.RegisteredEventMapper).
-		RegisterFilterEventMapper(human.HumanInitialCodeAddedType, human.InitialCodeAddedEventMapper).
-		RegisterFilterEventMapper(human.HumanInitialCodeSentType, human.InitialCodeSentEventMapper).
-		RegisterFilterEventMapper(human.HumanInitializedCheckSucceededType, human.InitializedCheckSucceededEventMapper).
-		RegisterFilterEventMapper(human.HumanInitializedCheckFailedType, human.InitializedCheckFailedEventMapper).
-		RegisterFilterEventMapper(human.HumanSignedOutType, human.SignedOutEventMapper).
-		RegisterFilterEventMapper(password.HumanPasswordChangedType, password.ChangedEventMapper).
-		RegisterFilterEventMapper(password.HumanPasswordCodeAddedType, password.CodeAddedEventMapper).
-		RegisterFilterEventMapper(password.HumanPasswordCodeSentType, password.CodeSentEventMapper).
-		RegisterFilterEventMapper(password.HumanPasswordCheckSucceededType, password.CheckSucceededEventMapper).
-		RegisterFilterEventMapper(password.HumanPasswordCheckFailedType, password.CheckFailedEventMapper).
-		RegisterFilterEventMapper(external_idp.HumanExternalIDPAddedType, external_idp.AddedEventMapper).
-		RegisterFilterEventMapper(external_idp.HumanExternalIDPRemovedType, external_idp.RemovedEventMapper).
-		RegisterFilterEventMapper(external_idp.HumanExternalIDPCascadeRemovedType, external_idp.CascadeRemovedEventMapper).
-		RegisterFilterEventMapper(external_idp.HumanExternalLoginCheckSucceededType, external_idp.CheckSucceededEventMapper).
-		RegisterFilterEventMapper(email.HumanEmailChangedType, email.ChangedEventMapper).
-		RegisterFilterEventMapper(email.HumanEmailVerifiedType, email.VerifiedEventMapper).
-		RegisterFilterEventMapper(email.HumanEmailVerificationFailedType, email.VerificationFailedEventMapper).
-		RegisterFilterEventMapper(email.HumanEmailCodeAddedType, email.CodeAddedEventMapper).
-		RegisterFilterEventMapper(email.HumanEmailCodeSentType, email.CodeSentEventMapper).
-		RegisterFilterEventMapper(phone.HumanPhoneChangedType, phone.ChangedEventMapper).
-		RegisterFilterEventMapper(phone.HumanPhoneRemovedType, phone.RemovedEventMapper).
-		RegisterFilterEventMapper(phone.HumanPhoneVerifiedType, phone.VerifiedEventMapper).
-		RegisterFilterEventMapper(phone.HumanPhoneVerificationFailedType, phone.VerificationFailedEventMapper).
-		RegisterFilterEventMapper(phone.HumanPhoneCodeAddedType, phone.CodeAddedEventMapper).
-		RegisterFilterEventMapper(phone.HumanPhoneCodeSentType, phone.CodeSentEventMapper).
-		RegisterFilterEventMapper(profile.HumanProfileChangedType, profile.ChangedEventMapper).
-		RegisterFilterEventMapper(address.HumanAddressChangedType, address.ChangedEventMapper).
-		RegisterFilterEventMapper(mfa.HumanMFAInitSkippedType, mfa.InitSkippedEventMapper).
-		RegisterFilterEventMapper(otp.HumanMFAOTPAddedType, otp.AddedEventMapper).
-		RegisterFilterEventMapper(otp.HumanMFAOTPVerifiedType, otp.VerifiedEventMapper).
-		RegisterFilterEventMapper(otp.HumanMFAOTPRemovedType, otp.RemovedEventMapper).
-		RegisterFilterEventMapper(otp.HumanMFAOTPCheckSucceededType, otp.CheckSucceededEventMapper).
-		RegisterFilterEventMapper(otp.HumanMFAOTPCheckFailedType, otp.CheckFailedEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanU2FTokenAddedType, web_auth_n.AddedEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanU2FTokenVerifiedType, web_auth_n.VerifiedEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanU2FTokenSignCountChangedType, web_auth_n.SignCountChangedEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanU2FTokenRemovedType, web_auth_n.RemovedEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanU2FTokenBeginLoginType, web_auth_n.BeginLoginEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanU2FTokenCheckSucceededType, web_auth_n.CheckSucceededEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanU2FTokenCheckFailedType, web_auth_n.CheckFailedEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanPasswordlessTokenAddedType, web_auth_n.AddedEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanPasswordlessTokenVerifiedType, web_auth_n.VerifiedEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanPasswordlessTokenSignCountChangedType, web_auth_n.SignCountChangedEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanPasswordlessTokenRemovedType, web_auth_n.RemovedEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanPasswordlessTokenBeginLoginType, web_auth_n.BeginLoginEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanPasswordlessTokenCheckSucceededType, web_auth_n.CheckSucceededEventMapper).
-		RegisterFilterEventMapper(web_auth_n.HumanPasswordlessTokenCheckFailedType, web_auth_n.CheckFailedEventMapper).
-		RegisterFilterEventMapper(machine.MachineAddedEventType, machine.AddedEventMapper).
-		RegisterFilterEventMapper(machine.MachineChangedEventType, machine.ChangedEventMapper).
-		RegisterFilterEventMapper(keys.MachineKeyAddedEventType, keys.AddedEventMapper).
-		RegisterFilterEventMapper(keys.MachineKeyRemovedEventType, keys.RemovedEventMapper)
+		RegisterFilterEventMapper(HumanAddedType, HumanAddedEventMapper).
+		RegisterFilterEventMapper(HumanRegisteredType, HumanRegisteredEventMapper).
+		RegisterFilterEventMapper(HumanInitialCodeAddedType, HumanInitialCodeAddedEventMapper).
+		RegisterFilterEventMapper(HumanInitialCodeSentType, HumanInitialCodeSentEventMapper).
+		RegisterFilterEventMapper(HumanInitializedCheckSucceededType, HumanInitializedCheckSucceededEventMapper).
+		RegisterFilterEventMapper(HumanInitializedCheckFailedType, HumanInitializedCheckFailedEventMapper).
+		RegisterFilterEventMapper(HumanSignedOutType, HumanSignedOutEventMapper).
+		RegisterFilterEventMapper(HumanPasswordChangedType, HumanPasswordChangedEventMapper).
+		RegisterFilterEventMapper(HumanPasswordCodeAddedType, HumanPasswordCodeAddedEventMapper).
+		RegisterFilterEventMapper(HumanPasswordCodeSentType, HumanPasswordCodeSentEventMapper).
+		RegisterFilterEventMapper(HumanPasswordCheckSucceededType, HumanPasswordCheckSucceededEventMapper).
+		RegisterFilterEventMapper(HumanPasswordCheckFailedType, HumanPasswordCheckFailedEventMapper).
+		RegisterFilterEventMapper(HumanExternalIDPAddedType, HumanExternalIDPAddedEventMapper).
+		RegisterFilterEventMapper(HumanExternalIDPRemovedType, HumanExternalIDPRemovedEventMapper).
+		RegisterFilterEventMapper(HumanExternalIDPCascadeRemovedType, HumanExternalIDPCascadeRemovedEventMapper).
+		RegisterFilterEventMapper(HumanExternalLoginCheckSucceededType, HumanExternalIDPCheckSucceededEventMapper).
+		RegisterFilterEventMapper(HumanEmailChangedType, HumanEmailChangedEventMapper).
+		RegisterFilterEventMapper(HumanEmailVerifiedType, HumanEmailVerifiedEventMapper).
+		RegisterFilterEventMapper(HumanEmailVerificationFailedType, HumanEmailVerificationFailedEventMapper).
+		RegisterFilterEventMapper(HumanEmailCodeAddedType, HumanEmailCodeAddedEventMapper).
+		RegisterFilterEventMapper(HumanEmailCodeSentType, HumanEmailCodeSentEventMapper).
+		RegisterFilterEventMapper(HumanPhoneChangedType, HumanPhoneChangedEventMapper).
+		RegisterFilterEventMapper(HumanPhoneRemovedType, HumanPhoneRemovedEventMapper).
+		RegisterFilterEventMapper(HumanPhoneVerifiedType, HumanPhoneVerifiedEventMapper).
+		RegisterFilterEventMapper(HumanPhoneVerificationFailedType, HumanPhoneVerificationFailedEventMapper).
+		RegisterFilterEventMapper(HumanPhoneCodeAddedType, HumanPhoneCodeAddedEventMapper).
+		RegisterFilterEventMapper(HumanPhoneCodeSentType, HumanPhoneCodeSentEventMapper).
+		RegisterFilterEventMapper(HumanProfileChangedType, HumanProfileChangedEventMapper).
+		RegisterFilterEventMapper(HumanAddressChangedType, HumanAddressChangedEventMapper).
+		RegisterFilterEventMapper(HumanMFAInitSkippedType, HumanMFAInitSkippedEventMapper).
+		RegisterFilterEventMapper(HumanMFAOTPAddedType, HumanOTPAddedEventMapper).
+		RegisterFilterEventMapper(HumanMFAOTPVerifiedType, HumanOTPVerifiedEventMapper).
+		RegisterFilterEventMapper(HumanMFAOTPRemovedType, HumanOTPRemovedEventMapper).
+		RegisterFilterEventMapper(HumanMFAOTPCheckSucceededType, HumanOTPCheckSucceededEventMapper).
+		RegisterFilterEventMapper(HumanMFAOTPCheckFailedType, HumanOTPCheckFailedEventMapper).
+		RegisterFilterEventMapper(HumanU2FTokenAddedType, WebAuthNAddedEventMapper).
+		RegisterFilterEventMapper(HumanU2FTokenVerifiedType, HumanWebAuthNVerifiedEventMapper).
+		RegisterFilterEventMapper(HumanU2FTokenSignCountChangedType, HumanWebAuthNSignCountChangedEventMapper).
+		RegisterFilterEventMapper(HumanU2FTokenRemovedType, HumanWebAuthNRemovedEventMapper).
+		RegisterFilterEventMapper(HumanU2FTokenBeginLoginType, HumanWebAuthNBeginLoginEventMapper).
+		RegisterFilterEventMapper(HumanU2FTokenCheckSucceededType, HumanWebAuthNCheckSucceededEventMapper).
+		RegisterFilterEventMapper(HumanU2FTokenCheckFailedType, HumanWebAuthNCheckFailedEventMapper).
+		RegisterFilterEventMapper(HumanPasswordlessTokenAddedType, WebAuthNAddedEventMapper).
+		RegisterFilterEventMapper(HumanPasswordlessTokenVerifiedType, HumanWebAuthNVerifiedEventMapper).
+		RegisterFilterEventMapper(HumanPasswordlessTokenSignCountChangedType, HumanWebAuthNSignCountChangedEventMapper).
+		RegisterFilterEventMapper(HumanPasswordlessTokenRemovedType, HumanWebAuthNRemovedEventMapper).
+		RegisterFilterEventMapper(HumanPasswordlessTokenBeginLoginType, HumanWebAuthNBeginLoginEventMapper).
+		RegisterFilterEventMapper(HumanPasswordlessTokenCheckSucceededType, HumanWebAuthNCheckSucceededEventMapper).
+		RegisterFilterEventMapper(HumanPasswordlessTokenCheckFailedType, HumanWebAuthNCheckFailedEventMapper).
+		RegisterFilterEventMapper(MachineAddedEventType, MachineAddedEventMapper).
+		RegisterFilterEventMapper(MachineChangedEventType, MachineChangedEventMapper).
+		RegisterFilterEventMapper(MachineKeyAddedEventType, MachineKeyAddedEventMapper).
+		RegisterFilterEventMapper(MachineKeyRemovedEventType, MachineKeyRemovedEventMapper)
 }

internal/v2/repository/user/human.go

@@ -1,4 +1,4 @@
-package human
+package user
 
 import (
 	"context"
@@ -7,12 +7,13 @@ import (
 	"github.com/caos/zitadel/internal/errors"
 	"github.com/caos/zitadel/internal/eventstore/v2"
 	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/domain"
 	"golang.org/x/text/language"
 	"time"
 )
 
 const (
-	humanEventPrefix                   = eventstore.EventType("user.human.")
+	humanEventPrefix                   = userEventTypePrefix + "human."
 	HumanAddedType                     = humanEventPrefix + "added"
 	HumanRegisteredType                = humanEventPrefix + "selfregistered"
 	HumanInitialCodeAddedType          = humanEventPrefix + "initialization.code.added"
@@ -22,17 +23,17 @@ const (
 	HumanSignedOutType                 = humanEventPrefix + "signed.out"
 )
 
-type AddedEvent struct {
+type HumanAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	UserName string `json:"userName"`
 
-	FirstName         string       `json:"firstName,omitempty"`
-	LastName          string       `json:"lastName,omitempty"`
-	NickName          string       `json:"nickName,omitempty"`
-	DisplayName       string       `json:"displayName,omitempty"`
-	PreferredLanguage language.Tag `json:"preferredLanguage,omitempty"`
-	Gender            Gender       `json:"gender,omitempty"`
+	FirstName         string        `json:"firstName,omitempty"`
+	LastName          string        `json:"lastName,omitempty"`
+	NickName          string        `json:"nickName,omitempty"`
+	DisplayName       string        `json:"displayName,omitempty"`
+	PreferredLanguage language.Tag  `json:"preferredLanguage,omitempty"`
+	Gender            domain.Gender `json:"gender,omitempty"`
 
 	EmailAddress string `json:"email,omitempty"`
 
@@ -43,13 +44,16 @@ type AddedEvent struct {
 	PostalCode    string `json:"postalCode,omitempty"`
 	Region        string `json:"region,omitempty"`
 	StreetAddress string `json:"streetAddress,omitempty"`
+
+	Secret         *crypto.CryptoValue `json:"secret,omitempty"`
+	ChangeRequired bool                `json:"changeRequired,omitempty"`
 }
 
-func (e *AddedEvent) Data() interface{} {
+func (e *HumanAddedEvent) Data() interface{} {
 	return e
 }
 
-func NewAddedEvent(
+func NewHumanAddedEvent(
 	ctx context.Context,
 	userName,
 	firstName,
@@ -57,7 +61,7 @@ func NewAddedEvent(
 	nickName,
 	displayName string,
 	preferredLanguage language.Tag,
-	gender Gender,
+	gender domain.Gender,
 	emailAddress,
 	phoneNumber,
 	country,
@@ -65,8 +69,8 @@ func NewAddedEvent(
 	postalCode,
 	region,
 	streetAddress string,
-) *AddedEvent {
-	return &AddedEvent{
+) *HumanAddedEvent {
+	return &HumanAddedEvent{
 		BaseEvent: *eventstore.NewBaseEventForPush(
 			ctx,
 			HumanAddedType,
@@ -88,8 +92,8 @@ func NewAddedEvent(
 	}
 }
 
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	humanAdded := &AddedEvent{
+func HumanAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	humanAdded := &HumanAddedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 	err := json.Unmarshal(event.Data, humanAdded)
@@ -100,17 +104,17 @@ func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
 	return humanAdded, nil
 }
 
-type RegisteredEvent struct {
+type HumanRegisteredEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	UserName string `json:"userName"`
 
-	FirstName         string       `json:"firstName,omitempty"`
-	LastName          string       `json:"lastName,omitempty"`
-	NickName          string       `json:"nickName,omitempty"`
-	DisplayName       string       `json:"displayName,omitempty"`
-	PreferredLanguage language.Tag `json:"preferredLanguage,omitempty"`
-	Gender            int32        `json:"gender,omitempty"`
+	FirstName         string        `json:"firstName,omitempty"`
+	LastName          string        `json:"lastName,omitempty"`
+	NickName          string        `json:"nickName,omitempty"`
+	DisplayName       string        `json:"displayName,omitempty"`
+	PreferredLanguage language.Tag  `json:"preferredLanguage,omitempty"`
+	Gender            domain.Gender `json:"gender,omitempty"`
 
 	EmailAddress string `json:"email,omitempty"`
 
@@ -123,11 +127,11 @@ type RegisteredEvent struct {
 	StreetAddress string `json:"streetAddress,omitempty"`
 }
 
-func (e *RegisteredEvent) Data() interface{} {
+func (e *HumanRegisteredEvent) Data() interface{} {
 	return e
 }
 
-func NewRegisteredEvent(
+func NewHumanRegisteredEvent(
 	ctx context.Context,
 	userName,
 	firstName,
@@ -135,7 +139,7 @@ func NewRegisteredEvent(
 	nickName,
 	displayName string,
 	preferredLanguage language.Tag,
-	gender int32,
+	gender domain.Gender,
 	emailAddress,
 	phoneNumber,
 	country,
@@ -143,8 +147,8 @@ func NewRegisteredEvent(
 	postalCode,
 	region,
 	streetAddress string,
-) *RegisteredEvent {
-	return &RegisteredEvent{
+) *HumanRegisteredEvent {
+	return &HumanRegisteredEvent{
 		BaseEvent: *eventstore.NewBaseEventForPush(
 			ctx,
 			HumanRegisteredType,
@@ -166,8 +170,8 @@ func NewRegisteredEvent(
 	}
 }
 
-func RegisteredEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	humanRegistered := &RegisteredEvent{
+func HumanRegisteredEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	humanRegistered := &HumanRegisteredEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 	err := json.Unmarshal(event.Data, humanRegistered)
@@ -178,22 +182,22 @@ func RegisteredEventMapper(event *repository.Event) (eventstore.EventReader, err
 	return humanRegistered, nil
 }
 
-type InitialCodeAddedEvent struct {
+type HumanInitialCodeAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 	Code                 *crypto.CryptoValue `json:"code,omitempty"`
 	Expiry               time.Duration       `json:"expiry,omitempty"`
 }
 
-func (e *InitialCodeAddedEvent) Data() interface{} {
+func (e *HumanInitialCodeAddedEvent) Data() interface{} {
 	return e
 }
 
-func NewInitialCodeAddedEvent(
+func NewHumanInitialCodeAddedEvent(
 	ctx context.Context,
 	code *crypto.CryptoValue,
 	expiry time.Duration,
-) *InitialCodeAddedEvent {
-	return &InitialCodeAddedEvent{
+) *HumanInitialCodeAddedEvent {
+	return &HumanInitialCodeAddedEvent{
 		BaseEvent: *eventstore.NewBaseEventForPush(
 			ctx,
 			HumanInitialCodeAddedType,
@@ -203,8 +207,8 @@ func NewInitialCodeAddedEvent(
 	}
 }
 
-func InitialCodeAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	humanRegistered := &InitialCodeAddedEvent{
+func HumanInitialCodeAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	humanRegistered := &HumanInitialCodeAddedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 	err := json.Unmarshal(event.Data, humanRegistered)
@@ -215,16 +219,16 @@ func InitialCodeAddedEventMapper(event *repository.Event) (eventstore.EventReade
 	return humanRegistered, nil
 }
 
-type InitialCodeSentEvent struct {
+type HumanInitialCodeSentEvent struct {
 	eventstore.BaseEvent `json:"-"`
 }
 
-func (e *InitialCodeSentEvent) Data() interface{} {
+func (e *HumanInitialCodeSentEvent) Data() interface{} {
 	return nil
 }
 
-func NewInitialCodeSentEvent(ctx context.Context) *InitialCodeSentEvent {
-	return &InitialCodeSentEvent{
+func NewHumanInitialCodeSentEvent(ctx context.Context) *HumanInitialCodeSentEvent {
+	return &HumanInitialCodeSentEvent{
 		BaseEvent: *eventstore.NewBaseEventForPush(
 			ctx,
 			HumanInitialCodeSentType,
@@ -232,22 +236,22 @@ func NewInitialCodeSentEvent(ctx context.Context) *InitialCodeSentEvent {
 	}
 }
 
-func InitialCodeSentEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	return &InitialCodeSentEvent{
+func HumanInitialCodeSentEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	return &HumanInitialCodeSentEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}, nil
 }
 
-type InitializedCheckSucceededEvent struct {
+type HumanInitializedCheckSucceededEvent struct {
 	eventstore.BaseEvent `json:"-"`
 }
 
-func (e *InitializedCheckSucceededEvent) Data() interface{} {
+func (e *HumanInitializedCheckSucceededEvent) Data() interface{} {
 	return nil
 }
 
-func NewInitializedCheckSucceededEvent(ctx context.Context) *InitializedCheckSucceededEvent {
-	return &InitializedCheckSucceededEvent{
+func NewHumanInitializedCheckSucceededEvent(ctx context.Context) *HumanInitializedCheckSucceededEvent {
+	return &HumanInitializedCheckSucceededEvent{
 		BaseEvent: *eventstore.NewBaseEventForPush(
 			ctx,
 			HumanInitializedCheckSucceededType,
@@ -255,22 +259,22 @@ func NewInitializedCheckSucceededEvent(ctx context.Context) *InitializedCheckSuc
 	}
 }
 
-func InitializedCheckSucceededEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	return &InitializedCheckSucceededEvent{
+func HumanInitializedCheckSucceededEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	return &HumanInitializedCheckSucceededEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}, nil
 }
 
-type InitializedCheckFailedEvent struct {
+type HumanInitializedCheckFailedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 }
 
-func (e *InitializedCheckFailedEvent) Data() interface{} {
+func (e *HumanInitializedCheckFailedEvent) Data() interface{} {
 	return nil
 }
 
-func NewInitializedCheckFailedEvent(ctx context.Context) *InitializedCheckFailedEvent {
-	return &InitializedCheckFailedEvent{
+func NewHumanInitializedCheckFailedEvent(ctx context.Context) *HumanInitializedCheckFailedEvent {
+	return &HumanInitializedCheckFailedEvent{
 		BaseEvent: *eventstore.NewBaseEventForPush(
 			ctx,
 			HumanInitializedCheckFailedType,
@@ -278,22 +282,22 @@ func NewInitializedCheckFailedEvent(ctx context.Context) *InitializedCheckFailed
 	}
 }
 
-func InitializedCheckFailedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	return &InitializedCheckFailedEvent{
+func HumanInitializedCheckFailedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	return &HumanInitializedCheckFailedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}, nil
 }
 
-type SignedOutEvent struct {
+type HumanSignedOutEvent struct {
 	eventstore.BaseEvent `json:"-"`
 }
 
-func (e *SignedOutEvent) Data() interface{} {
+func (e *HumanSignedOutEvent) Data() interface{} {
 	return nil
 }
 
-func NewSignedOutEvent(ctx context.Context) *SignedOutEvent {
-	return &SignedOutEvent{
+func NewHumanSignedOutEvent(ctx context.Context) *HumanSignedOutEvent {
+	return &HumanSignedOutEvent{
 		BaseEvent: *eventstore.NewBaseEventForPush(
 			ctx,
 			HumanSignedOutType,
@@ -301,8 +305,8 @@ func NewSignedOutEvent(ctx context.Context) *SignedOutEvent {
 	}
 }
 
-func SignedOutEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	return &SignedOutEvent{
+func HumanSignedOutEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	return &HumanSignedOutEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}, nil
 }

internal/v2/repository/user/human/address/write_model.go

@@ -1,13 +0,0 @@
-package address
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	Country       string
-	Locality      string
-	PostalCode    string
-	Region        string
-	StreetAddress string
-}