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 <fabienne.gerschwiler@gmail.com>

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)
-}