start implementing new eventstore on iam

internal/v2/repository/iam/aggregate.go

@@ -4,9 +4,37 @@ import (
 	"github.com/caos/zitadel/internal/eventstore/v2"
 )
 
+const (
+	iamEventTypePrefix = eventstore.EventType("iam.")
+)
+
+const (
+	AggregateType    = "iam"
+	AggregateVersion = "v1"
+)
+
 type Aggregate struct {
 	eventstore.Aggregate
 
 	SetUpStarted Step
 	SetUpDone    Step
 }
+
+func NewAggregate(
+	id,
+	resourceOwner string,
+	previousSequence uint64,
+) *Aggregate {
+
+	return &Aggregate{
+		Aggregate: *eventstore.NewAggregate(id, AggregateType, resourceOwner, AggregateVersion, previousSequence),
+	}
+}
+
+func AggregateFromReadModel(rm *ReadModel) *Aggregate {
+	return &Aggregate{
+		Aggregate:    *eventstore.NewAggregate(rm.AggregateID, AggregateType, rm.ResourceOwner, AggregateVersion, rm.ProcessedSequence),
+		SetUpDone:    rm.SetUpDone,
+		SetUpStarted: rm.SetUpStarted,
+	}
+}

internal/v2/repository/iam/event_iam_project_set.go

@@ -2,8 +2,11 @@ package iam
 
 import (
 	"context"
+	"encoding/json"
 
+	"github.com/caos/zitadel/internal/errors"
 	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
 )
 
 const (
@@ -33,3 +36,15 @@ func NewProjectSetEvent(ctx context.Context, projectID string) *ProjectSetEvent
 		ProjectID: projectID,
 	}
 }
+
+func ProjectSetMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &ProjectSetEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "IAM-cdFZH", "unable to unmarshal global org set")
+	}
+
+	return e, nil
+}

internal/v2/repository/iam/event_org_set.go

@@ -2,8 +2,11 @@ package iam
 
 import (
 	"context"
+	"encoding/json"
 
+	"github.com/caos/zitadel/internal/errors"
 	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
 )
 
 const (
@@ -33,3 +36,15 @@ func NewGlobalOrgSetEventEvent(ctx context.Context, orgID string) *GlobalOrgSetE
 		OrgID: orgID,
 	}
 }
+
+func GlobalOrgSetMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &GlobalOrgSetEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "IAM-cdFZH", "unable to unmarshal global org set")
+	}
+
+	return e, nil
+}

internal/v2/repository/iam/events_step.go

@@ -44,20 +44,30 @@ func SetupStepMapper(event *repository.Event) (eventstore.EventReader, error) {
 	return step, nil
 }
 
-func NewSetupStepDoneEvent(ctx context.Context) *SetupStepEvent {
+func NewSetupStepDoneEvent(
+	ctx context.Context,
+	step Step,
+) *SetupStepEvent {
+
 	return &SetupStepEvent{
 		BaseEvent: *eventstore.NewBaseEventForPush(
 			ctx,
 			SetupDoneEventType,
 		),
+		Step: step,
 	}
 }
 
-func NewSetupStepStartedEvent(ctx context.Context) *SetupStepEvent {
+func NewSetupStepStartedEvent(
+	ctx context.Context,
+	step Step,
+) *SetupStepEvent {
+
 	return &SetupStepEvent{
 		BaseEvent: *eventstore.NewBaseEventForPush(
 			ctx,
 			SetupStartedEventType,
 		),
+		Step: step,
 	}
 }

internal/v2/repository/iam/member.go

@@ -5,11 +5,6 @@ import (
 
 	"github.com/caos/zitadel/internal/eventstore/v2"
 	"github.com/caos/zitadel/internal/v2/repository/member"
-	"github.com/caos/zitadel/internal/v2/repository/members"
-)
-
-const (
-	iamEventTypePrefix = eventstore.EventType("iam.")
 )
 
 var (
@@ -18,24 +13,6 @@ var (
 	MemberRemovedEventType = iamEventTypePrefix + member.RemovedEventType
 )
 
-type MembersReadModel struct {
-	members.ReadModel
-}
-
-func (rm *MembersReadModel) AppendEvents(events ...eventstore.EventReader) (err error) {
-	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)
-		}
-	}
-	return nil
-}
-
 type MemberReadModel member.ReadModel
 
 func (rm *MemberReadModel) AppendEvents(events ...eventstore.EventReader) (err error) {
@@ -45,6 +22,8 @@ func (rm *MemberReadModel) AppendEvents(events ...eventstore.EventReader) (err e
 			rm.ReadModel.AppendEvents(&e.AddedEvent)
 		case *MemberChangedEvent:
 			rm.ReadModel.AppendEvents(&e.ChangedEvent)
+		case *member.AddedEvent, *member.ChangedEvent, *MemberRemovedEvent:
+			rm.ReadModel.AppendEvents(e)
 		}
 	}
 	return nil
@@ -68,7 +47,7 @@ func NewMemberAddedEvent(
 ) *MemberAddedEvent {
 
 	return &MemberAddedEvent{
-		AddedEvent: *member.NewMemberAddedEvent(
+		AddedEvent: *member.NewAddedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				MemberAddedEventType,
@@ -86,7 +65,7 @@ func NewMemberChangedEvent(
 ) *MemberChangedEvent {
 
 	return &MemberChangedEvent{
-		ChangedEvent: *member.NewMemberChangedEvent(
+		ChangedEvent: *member.NewChangedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				MemberChangedEventType,
@@ -103,7 +82,7 @@ func NewMemberRemovedEvent(
 ) *MemberRemovedEvent {
 
 	return &MemberRemovedEvent{
-		RemovedEvent: *member.NewMemberRemovedEvent(
+		RemovedEvent: *member.NewRemovedEvent(
 			eventstore.NewBaseEventForPush(
 				ctx,
 				MemberRemovedEventType,

internal/v2/repository/iam/members.go

@@ -0,0 +1,27 @@
+package iam
+
+import (
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/v2/repository/member"
+	"github.com/caos/zitadel/internal/v2/repository/members"
+)
+
+type MembersReadModel struct {
+	members.ReadModel
+}
+
+func (rm *MembersReadModel) AppendEvents(events ...eventstore.EventReader) (err error) {
+	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)
+		case *member.AddedEvent, *member.ChangedEvent, *member.RemovedEvent:
+			rm.ReadModel.AppendEvents(e)
+		}
+	}
+	return nil
+}

internal/v2/repository/iam/policy_label.go

@@ -0,0 +1,65 @@
+package iam
+
+import (
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+var (
+	LabelPolicyAddedEventType   = iamEventTypePrefix + policy.LabelPolicyAddedEventType
+	LabelPolicyChangedEventType = iamEventTypePrefix + policy.LabelPolicyChangedEventType
+)
+
+type LabelPolicyReadModel struct{ policy.LabelPolicyReadModel }
+
+func (rm *LabelPolicyReadModel) AppendEvents(events ...eventstore.EventReader) (err error) {
+	for _, event := range events {
+		switch e := event.(type) {
+		case *LabelPolicyAddedEvent:
+			rm.ReadModel.AppendEvents(&e.LabelPolicyAddedEvent)
+		case *LabelPolicyChangedEvent:
+			rm.ReadModel.AppendEvents(&e.LabelPolicyChangedEvent)
+		case *policy.LabelPolicyAddedEvent, *policy.LabelPolicyChangedEvent:
+			rm.ReadModel.AppendEvents(e)
+		}
+	}
+	return nil
+}
+
+type LabelPolicyAddedEvent struct {
+	policy.LabelPolicyAddedEvent
+}
+
+type LabelPolicyChangedEvent struct {
+	policy.LabelPolicyChangedEvent
+}
+
+// func NewLabelPolicyAddedEvent(
+// 	ctx context.Context,
+// 	primaryColor,
+// 	secondaryColor string,
+// ) *LabelPolicyAddedEvent {
+
+// 	return &LabelPolicyAddedEvent{
+// 		LabelPolicyAddedEvent: *policy.NewLabelPolicyAddedEvent(
+// 			ctx,
+// 			primaryColor,
+// 			secondaryColor,
+// 		),
+// 	}
+// }
+
+// func NewLabelPolicyChangedEvent(
+// 	ctx context.Context,
+// 	primaryColor,
+// 	secondaryColor string,
+// ) *MemberChangedEvent {
+
+// 	return &LabelPolicyChangedEvent{
+// 		LabelPolicyChangedEvent: *policy.NewLabelPolicyChangedEvent(
+// 			ctx,
+// 			primaryColor,
+// 			secondaryColor,
+// 		),
+// 	}
+// }

internal/v2/repository/iam/policy_login.go

@@ -0,0 +1,35 @@
+package iam
+
+import (
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+var (
+	LoginPolicyAddedEventType   = iamEventTypePrefix + policy.LoginPolicyAddedEventType
+	LoginPolicyChangedEventType = iamEventTypePrefix + policy.LoginPolicyChangedEventType
+)
+
+type LoginPolicyReadModel struct{ policy.LoginPolicyReadModel }
+
+func (rm *LoginPolicyReadModel) AppendEvents(events ...eventstore.EventReader) (err error) {
+	for _, event := range events {
+		switch e := event.(type) {
+		case *LoginPolicyAddedEvent:
+			rm.ReadModel.AppendEvents(&e.LoginPolicyAddedEvent)
+		case *LoginPolicyChangedEvent:
+			rm.ReadModel.AppendEvents(&e.LoginPolicyChangedEvent)
+		case *policy.LoginPolicyAddedEvent, *policy.LoginPolicyChangedEvent:
+			rm.ReadModel.AppendEvents(e)
+		}
+	}
+	return nil
+}
+
+type LoginPolicyAddedEvent struct {
+	policy.LoginPolicyAddedEvent
+}
+
+type LoginPolicyChangedEvent struct {
+	policy.LoginPolicyChangedEvent
+}

internal/v2/repository/iam/policy_org_iam.go

@@ -0,0 +1,28 @@
+package iam
+
+import (
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+var (
+	OrgIAMPolicyAddedEventType = iamEventTypePrefix + policy.OrgIAMPolicyAddedEventType
+)
+
+type OrgIAMPolicyReadModel struct{ policy.OrgIAMPolicyReadModel }
+
+func (rm *OrgIAMPolicyReadModel) AppendEvents(events ...eventstore.EventReader) (err error) {
+	for _, event := range events {
+		switch e := event.(type) {
+		case *OrgIAMPolicyAddedEvent:
+			rm.ReadModel.AppendEvents(&e.OrgIAMPolicyAddedEvent)
+		case *policy.OrgIAMPolicyAddedEvent:
+			rm.ReadModel.AppendEvents(e)
+		}
+	}
+	return nil
+}
+
+type OrgIAMPolicyAddedEvent struct {
+	policy.OrgIAMPolicyAddedEvent
+}

internal/v2/repository/iam/policy_password_age.go

@@ -0,0 +1,37 @@
+package iam
+
+import (
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+var (
+	PasswordAgePolicyAddedEventType   = iamEventTypePrefix + policy.PasswordAgePolicyAddedEventType
+	PasswordAgePolicyChangedEventType = iamEventTypePrefix + policy.PasswordAgePolicyChangedEventType
+)
+
+type PasswordAgePolicyReadModel struct {
+	policy.PasswordAgePolicyReadModel
+}
+
+func (rm *PasswordAgePolicyReadModel) AppendEvents(events ...eventstore.EventReader) (err error) {
+	for _, event := range events {
+		switch e := event.(type) {
+		case *PasswordAgePolicyAddedEvent:
+			rm.ReadModel.AppendEvents(&e.PasswordAgePolicyAddedEvent)
+		case *PasswordAgePolicyChangedEvent:
+			rm.ReadModel.AppendEvents(&e.PasswordAgePolicyChangedEvent)
+		case *policy.PasswordAgePolicyAddedEvent, *policy.PasswordAgePolicyChangedEvent:
+			rm.ReadModel.AppendEvents(e)
+		}
+	}
+	return nil
+}
+
+type PasswordAgePolicyAddedEvent struct {
+	policy.PasswordAgePolicyAddedEvent
+}
+
+type PasswordAgePolicyChangedEvent struct {
+	policy.PasswordAgePolicyChangedEvent
+}

internal/v2/repository/iam/policy_password_complexity.go

@@ -0,0 +1,37 @@
+package iam
+
+import (
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+var (
+	PasswordComplexityPolicyAddedEventType   = iamEventTypePrefix + policy.PasswordComplexityPolicyAddedEventType
+	PasswordComplexityPolicyChangedEventType = iamEventTypePrefix + policy.PasswordComplexityPolicyChangedEventType
+)
+
+type PasswordComplexityPolicyReadModel struct {
+	policy.PasswordComplexityPolicyReadModel
+}
+
+func (rm *PasswordComplexityPolicyReadModel) AppendEvents(events ...eventstore.EventReader) (err error) {
+	for _, event := range events {
+		switch e := event.(type) {
+		case *PasswordComplexityPolicyAddedEvent:
+			rm.ReadModel.AppendEvents(&e.PasswordComplexityPolicyAddedEvent)
+		case *PasswordComplexityPolicyChangedEvent:
+			rm.ReadModel.AppendEvents(&e.PasswordComplexityPolicyChangedEvent)
+		case *policy.PasswordComplexityPolicyAddedEvent, *policy.PasswordComplexityPolicyChangedEvent:
+			rm.ReadModel.AppendEvents(e)
+		}
+	}
+	return nil
+}
+
+type PasswordComplexityPolicyAddedEvent struct {
+	policy.PasswordComplexityPolicyAddedEvent
+}
+
+type PasswordComplexityPolicyChangedEvent struct {
+	policy.PasswordComplexityPolicyChangedEvent
+}

internal/v2/repository/iam/policy_password_lockout.go

@@ -0,0 +1,37 @@
+package iam
+
+import (
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/v2/repository/policy"
+)
+
+var (
+	PasswordLockoutPolicyAddedEventType   = iamEventTypePrefix + policy.PasswordLockoutPolicyAddedEventType
+	PasswordLockoutPolicyChangedEventType = iamEventTypePrefix + policy.PasswordLockoutPolicyChangedEventType
+)
+
+type PasswordLockoutPolicyReadModel struct {
+	policy.PasswordLockoutPolicyReadModel
+}
+
+func (rm *PasswordLockoutPolicyReadModel) AppendEvents(events ...eventstore.EventReader) (err error) {
+	for _, event := range events {
+		switch e := event.(type) {
+		case *PasswordLockoutPolicyAddedEvent:
+			rm.ReadModel.AppendEvents(&e.PasswordLockoutPolicyAddedEvent)
+		case *PasswordLockoutPolicyChangedEvent:
+			rm.ReadModel.AppendEvents(&e.PasswordLockoutPolicyChangedEvent)
+		case *policy.PasswordLockoutPolicyAddedEvent, *policy.PasswordLockoutPolicyChangedEvent:
+			rm.ReadModel.AppendEvents(e)
+		}
+	}
+	return nil
+}
+
+type PasswordLockoutPolicyAddedEvent struct {
+	policy.PasswordLockoutPolicyAddedEvent
+}
+
+type PasswordLockoutPolicyChangedEvent struct {
+	policy.PasswordLockoutPolicyChangedEvent
+}

internal/v2/repository/iam/read_model.go

@@ -17,12 +17,12 @@ type ReadModel struct {
 	GlobalOrgID string
 	ProjectID   string
 
-	DefaultLoginPolicy              policy.LoginPolicyReadModel
-	DefaultLabelPolicy              policy.LabelPolicyReadModel
-	DefaultOrgIAMPolicy             policy.OrgIAMPolicyReadModel
-	DefaultPasswordComplexityPolicy policy.PasswordComplexityPolicyReadModel
-	DefaultPasswordAgePolicy        policy.PasswordAgePolicyReadModel
-	DefaultPasswordLockoutPolicy    policy.PasswordLockoutPolicyReadModel
+	DefaultLoginPolicy              LoginPolicyReadModel
+	DefaultLabelPolicy              LabelPolicyReadModel
+	DefaultOrgIAMPolicy             OrgIAMPolicyReadModel
+	DefaultPasswordComplexityPolicy PasswordComplexityPolicyReadModel
+	DefaultPasswordAgePolicy        PasswordAgePolicyReadModel
+	DefaultPasswordLockoutPolicy    PasswordLockoutPolicyReadModel
 }
 
 func (rm *ReadModel) AppendEvents(events ...eventstore.EventReader) (err error) {
@@ -64,7 +64,6 @@ func (rm *ReadModel) Reduce() (err error) {
 		}
 	}
 	for _, reduce := range []func() error{
-		rm.Members.Reduce,
 		rm.Members.Reduce,
 		rm.DefaultLoginPolicy.Reduce,
 		rm.DefaultLabelPolicy.Reduce,
@@ -81,3 +80,10 @@ func (rm *ReadModel) Reduce() (err error) {
 
 	return nil
 }
+
+func (rm *ReadModel) AppendAndReduce(events ...eventstore.EventReader) error {
+	if err := rm.AppendEvents(events...); err != nil {
+		return err
+	}
+	return rm.Reduce()
+}