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