fix: rename iam to instance (#3345)

* fix: rename iam command side to instance

* fix: rename iam command side to instance

* fix: rename iam command side to instance

* fix: rename iam command side to instance

* fix: rename orgiampolicy to domain policy

* fix: merge conflicts

* fix: protos

* fix: md files

* implement deprecated org iam policy again

Co-authored-by: Livio Amstutz <livio.a@gmail.com>

internal/query/projection/custom_text.go

@@ -7,7 +7,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/policy"
 )
@@ -75,18 +75,18 @@ func (p *CustomTextProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.CustomTextSetEventType,
+					Event:  instance.CustomTextSetEventType,
 					Reduce: p.reduceSet,
 				},
 				{
-					Event:  iam.CustomTextRemovedEventType,
+					Event:  instance.CustomTextRemovedEventType,
 					Reduce: p.reduceRemoved,
 				},
 				{
-					Event:  iam.CustomTextTemplateRemovedEventType,
+					Event:  instance.CustomTextTemplateRemovedEventType,
 					Reduce: p.reduceTemplateRemoved,
 				},
 			},
@@ -101,11 +101,11 @@ func (p *CustomTextProjection) reduceSet(event eventstore.Event) (*handler.State
 	case *org.CustomTextSetEvent:
 		customTextEvent = e.CustomTextSetEvent
 		isDefault = false
-	case *iam.CustomTextSetEvent:
+	case *instance.CustomTextSetEvent:
 		customTextEvent = e.CustomTextSetEvent
 		isDefault = true
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-KKfw4", "reduce.wrong.event.type %v", []eventstore.EventType{org.CustomTextSetEventType, iam.CustomTextSetEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-KKfw4", "reduce.wrong.event.type %v", []eventstore.EventType{org.CustomTextSetEventType, instance.CustomTextSetEventType})
 	}
 	return crdb.NewUpsertStatement(
 		&customTextEvent,
@@ -128,10 +128,10 @@ func (p *CustomTextProjection) reduceRemoved(event eventstore.Event) (*handler.S
 	switch e := event.(type) {
 	case *org.CustomTextRemovedEvent:
 		customTextEvent = e.CustomTextRemovedEvent
-	case *iam.CustomTextRemovedEvent:
+	case *instance.CustomTextRemovedEvent:
 		customTextEvent = e.CustomTextRemovedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-n9wJg", "reduce.wrong.event.type %v", []eventstore.EventType{org.CustomTextRemovedEventType, iam.CustomTextRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-n9wJg", "reduce.wrong.event.type %v", []eventstore.EventType{org.CustomTextRemovedEventType, instance.CustomTextRemovedEventType})
 	}
 	return crdb.NewDeleteStatement(
 		&customTextEvent,
@@ -148,10 +148,10 @@ func (p *CustomTextProjection) reduceTemplateRemoved(event eventstore.Event) (*h
 	switch e := event.(type) {
 	case *org.CustomTextTemplateRemovedEvent:
 		customTextEvent = e.CustomTextTemplateRemovedEvent
-	case *iam.CustomTextTemplateRemovedEvent:
+	case *instance.CustomTextTemplateRemovedEvent:
 		customTextEvent = e.CustomTextTemplateRemovedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-29iPf", "reduce.wrong.event.type %v", []eventstore.EventType{org.CustomTextTemplateRemovedEventType, iam.CustomTextTemplateRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-29iPf", "reduce.wrong.event.type %v", []eventstore.EventType{org.CustomTextTemplateRemovedEventType, instance.CustomTextTemplateRemovedEventType})
 	}
 	return crdb.NewDeleteStatement(
 		&customTextEvent,

internal/query/projection/custom_text_test.go

@@ -7,7 +7,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -134,18 +134,18 @@ func TestCustomTextProjection_reduces(t *testing.T) {
 			reduce: (&CustomTextProjection{}).reduceSet,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.CustomTextSetEventType),
-					iam.AggregateType,
+					repository.EventType(instance.CustomTextSetEventType),
+					instance.AggregateType,
 					[]byte(`{
 					"key": "Text",
 						"language": "en",
 						"template": "InitCode",
 						"text": "Test"
 					}`),
-				), iam.CustomTextSetEventMapper),
+				), instance.CustomTextSetEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       CustomTextTable,
@@ -175,17 +175,17 @@ func TestCustomTextProjection_reduces(t *testing.T) {
 			reduce: (&CustomTextProjection{}).reduceRemoved,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.CustomTextTemplateRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.CustomTextTemplateRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"key": "Text",
 						"language": "en",
 						"template": "InitCode"
 					}`),
-				), iam.CustomTextRemovedEventMapper),
+				), instance.CustomTextRemovedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       CustomTextTable,
@@ -209,17 +209,17 @@ func TestCustomTextProjection_reduces(t *testing.T) {
 			reduce: (&CustomTextProjection{}).reduceTemplateRemoved,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.CustomTextTemplateRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.CustomTextTemplateRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"key": "Text",
 						"language": "en",
 						"template": "InitCode"
 					}`),
-				), iam.CustomTextTemplateRemovedEventMapper),
+				), instance.CustomTextTemplateRemovedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       CustomTextTable,

internal/query/projection/debug_notification.go

@@ -10,7 +10,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 )
 
 const (
@@ -57,30 +57,30 @@ func NewDebugNotificationProviderProjection(ctx context.Context, config crdb.Sta
 func (p *DebugNotificationProviderProjection) reducers() []handler.AggregateReducer {
 	return []handler.AggregateReducer{
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.DebugNotificationProviderFileAddedEventType,
+					Event:  instance.DebugNotificationProviderFileAddedEventType,
 					Reduce: p.reduceDebugNotificationProviderAdded,
 				},
 				{
-					Event:  iam.DebugNotificationProviderFileChangedEventType,
+					Event:  instance.DebugNotificationProviderFileChangedEventType,
 					Reduce: p.reduceDebugNotificationProviderChanged,
 				},
 				{
-					Event:  iam.DebugNotificationProviderFileRemovedEventType,
+					Event:  instance.DebugNotificationProviderFileRemovedEventType,
 					Reduce: p.reduceDebugNotificationProviderRemoved,
 				},
 				{
-					Event:  iam.DebugNotificationProviderLogAddedEventType,
+					Event:  instance.DebugNotificationProviderLogAddedEventType,
 					Reduce: p.reduceDebugNotificationProviderAdded,
 				},
 				{
-					Event:  iam.DebugNotificationProviderLogChangedEventType,
+					Event:  instance.DebugNotificationProviderLogChangedEventType,
 					Reduce: p.reduceDebugNotificationProviderChanged,
 				},
 				{
-					Event:  iam.DebugNotificationProviderLogRemovedEventType,
+					Event:  instance.DebugNotificationProviderLogRemovedEventType,
 					Reduce: p.reduceDebugNotificationProviderRemoved,
 				},
 			},
@@ -92,14 +92,14 @@ func (p *DebugNotificationProviderProjection) reduceDebugNotificationProviderAdd
 	var providerEvent settings.DebugNotificationProviderAddedEvent
 	var providerType domain.NotificationProviderType
 	switch e := event.(type) {
-	case *iam.DebugNotificationProviderFileAddedEvent:
+	case *instance.DebugNotificationProviderFileAddedEvent:
 		providerEvent = e.DebugNotificationProviderAddedEvent
 		providerType = domain.NotificationProviderTypeFile
-	case *iam.DebugNotificationProviderLogAddedEvent:
+	case *instance.DebugNotificationProviderLogAddedEvent:
 		providerEvent = e.DebugNotificationProviderAddedEvent
 		providerType = domain.NotificationProviderTypeLog
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-pYPxS", "reduce.wrong.event.type %v", []eventstore.EventType{iam.DebugNotificationProviderFileAddedEventType, iam.DebugNotificationProviderLogAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-pYPxS", "reduce.wrong.event.type %v", []eventstore.EventType{instance.DebugNotificationProviderFileAddedEventType, instance.DebugNotificationProviderLogAddedEventType})
 	}
 
 	return crdb.NewCreateStatement(&providerEvent, []handler.Column{
@@ -119,14 +119,14 @@ func (p *DebugNotificationProviderProjection) reduceDebugNotificationProviderCha
 	var providerEvent settings.DebugNotificationProviderChangedEvent
 	var providerType domain.NotificationProviderType
 	switch e := event.(type) {
-	case *iam.DebugNotificationProviderFileChangedEvent:
+	case *instance.DebugNotificationProviderFileChangedEvent:
 		providerEvent = e.DebugNotificationProviderChangedEvent
 		providerType = domain.NotificationProviderTypeFile
-	case *iam.DebugNotificationProviderLogChangedEvent:
+	case *instance.DebugNotificationProviderLogChangedEvent:
 		providerEvent = e.DebugNotificationProviderChangedEvent
 		providerType = domain.NotificationProviderTypeLog
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-pYPxS", "reduce.wrong.event.type %v", []eventstore.EventType{iam.DebugNotificationProviderFileChangedEventType, iam.DebugNotificationProviderLogChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-pYPxS", "reduce.wrong.event.type %v", []eventstore.EventType{instance.DebugNotificationProviderFileChangedEventType, instance.DebugNotificationProviderLogChangedEventType})
 	}
 
 	cols := []handler.Column{
@@ -151,14 +151,14 @@ func (p *DebugNotificationProviderProjection) reduceDebugNotificationProviderRem
 	var providerEvent settings.DebugNotificationProviderRemovedEvent
 	var providerType domain.NotificationProviderType
 	switch e := event.(type) {
-	case *iam.DebugNotificationProviderFileRemovedEvent:
+	case *instance.DebugNotificationProviderFileRemovedEvent:
 		providerEvent = e.DebugNotificationProviderRemovedEvent
 		providerType = domain.NotificationProviderTypeFile
-	case *iam.DebugNotificationProviderLogRemovedEvent:
+	case *instance.DebugNotificationProviderLogRemovedEvent:
 		providerEvent = e.DebugNotificationProviderRemovedEvent
 		providerType = domain.NotificationProviderTypeLog
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-dow9f", "reduce.wrong.event.type %v", []eventstore.EventType{iam.DebugNotificationProviderFileRemovedEventType, iam.DebugNotificationProviderLogRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-dow9f", "reduce.wrong.event.type %v", []eventstore.EventType{instance.DebugNotificationProviderFileRemovedEventType, instance.DebugNotificationProviderLogRemovedEventType})
 	}
 
 	return crdb.NewDeleteStatement(

internal/query/projection/debug_notification_provider_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 )
 
 func TestDebugNotificationProviderProjection_reduces(t *testing.T) {
@@ -22,19 +22,19 @@ func TestDebugNotificationProviderProjection_reduces(t *testing.T) {
 		want   wantReduce
 	}{
 		{
-			name:   "iam.reduceNotificationProviderFileAdded",
+			name:   "instance.reduceNotificationProviderFileAdded",
 			reduce: (&DebugNotificationProviderProjection{}).reduceDebugNotificationProviderAdded,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.DebugNotificationProviderFileAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.DebugNotificationProviderFileAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"compact": true
 			}`),
-				), iam.DebugNotificationProviderFileAddedEventMapper),
+				), instance.DebugNotificationProviderFileAddedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       DebugNotificationProviderTable,
@@ -59,19 +59,19 @@ func TestDebugNotificationProviderProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceNotificationProviderFileChanged",
+			name:   "instance.reduceNotificationProviderFileChanged",
 			reduce: (&DebugNotificationProviderProjection{}).reduceDebugNotificationProviderChanged,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.DebugNotificationProviderFileChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.DebugNotificationProviderFileChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 				"compact": true
 			}`),
-				), iam.DebugNotificationProviderFileChangedEventMapper),
+				), instance.DebugNotificationProviderFileChangedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       DebugNotificationProviderTable,
@@ -92,17 +92,17 @@ func TestDebugNotificationProviderProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceNotificationProviderFileRemoved",
+			name:   "instance.reduceNotificationProviderFileRemoved",
 			reduce: (&DebugNotificationProviderProjection{}).reduceDebugNotificationProviderRemoved,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.DebugNotificationProviderFileRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.DebugNotificationProviderFileRemovedEventType),
+					instance.AggregateType,
 					nil,
-				), iam.DebugNotificationProviderFileRemovedEventMapper),
+				), instance.DebugNotificationProviderFileRemovedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       DebugNotificationProviderTable,
@@ -120,19 +120,19 @@ func TestDebugNotificationProviderProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceNotificationProviderLogAdded",
+			name:   "instance.reduceNotificationProviderLogAdded",
 			reduce: (&DebugNotificationProviderProjection{}).reduceDebugNotificationProviderAdded,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.DebugNotificationProviderLogAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.DebugNotificationProviderLogAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"compact": true
 			}`),
-				), iam.DebugNotificationProviderLogAddedEventMapper),
+				), instance.DebugNotificationProviderLogAddedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       DebugNotificationProviderTable,
@@ -157,19 +157,19 @@ func TestDebugNotificationProviderProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceNotificationProviderLogChanged",
+			name:   "instance.reduceNotificationProviderLogChanged",
 			reduce: (&DebugNotificationProviderProjection{}).reduceDebugNotificationProviderChanged,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.DebugNotificationProviderLogChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.DebugNotificationProviderLogChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 				"compact": true
 			}`),
-				), iam.DebugNotificationProviderLogChangedEventMapper),
+				), instance.DebugNotificationProviderLogChangedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       DebugNotificationProviderTable,
@@ -190,17 +190,17 @@ func TestDebugNotificationProviderProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceNotificationProviderLogRemoved",
+			name:   "instance.reduceNotificationProviderLogRemoved",
 			reduce: (&DebugNotificationProviderProjection{}).reduceDebugNotificationProviderRemoved,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.DebugNotificationProviderLogRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.DebugNotificationProviderLogRemovedEventType),
+					instance.AggregateType,
 					nil,
-				), iam.DebugNotificationProviderLogRemovedEventMapper),
+				), instance.DebugNotificationProviderLogRemovedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       DebugNotificationProviderTable,

internal/query/projection/feature.go

@@ -10,7 +10,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
 	"github.com/caos/zitadel/internal/repository/features"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -107,10 +107,10 @@ func (p *FeatureProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.FeaturesSetEventType,
+					Event:  instance.FeaturesSetEventType,
 					Reduce: p.reduceFeatureSet,
 				},
 			},
@@ -122,14 +122,14 @@ func (p *FeatureProjection) reduceFeatureSet(event eventstore.Event) (*handler.S
 	var featureEvent features.FeaturesSetEvent
 	var isDefault bool
 	switch e := event.(type) {
-	case *iam.FeaturesSetEvent:
+	case *instance.FeaturesSetEvent:
 		featureEvent = e.FeaturesSetEvent
 		isDefault = true
 	case *org.FeaturesSetEvent:
 		featureEvent = e.FeaturesSetEvent
 		isDefault = false
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-K0erf", "reduce.wrong.event.type %v", []eventstore.EventType{org.FeaturesSetEventType, iam.FeaturesSetEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-K0erf", "reduce.wrong.event.type %v", []eventstore.EventType{org.FeaturesSetEventType, instance.FeaturesSetEventType})
 	}
 
 	cols := []handler.Column{

internal/query/projection/feature_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -232,12 +232,12 @@ func TestFeatureProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceFeatureSet old",
+			name:   "instance.reduceFeatureSet old",
 			reduce: (&FeatureProjection{}).reduceFeatureSet,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.FeaturesSetEventType),
-					iam.AggregateType,
+					repository.EventType(instance.FeaturesSetEventType),
+					instance.AggregateType,
 					[]byte(`{
 				"tierName": "TierName",
 				"tierDescription": "TierDescription",
@@ -261,10 +261,10 @@ func TestFeatureProjection_reduces(t *testing.T) {
 				"lockoutPolicy": true,
 				"actions": true
 			}`),
-				), iam.FeaturesSetEventMapper),
+				), instance.FeaturesSetEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       FeatureTable,
@@ -306,12 +306,12 @@ func TestFeatureProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceFeatureSet new",
+			name:   "instance.reduceFeatureSet new",
 			reduce: (&FeatureProjection{}).reduceFeatureSet,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.FeaturesSetEventType),
-					iam.AggregateType,
+					repository.EventType(instance.FeaturesSetEventType),
+					instance.AggregateType,
 					[]byte(`{
 				"tierName": "TierName",
 				"tierDescription": "TierDescription",
@@ -336,10 +336,10 @@ func TestFeatureProjection_reduces(t *testing.T) {
 				"actionsAllowed": 1,
 				"maxActions": 10
 			}`),
-				), iam.FeaturesSetEventMapper),
+				), instance.FeaturesSetEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       FeatureTable,

internal/query/projection/iam.go

@@ -1,149 +0,0 @@
-package projection
-
-import (
-	"context"
-
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore"
-	"github.com/caos/zitadel/internal/eventstore/handler"
-	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
-)
-
-const (
-	IAMProjectionTable = "projections.iam"
-
-	IAMColumnID              = "id"
-	IAMColumnChangeDate      = "change_date"
-	IAMColumnGlobalOrgID     = "global_org_id"
-	IAMColumnProjectID       = "iam_project_id"
-	IAMColumnSequence        = "sequence"
-	IAMColumnSetUpStarted    = "setup_started"
-	IAMColumnSetUpDone       = "setup_done"
-	IAMColumnDefaultLanguage = "default_language"
-)
-
-type IAMProjection struct {
-	crdb.StatementHandler
-}
-
-func NewIAMProjection(ctx context.Context, config crdb.StatementHandlerConfig) *IAMProjection {
-	p := new(IAMProjection)
-	config.ProjectionName = IAMProjectionTable
-	config.Reducers = p.reducers()
-	config.InitCheck = crdb.NewTableCheck(
-		crdb.NewTable([]*crdb.Column{
-			crdb.NewColumn(IAMColumnID, crdb.ColumnTypeText),
-			crdb.NewColumn(IAMColumnChangeDate, crdb.ColumnTypeTimestamp),
-			crdb.NewColumn(IAMColumnGlobalOrgID, crdb.ColumnTypeText, crdb.Default("")),
-			crdb.NewColumn(IAMColumnProjectID, crdb.ColumnTypeText, crdb.Default("")),
-			crdb.NewColumn(IAMColumnSequence, crdb.ColumnTypeInt64),
-			crdb.NewColumn(IAMColumnSetUpStarted, crdb.ColumnTypeInt64, crdb.Default(0)),
-			crdb.NewColumn(IAMColumnSetUpDone, crdb.ColumnTypeInt64, crdb.Default(0)),
-			crdb.NewColumn(IAMColumnDefaultLanguage, crdb.ColumnTypeText, crdb.Default("")),
-		},
-			crdb.NewPrimaryKey(IAMColumnID),
-		),
-	)
-	p.StatementHandler = crdb.NewStatementHandler(ctx, config)
-	return p
-}
-
-func (p *IAMProjection) reducers() []handler.AggregateReducer {
-	return []handler.AggregateReducer{
-		{
-			Aggregate: iam.AggregateType,
-			EventRedusers: []handler.EventReducer{
-				{
-					Event:  iam.GlobalOrgSetEventType,
-					Reduce: p.reduceGlobalOrgSet,
-				},
-				{
-					Event:  iam.ProjectSetEventType,
-					Reduce: p.reduceIAMProjectSet,
-				},
-				{
-					Event:  iam.DefaultLanguageSetEventType,
-					Reduce: p.reduceDefaultLanguageSet,
-				},
-				{
-					Event:  iam.SetupStartedEventType,
-					Reduce: p.reduceSetupEvent,
-				},
-				{
-					Event:  iam.SetupDoneEventType,
-					Reduce: p.reduceSetupEvent,
-				},
-			},
-		},
-	}
-}
-
-func (p *IAMProjection) reduceGlobalOrgSet(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.GlobalOrgSetEvent)
-	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-2n9f2", "reduce.wrong.event.type %s", iam.GlobalOrgSetEventType)
-	}
-	return crdb.NewUpsertStatement(
-		e,
-		[]handler.Column{
-			handler.NewCol(IAMColumnID, e.Aggregate().InstanceID),
-			handler.NewCol(IAMColumnChangeDate, e.CreationDate()),
-			handler.NewCol(IAMColumnSequence, e.Sequence()),
-			handler.NewCol(IAMColumnGlobalOrgID, e.OrgID),
-		},
-	), nil
-}
-
-func (p *IAMProjection) reduceIAMProjectSet(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.ProjectSetEvent)
-	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-30o0e", "reduce.wrong.event.type %s", iam.ProjectSetEventType)
-	}
-	return crdb.NewUpsertStatement(
-		e,
-		[]handler.Column{
-			handler.NewCol(IAMColumnID, e.Aggregate().InstanceID),
-			handler.NewCol(IAMColumnChangeDate, e.CreationDate()),
-			handler.NewCol(IAMColumnSequence, e.Sequence()),
-			handler.NewCol(IAMColumnProjectID, e.ProjectID),
-		},
-	), nil
-}
-
-func (p *IAMProjection) reduceDefaultLanguageSet(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.DefaultLanguageSetEvent)
-	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-30o0e", "reduce.wrong.event.type %s", iam.DefaultLanguageSetEventType)
-	}
-	return crdb.NewUpsertStatement(
-		e,
-		[]handler.Column{
-			handler.NewCol(IAMColumnID, e.Aggregate().InstanceID),
-			handler.NewCol(IAMColumnChangeDate, e.CreationDate()),
-			handler.NewCol(IAMColumnSequence, e.Sequence()),
-			handler.NewCol(IAMColumnDefaultLanguage, e.Language.String()),
-		},
-	), nil
-}
-
-func (p *IAMProjection) reduceSetupEvent(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.SetupStepEvent)
-	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-d9nfw", "reduce.wrong.event.type %v", []eventstore.EventType{iam.SetupDoneEventType, iam.SetupStartedEventType})
-	}
-	columns := []handler.Column{
-		handler.NewCol(IAMColumnID, e.Aggregate().InstanceID),
-		handler.NewCol(IAMColumnChangeDate, e.CreationDate()),
-		handler.NewCol(IAMColumnSequence, e.Sequence()),
-	}
-	if e.EventType == iam.SetupStartedEventType {
-		columns = append(columns, handler.NewCol(IAMColumnSetUpStarted, e.Step))
-	} else {
-		columns = append(columns, handler.NewCol(IAMColumnSetUpDone, e.Step))
-	}
-	return crdb.NewUpsertStatement(
-		e,
-		columns,
-	), nil
-}

internal/query/projection/iam_member.go

@@ -1,113 +0,0 @@
-package projection
-
-import (
-	"context"
-
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore"
-	"github.com/caos/zitadel/internal/eventstore/handler"
-	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
-	"github.com/caos/zitadel/internal/repository/user"
-)
-
-const (
-	IAMMemberProjectionTable = "projections.iam_members"
-
-	IAMMemberIAMIDCol = "iam_id"
-)
-
-type IAMMemberProjection struct {
-	crdb.StatementHandler
-}
-
-func NewIAMMemberProjection(ctx context.Context, config crdb.StatementHandlerConfig) *IAMMemberProjection {
-	p := new(IAMMemberProjection)
-	config.ProjectionName = IAMMemberProjectionTable
-	config.Reducers = p.reducers()
-	config.InitCheck = crdb.NewTableCheck(
-		crdb.NewTable(
-			append(memberColumns, crdb.NewColumn(IAMColumnID, crdb.ColumnTypeText)),
-			crdb.NewPrimaryKey(MemberInstanceID, IAMColumnID, MemberUserIDCol),
-			crdb.NewIndex("user_idx", []string{MemberUserIDCol}),
-		),
-	)
-
-	p.StatementHandler = crdb.NewStatementHandler(ctx, config)
-	return p
-}
-
-func (p *IAMMemberProjection) reducers() []handler.AggregateReducer {
-	return []handler.AggregateReducer{
-		{
-			Aggregate: iam.AggregateType,
-			EventRedusers: []handler.EventReducer{
-				{
-					Event:  iam.MemberAddedEventType,
-					Reduce: p.reduceAdded,
-				},
-				{
-					Event:  iam.MemberChangedEventType,
-					Reduce: p.reduceChanged,
-				},
-				{
-					Event:  iam.MemberCascadeRemovedEventType,
-					Reduce: p.reduceCascadeRemoved,
-				},
-				{
-					Event:  iam.MemberRemovedEventType,
-					Reduce: p.reduceRemoved,
-				},
-			},
-		},
-		{
-			Aggregate: user.AggregateType,
-			EventRedusers: []handler.EventReducer{
-				{
-					Event:  user.UserRemovedType,
-					Reduce: p.reduceUserRemoved,
-				},
-			},
-		},
-	}
-}
-
-func (p *IAMMemberProjection) reduceAdded(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.MemberAddedEvent)
-	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-pGNCu", "reduce.wrong.event.type %s", iam.MemberAddedEventType)
-	}
-	return reduceMemberAdded(e.MemberAddedEvent, withMemberCol(IAMMemberIAMIDCol, e.Aggregate().ID))
-}
-
-func (p *IAMMemberProjection) reduceChanged(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.MemberChangedEvent)
-	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-5WQcZ", "reduce.wrong.event.type %s", iam.MemberChangedEventType)
-	}
-	return reduceMemberChanged(e.MemberChangedEvent)
-}
-
-func (p *IAMMemberProjection) reduceCascadeRemoved(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.MemberCascadeRemovedEvent)
-	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-Dmdf2", "reduce.wrong.event.type %s", iam.MemberCascadeRemovedEventType)
-	}
-	return reduceMemberCascadeRemoved(e.MemberCascadeRemovedEvent)
-}
-
-func (p *IAMMemberProjection) reduceRemoved(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.MemberRemovedEvent)
-	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-exVqy", "reduce.wrong.event.type %s", iam.MemberRemovedEventType)
-	}
-	return reduceMemberRemoved(e, withMemberCond(MemberUserIDCol, e.UserID))
-}
-
-func (p *IAMMemberProjection) reduceUserRemoved(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*user.UserRemovedEvent)
-	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-mkDHF", "reduce.wrong.event.type %s", user.UserRemovedType)
-	}
-	return reduceMemberRemoved(e, withMemberCond(MemberUserIDCol, e.Aggregate().ID))
-}

internal/query/projection/idp.go

@@ -10,8 +10,8 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
 	"github.com/caos/zitadel/internal/repository/idpconfig"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -111,42 +111,42 @@ func NewIDPProjection(ctx context.Context, config crdb.StatementHandlerConfig) *
 func (p *IDPProjection) reducers() []handler.AggregateReducer {
 	return []handler.AggregateReducer{
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.IDPConfigAddedEventType,
+					Event:  instance.IDPConfigAddedEventType,
 					Reduce: p.reduceIDPAdded,
 				},
 				{
-					Event:  iam.IDPConfigChangedEventType,
+					Event:  instance.IDPConfigChangedEventType,
 					Reduce: p.reduceIDPChanged,
 				},
 				{
-					Event:  iam.IDPConfigDeactivatedEventType,
+					Event:  instance.IDPConfigDeactivatedEventType,
 					Reduce: p.reduceIDPDeactivated,
 				},
 				{
-					Event:  iam.IDPConfigReactivatedEventType,
+					Event:  instance.IDPConfigReactivatedEventType,
 					Reduce: p.reduceIDPReactivated,
 				},
 				{
-					Event:  iam.IDPConfigRemovedEventType,
+					Event:  instance.IDPConfigRemovedEventType,
 					Reduce: p.reduceIDPRemoved,
 				},
 				{
-					Event:  iam.IDPOIDCConfigAddedEventType,
+					Event:  instance.IDPOIDCConfigAddedEventType,
 					Reduce: p.reduceOIDCConfigAdded,
 				},
 				{
-					Event:  iam.IDPOIDCConfigChangedEventType,
+					Event:  instance.IDPOIDCConfigChangedEventType,
 					Reduce: p.reduceOIDCConfigChanged,
 				},
 				{
-					Event:  iam.IDPJWTConfigAddedEventType,
+					Event:  instance.IDPJWTConfigAddedEventType,
 					Reduce: p.reduceJWTConfigAdded,
 				},
 				{
-					Event:  iam.IDPJWTConfigChangedEventType,
+					Event:  instance.IDPJWTConfigChangedEventType,
 					Reduce: p.reduceJWTConfigChanged,
 				},
 			},
@@ -202,11 +202,11 @@ func (p *IDPProjection) reduceIDPAdded(event eventstore.Event) (*handler.Stateme
 	case *org.IDPConfigAddedEvent:
 		idpEvent = e.IDPConfigAddedEvent
 		idpOwnerType = domain.IdentityProviderTypeOrg
-	case *iam.IDPConfigAddedEvent:
+	case *instance.IDPConfigAddedEvent:
 		idpEvent = e.IDPConfigAddedEvent
 		idpOwnerType = domain.IdentityProviderTypeSystem
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-fcUdQ", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigAddedEventType, iam.IDPConfigAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-fcUdQ", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigAddedEventType, instance.IDPConfigAddedEventType})
 	}
 
 	return crdb.NewCreateStatement(
@@ -232,10 +232,10 @@ func (p *IDPProjection) reduceIDPChanged(event eventstore.Event) (*handler.State
 	switch e := event.(type) {
 	case *org.IDPConfigChangedEvent:
 		idpEvent = e.IDPConfigChangedEvent
-	case *iam.IDPConfigChangedEvent:
+	case *instance.IDPConfigChangedEvent:
 		idpEvent = e.IDPConfigChangedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-NVvJD", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigChangedEventType, iam.IDPConfigChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-NVvJD", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigChangedEventType, instance.IDPConfigChangedEventType})
 	}
 
 	cols := make([]handler.Column, 0, 5)
@@ -271,10 +271,10 @@ func (p *IDPProjection) reduceIDPDeactivated(event eventstore.Event) (*handler.S
 	switch e := event.(type) {
 	case *org.IDPConfigDeactivatedEvent:
 		idpEvent = e.IDPConfigDeactivatedEvent
-	case *iam.IDPConfigDeactivatedEvent:
+	case *instance.IDPConfigDeactivatedEvent:
 		idpEvent = e.IDPConfigDeactivatedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-94O5l", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigDeactivatedEventType, iam.IDPConfigDeactivatedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-94O5l", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigDeactivatedEventType, instance.IDPConfigDeactivatedEventType})
 	}
 
 	return crdb.NewUpdateStatement(
@@ -295,10 +295,10 @@ func (p *IDPProjection) reduceIDPReactivated(event eventstore.Event) (*handler.S
 	switch e := event.(type) {
 	case *org.IDPConfigReactivatedEvent:
 		idpEvent = e.IDPConfigReactivatedEvent
-	case *iam.IDPConfigReactivatedEvent:
+	case *instance.IDPConfigReactivatedEvent:
 		idpEvent = e.IDPConfigReactivatedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-I8QyS", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigReactivatedEventType, iam.IDPConfigReactivatedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-I8QyS", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigReactivatedEventType, instance.IDPConfigReactivatedEventType})
 	}
 
 	return crdb.NewUpdateStatement(
@@ -319,10 +319,10 @@ func (p *IDPProjection) reduceIDPRemoved(event eventstore.Event) (*handler.State
 	switch e := event.(type) {
 	case *org.IDPConfigRemovedEvent:
 		idpEvent = e.IDPConfigRemovedEvent
-	case *iam.IDPConfigRemovedEvent:
+	case *instance.IDPConfigRemovedEvent:
 		idpEvent = e.IDPConfigRemovedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-B4zy8", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigRemovedEventType, iam.IDPConfigRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-B4zy8", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigRemovedEventType, instance.IDPConfigRemovedEventType})
 	}
 
 	return crdb.NewDeleteStatement(
@@ -338,10 +338,10 @@ func (p *IDPProjection) reduceOIDCConfigAdded(event eventstore.Event) (*handler.
 	switch e := event.(type) {
 	case *org.IDPOIDCConfigAddedEvent:
 		idpEvent = e.OIDCConfigAddedEvent
-	case *iam.IDPOIDCConfigAddedEvent:
+	case *instance.IDPOIDCConfigAddedEvent:
 		idpEvent = e.OIDCConfigAddedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-2FuAA", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPOIDCConfigAddedEventType, iam.IDPOIDCConfigAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-2FuAA", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPOIDCConfigAddedEventType, instance.IDPOIDCConfigAddedEventType})
 	}
 
 	return crdb.NewMultiStatement(&idpEvent,
@@ -377,10 +377,10 @@ func (p *IDPProjection) reduceOIDCConfigChanged(event eventstore.Event) (*handle
 	switch e := event.(type) {
 	case *org.IDPOIDCConfigChangedEvent:
 		idpEvent = e.OIDCConfigChangedEvent
-	case *iam.IDPOIDCConfigChangedEvent:
+	case *instance.IDPOIDCConfigChangedEvent:
 		idpEvent = e.OIDCConfigChangedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-x2IVI", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPOIDCConfigChangedEventType, iam.IDPOIDCConfigChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-x2IVI", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPOIDCConfigChangedEventType, instance.IDPOIDCConfigChangedEventType})
 	}
 
 	cols := make([]handler.Column, 0, 8)
@@ -439,10 +439,10 @@ func (p *IDPProjection) reduceJWTConfigAdded(event eventstore.Event) (*handler.S
 	switch e := event.(type) {
 	case *org.IDPJWTConfigAddedEvent:
 		idpEvent = e.JWTConfigAddedEvent
-	case *iam.IDPJWTConfigAddedEvent:
+	case *instance.IDPJWTConfigAddedEvent:
 		idpEvent = e.JWTConfigAddedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-qvPdb", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPJWTConfigAddedEventType, iam.IDPJWTConfigAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-qvPdb", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPJWTConfigAddedEventType, instance.IDPJWTConfigAddedEventType})
 	}
 
 	return crdb.NewMultiStatement(&idpEvent,
@@ -475,10 +475,10 @@ func (p *IDPProjection) reduceJWTConfigChanged(event eventstore.Event) (*handler
 	switch e := event.(type) {
 	case *org.IDPJWTConfigChangedEvent:
 		idpEvent = e.JWTConfigChangedEvent
-	case *iam.IDPJWTConfigChangedEvent:
+	case *instance.IDPJWTConfigChangedEvent:
 		idpEvent = e.JWTConfigChangedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-x2IVI", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPJWTConfigChangedEventType, iam.IDPJWTConfigChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-x2IVI", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPJWTConfigChangedEventType, instance.IDPJWTConfigChangedEventType})
 	}
 
 	cols := make([]handler.Column, 0, 4)

internal/query/projection/idp_login_policy_link.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/policy"
 )
@@ -80,22 +80,22 @@ func (p *IDPLoginPolicyLinkProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.LoginPolicyIDPProviderAddedEventType,
+					Event:  instance.LoginPolicyIDPProviderAddedEventType,
 					Reduce: p.reduceAdded,
 				},
 				{
-					Event:  iam.LoginPolicyIDPProviderCascadeRemovedEventType,
+					Event:  instance.LoginPolicyIDPProviderCascadeRemovedEventType,
 					Reduce: p.reduceCascadeRemoved,
 				},
 				{
-					Event:  iam.LoginPolicyIDPProviderRemovedEventType,
+					Event:  instance.LoginPolicyIDPProviderRemovedEventType,
 					Reduce: p.reduceRemoved,
 				},
 				{
-					Event:  iam.IDPConfigRemovedEventType,
+					Event:  instance.IDPConfigRemovedEventType,
 					Reduce: p.reduceIDPConfigRemoved,
 				},
 			},
@@ -113,11 +113,11 @@ func (p *IDPLoginPolicyLinkProjection) reduceAdded(event eventstore.Event) (*han
 	case *org.IdentityProviderAddedEvent:
 		idp = e.IdentityProviderAddedEvent
 		providerType = domain.IdentityProviderTypeOrg
-	case *iam.IdentityProviderAddedEvent:
+	case *instance.IdentityProviderAddedEvent:
 		idp = e.IdentityProviderAddedEvent
 		providerType = domain.IdentityProviderTypeSystem
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-Nlp55", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyIDPProviderAddedEventType, iam.LoginPolicyIDPProviderAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-Nlp55", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyIDPProviderAddedEventType, instance.LoginPolicyIDPProviderAddedEventType})
 	}
 
 	return crdb.NewCreateStatement(&idp,
@@ -140,10 +140,10 @@ func (p *IDPLoginPolicyLinkProjection) reduceRemoved(event eventstore.Event) (*h
 	switch e := event.(type) {
 	case *org.IdentityProviderRemovedEvent:
 		idp = e.IdentityProviderRemovedEvent
-	case *iam.IdentityProviderRemovedEvent:
+	case *instance.IdentityProviderRemovedEvent:
 		idp = e.IdentityProviderRemovedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-tUMYY", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyIDPProviderRemovedEventType, iam.LoginPolicyIDPProviderRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-tUMYY", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyIDPProviderRemovedEventType, instance.LoginPolicyIDPProviderRemovedEventType})
 	}
 
 	return crdb.NewDeleteStatement(&idp,
@@ -160,10 +160,10 @@ func (p *IDPLoginPolicyLinkProjection) reduceCascadeRemoved(event eventstore.Eve
 	switch e := event.(type) {
 	case *org.IdentityProviderCascadeRemovedEvent:
 		idp = e.IdentityProviderCascadeRemovedEvent
-	case *iam.IdentityProviderCascadeRemovedEvent:
+	case *instance.IdentityProviderCascadeRemovedEvent:
 		idp = e.IdentityProviderCascadeRemovedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-iCKSj", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyIDPProviderCascadeRemovedEventType, iam.LoginPolicyIDPProviderCascadeRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-iCKSj", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyIDPProviderCascadeRemovedEventType, instance.LoginPolicyIDPProviderCascadeRemovedEventType})
 	}
 
 	return crdb.NewDeleteStatement(&idp,
@@ -180,10 +180,10 @@ func (p *IDPLoginPolicyLinkProjection) reduceIDPConfigRemoved(event eventstore.E
 	switch e := event.(type) {
 	case *org.IDPConfigRemovedEvent:
 		idpID = e.ConfigID
-	case *iam.IDPConfigRemovedEvent:
+	case *instance.IDPConfigRemovedEvent:
 		idpID = e.ConfigID
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-u6tze", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigRemovedEventType, iam.IDPConfigRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-u6tze", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigRemovedEventType, instance.IDPConfigRemovedEventType})
 	}
 
 	return crdb.NewDeleteStatement(event,

internal/query/projection/idp_login_policy_link_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -26,17 +26,17 @@ func TestIDPLoginPolicyLinkProjection_reduces(t *testing.T) {
 			name: "iam.reduceAdded",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LoginPolicyIDPProviderAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LoginPolicyIDPProviderAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 	"idpConfigId": "idp-config-id",
     "idpProviderType": 1
 }`),
-				), iam.IdentityProviderAddedEventMapper),
+				), instance.IdentityProviderAddedEventMapper),
 			},
 			reduce: (&IDPLoginPolicyLinkProjection{}).reduceAdded,
 			want: wantReduce{
-				aggregateType:    iam.AggregateType,
+				aggregateType:    instance.AggregateType,
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPLoginPolicyLinkTable,
@@ -63,17 +63,17 @@ func TestIDPLoginPolicyLinkProjection_reduces(t *testing.T) {
 			name: "iam.reduceRemoved",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LoginPolicyIDPProviderRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LoginPolicyIDPProviderRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 	"idpConfigId": "idp-config-id",
     "idpProviderType": 1
 }`),
-				), iam.IdentityProviderRemovedEventMapper),
+				), instance.IdentityProviderRemovedEventMapper),
 			},
 			reduce: (&IDPLoginPolicyLinkProjection{}).reduceRemoved,
 			want: wantReduce{
-				aggregateType:    iam.AggregateType,
+				aggregateType:    instance.AggregateType,
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPLoginPolicyLinkTable,
@@ -94,17 +94,17 @@ func TestIDPLoginPolicyLinkProjection_reduces(t *testing.T) {
 			name: "iam.reduceCascadeRemoved",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LoginPolicyIDPProviderCascadeRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LoginPolicyIDPProviderCascadeRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 	"idpConfigId": "idp-config-id",
     "idpProviderType": 1
 }`),
-				), iam.IdentityProviderCascadeRemovedEventMapper),
+				), instance.IdentityProviderCascadeRemovedEventMapper),
 			},
 			reduce: (&IDPLoginPolicyLinkProjection{}).reduceCascadeRemoved,
 			want: wantReduce{
-				aggregateType:    iam.AggregateType,
+				aggregateType:    instance.AggregateType,
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPLoginPolicyLinkTable,
@@ -281,16 +281,16 @@ func TestIDPLoginPolicyLinkProjection_reduces(t *testing.T) {
 			name: "iam.IDPConfigRemovedEvent",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPConfigRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPConfigRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"idpConfigId": "idp-config-id"
 					}`),
-				), iam.IDPConfigRemovedEventMapper),
+				), instance.IDPConfigRemovedEventMapper),
 			},
 			reduce: (&IDPLoginPolicyLinkProjection{}).reduceIDPConfigRemoved,
 			want: wantReduce{
-				aggregateType:    iam.AggregateType,
+				aggregateType:    instance.AggregateType,
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPLoginPolicyLinkTable,

internal/query/projection/idp_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -25,11 +25,11 @@ func TestIDPProjection_reduces(t *testing.T) {
 		want   wantReduce
 	}{
 		{
-			name: "iam.reduceIDPAdded",
+			name: "instance.reduceIDPAdded",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPConfigAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPConfigAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 	"idpConfigId": "idp-config-id",
 	"name": "custom-zitadel-instance",
@@ -37,11 +37,11 @@ func TestIDPProjection_reduces(t *testing.T) {
 	"stylingType": 0,
 	"autoRegister": true
 }`),
-				), iam.IDPConfigAddedEventMapper),
+				), instance.IDPConfigAddedEventMapper),
 			},
 			reduce: (&IDPProjection{}).reduceIDPAdded,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPTable,
@@ -68,22 +68,22 @@ func TestIDPProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceIDPChanged",
+			name: "instance.reduceIDPChanged",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPConfigChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPConfigChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 	"idpConfigId": "idp-config-id",
 	"name": "custom-zitadel-instance",
 	"stylingType": 1,
 	"autoRegister": true
 }`),
-				), iam.IDPConfigChangedEventMapper),
+				), instance.IDPConfigChangedEventMapper),
 			},
 			reduce: (&IDPProjection{}).reduceIDPChanged,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPTable,
@@ -105,19 +105,19 @@ func TestIDPProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceIDPDeactivated",
+			name: "instance.reduceIDPDeactivated",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPConfigDeactivatedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPConfigDeactivatedEventType),
+					instance.AggregateType,
 					[]byte(`{
 	"idpConfigId": "idp-config-id"
 }`),
-				), iam.IDPConfigDeactivatedEventMapper),
+				), instance.IDPConfigDeactivatedEventMapper),
 			},
 			reduce: (&IDPProjection{}).reduceIDPDeactivated,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPTable,
@@ -137,19 +137,19 @@ func TestIDPProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceIDPReactivated",
+			name: "instance.reduceIDPReactivated",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPConfigReactivatedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPConfigReactivatedEventType),
+					instance.AggregateType,
 					[]byte(`{
 	"idpConfigId": "idp-config-id"
 }`),
-				), iam.IDPConfigReactivatedEventMapper),
+				), instance.IDPConfigReactivatedEventMapper),
 			},
 			reduce: (&IDPProjection{}).reduceIDPReactivated,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPTable,
@@ -169,19 +169,19 @@ func TestIDPProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceIDPRemoved",
+			name: "instance.reduceIDPRemoved",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPConfigRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPConfigRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 	"idpConfigId": "idp-config-id"
 }`),
-				), iam.IDPConfigRemovedEventMapper),
+				), instance.IDPConfigRemovedEventMapper),
 			},
 			reduce: (&IDPProjection{}).reduceIDPRemoved,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPTable,
@@ -198,11 +198,11 @@ func TestIDPProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceOIDCConfigAdded",
+			name: "instance.reduceOIDCConfigAdded",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPOIDCConfigAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPOIDCConfigAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 	"idpConfigId": "idp-config-id",
 	"clientId": "client-id",
@@ -218,11 +218,11 @@ func TestIDPProjection_reduces(t *testing.T) {
     "idpDisplayNameMapping": 0,
     "usernameMapping": 1
 }`),
-				), iam.IDPOIDCConfigAddedEventMapper),
+				), instance.IDPOIDCConfigAddedEventMapper),
 			},
 			reduce: (&IDPProjection{}).reduceOIDCConfigAdded,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPTable,
@@ -256,11 +256,11 @@ func TestIDPProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceOIDCConfigChanged",
+			name: "instance.reduceOIDCConfigChanged",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPOIDCConfigChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPOIDCConfigChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 	"idpConfigId": "idp-config-id",
 	"clientId": "client-id",
@@ -276,11 +276,11 @@ func TestIDPProjection_reduces(t *testing.T) {
     "idpDisplayNameMapping": 0,
     "usernameMapping": 1
 }`),
-				), iam.IDPOIDCConfigChangedEventMapper),
+				), instance.IDPOIDCConfigChangedEventMapper),
 			},
 			reduce: (&IDPProjection{}).reduceOIDCConfigChanged,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPTable,
@@ -313,17 +313,17 @@ func TestIDPProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceOIDCConfigChanged: no op",
+			name: "instance.reduceOIDCConfigChanged: no op",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPOIDCConfigChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPOIDCConfigChangedEventType),
+					instance.AggregateType,
 					[]byte("{}"),
-				), iam.IDPOIDCConfigChangedEventMapper),
+				), instance.IDPOIDCConfigChangedEventMapper),
 			},
 			reduce: (&IDPProjection{}).reduceOIDCConfigChanged,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPTable,
@@ -333,11 +333,11 @@ func TestIDPProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceJWTConfigAdded",
+			name: "instance.reduceJWTConfigAdded",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPJWTConfigAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPJWTConfigAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 	"idpConfigId": "idp-config-id",
 	"jwtEndpoint": "https://api.zitadel.ch/jwt",
@@ -345,11 +345,11 @@ func TestIDPProjection_reduces(t *testing.T) {
     "keysEndpoint": "https://api.zitadel.ch/keys",
     "headerName": "hodor"
 }`),
-				), iam.IDPJWTConfigAddedEventMapper),
+				), instance.IDPJWTConfigAddedEventMapper),
 			},
 			reduce: (&IDPProjection{}).reduceJWTConfigAdded,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPTable,
@@ -379,11 +379,11 @@ func TestIDPProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceJWTConfigChanged",
+			name: "instance.reduceJWTConfigChanged",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPJWTConfigChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPJWTConfigChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 	"idpConfigId": "idp-config-id",
 	"jwtEndpoint": "https://api.zitadel.ch/jwt",
@@ -391,11 +391,11 @@ func TestIDPProjection_reduces(t *testing.T) {
     "keysEndpoint": "https://api.zitadel.ch/keys",
     "headerName": "hodor"
 }`),
-				), iam.IDPJWTConfigChangedEventMapper),
+				), instance.IDPJWTConfigChangedEventMapper),
 			},
 			reduce: (&IDPProjection{}).reduceJWTConfigChanged,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPTable,
@@ -424,17 +424,17 @@ func TestIDPProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceJWTConfigChanged: no op",
+			name: "instance.reduceJWTConfigChanged: no op",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPJWTConfigChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPJWTConfigChangedEventType),
+					instance.AggregateType,
 					[]byte(`{}`),
-				), iam.IDPJWTConfigChangedEventMapper),
+				), instance.IDPJWTConfigChangedEventMapper),
 			},
 			reduce: (&IDPProjection{}).reduceJWTConfigChanged,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPTable,

internal/query/projection/idp_user_link.go

@@ -7,7 +7,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/user"
 )
@@ -90,10 +90,10 @@ func (p *IDPUserLinkProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.IDPConfigRemovedEventType,
+					Event:  instance.IDPConfigRemovedEventType,
 					Reduce: p.reduceIDPConfigRemoved,
 				},
 			},
@@ -184,10 +184,10 @@ func (p *IDPUserLinkProjection) reduceIDPConfigRemoved(event eventstore.Event) (
 	switch e := event.(type) {
 	case *org.IDPConfigRemovedEvent:
 		idpID = e.ConfigID
-	case *iam.IDPConfigRemovedEvent:
+	case *instance.IDPConfigRemovedEvent:
 		idpID = e.ConfigID
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-iCKSj", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigRemovedEventType, iam.IDPConfigRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-iCKSj", "reduce.wrong.event.type %v", []eventstore.EventType{org.IDPConfigRemovedEventType, instance.IDPConfigRemovedEventType})
 	}
 
 	return crdb.NewDeleteStatement(event,

internal/query/projection/idp_user_link_test.go

@@ -7,7 +7,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/user"
 )
@@ -213,16 +213,16 @@ func TestIDPUserLinkProjection_reduces(t *testing.T) {
 			name: "iam.IDPConfigRemovedEvent",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.IDPConfigRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.IDPConfigRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"idpConfigId": "idp-config-id"
 					}`),
-				), iam.IDPConfigRemovedEventMapper),
+				), instance.IDPConfigRemovedEventMapper),
 			},
 			reduce: (&IDPUserLinkProjection{}).reduceIDPConfigRemoved,
 			want: wantReduce{
-				aggregateType:    iam.AggregateType,
+				aggregateType:    instance.AggregateType,
 				sequence:         15,
 				previousSequence: 10,
 				projection:       IDPUserLinkTable,

internal/query/projection/instance.go

@@ -0,0 +1,149 @@
+package projection
+
+import (
+	"context"
+
+	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore"
+	"github.com/caos/zitadel/internal/eventstore/handler"
+	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
+	"github.com/caos/zitadel/internal/repository/instance"
+)
+
+const (
+	InstanceProjectionTable = "projections.instance"
+
+	InstanceColumnID              = "id"
+	InstanceColumnChangeDate      = "change_date"
+	InstanceColumnGlobalOrgID     = "global_org_id"
+	InstanceColumnProjectID       = "iam_project_id"
+	InstanceColumnSequence        = "sequence"
+	InstanceColumnSetUpStarted    = "setup_started"
+	InstanceColumnSetUpDone       = "setup_done"
+	InstanceColumnDefaultLanguage = "default_language"
+)
+
+type IAMProjection struct {
+	crdb.StatementHandler
+}
+
+func NewIAMProjection(ctx context.Context, config crdb.StatementHandlerConfig) *IAMProjection {
+	p := new(IAMProjection)
+	config.ProjectionName = InstanceProjectionTable
+	config.Reducers = p.reducers()
+	config.InitCheck = crdb.NewTableCheck(
+		crdb.NewTable([]*crdb.Column{
+			crdb.NewColumn(InstanceColumnID, crdb.ColumnTypeText),
+			crdb.NewColumn(InstanceColumnChangeDate, crdb.ColumnTypeTimestamp),
+			crdb.NewColumn(InstanceColumnGlobalOrgID, crdb.ColumnTypeText, crdb.Default("")),
+			crdb.NewColumn(InstanceColumnProjectID, crdb.ColumnTypeText, crdb.Default("")),
+			crdb.NewColumn(InstanceColumnSequence, crdb.ColumnTypeInt64),
+			crdb.NewColumn(InstanceColumnSetUpStarted, crdb.ColumnTypeInt64, crdb.Default(0)),
+			crdb.NewColumn(InstanceColumnSetUpDone, crdb.ColumnTypeInt64, crdb.Default(0)),
+			crdb.NewColumn(InstanceColumnDefaultLanguage, crdb.ColumnTypeText, crdb.Default("")),
+		},
+			crdb.NewPrimaryKey(InstanceColumnID),
+		),
+	)
+	p.StatementHandler = crdb.NewStatementHandler(ctx, config)
+	return p
+}
+
+func (p *IAMProjection) reducers() []handler.AggregateReducer {
+	return []handler.AggregateReducer{
+		{
+			Aggregate: instance.AggregateType,
+			EventRedusers: []handler.EventReducer{
+				{
+					Event:  instance.GlobalOrgSetEventType,
+					Reduce: p.reduceGlobalOrgSet,
+				},
+				{
+					Event:  instance.ProjectSetEventType,
+					Reduce: p.reduceIAMProjectSet,
+				},
+				{
+					Event:  instance.DefaultLanguageSetEventType,
+					Reduce: p.reduceDefaultLanguageSet,
+				},
+				{
+					Event:  instance.SetupStartedEventType,
+					Reduce: p.reduceSetupEvent,
+				},
+				{
+					Event:  instance.SetupDoneEventType,
+					Reduce: p.reduceSetupEvent,
+				},
+			},
+		},
+	}
+}
+
+func (p *IAMProjection) reduceGlobalOrgSet(event eventstore.Event) (*handler.Statement, error) {
+	e, ok := event.(*instance.GlobalOrgSetEvent)
+	if !ok {
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-2n9f2", "reduce.wrong.event.type %s", instance.GlobalOrgSetEventType)
+	}
+	return crdb.NewUpsertStatement(
+		e,
+		[]handler.Column{
+			handler.NewCol(InstanceColumnID, e.Aggregate().InstanceID),
+			handler.NewCol(InstanceColumnChangeDate, e.CreationDate()),
+			handler.NewCol(InstanceColumnSequence, e.Sequence()),
+			handler.NewCol(InstanceColumnGlobalOrgID, e.OrgID),
+		},
+	), nil
+}
+
+func (p *IAMProjection) reduceIAMProjectSet(event eventstore.Event) (*handler.Statement, error) {
+	e, ok := event.(*instance.ProjectSetEvent)
+	if !ok {
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-30o0e", "reduce.wrong.event.type %s", instance.ProjectSetEventType)
+	}
+	return crdb.NewUpsertStatement(
+		e,
+		[]handler.Column{
+			handler.NewCol(InstanceColumnID, e.Aggregate().InstanceID),
+			handler.NewCol(InstanceColumnChangeDate, e.CreationDate()),
+			handler.NewCol(InstanceColumnSequence, e.Sequence()),
+			handler.NewCol(InstanceColumnProjectID, e.ProjectID),
+		},
+	), nil
+}
+
+func (p *IAMProjection) reduceDefaultLanguageSet(event eventstore.Event) (*handler.Statement, error) {
+	e, ok := event.(*instance.DefaultLanguageSetEvent)
+	if !ok {
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-30o0e", "reduce.wrong.event.type %s", instance.DefaultLanguageSetEventType)
+	}
+	return crdb.NewUpsertStatement(
+		e,
+		[]handler.Column{
+			handler.NewCol(InstanceColumnID, e.Aggregate().InstanceID),
+			handler.NewCol(InstanceColumnChangeDate, e.CreationDate()),
+			handler.NewCol(InstanceColumnSequence, e.Sequence()),
+			handler.NewCol(InstanceColumnDefaultLanguage, e.Language.String()),
+		},
+	), nil
+}
+
+func (p *IAMProjection) reduceSetupEvent(event eventstore.Event) (*handler.Statement, error) {
+	e, ok := event.(*instance.SetupStepEvent)
+	if !ok {
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-d9nfw", "reduce.wrong.event.type %v", []eventstore.EventType{instance.SetupDoneEventType, instance.SetupStartedEventType})
+	}
+	columns := []handler.Column{
+		handler.NewCol(InstanceColumnID, e.Aggregate().InstanceID),
+		handler.NewCol(InstanceColumnChangeDate, e.CreationDate()),
+		handler.NewCol(InstanceColumnSequence, e.Sequence()),
+	}
+	if e.EventType == instance.SetupStartedEventType {
+		columns = append(columns, handler.NewCol(InstanceColumnSetUpStarted, e.Step))
+	} else {
+		columns = append(columns, handler.NewCol(InstanceColumnSetUpDone, e.Step))
+	}
+	return crdb.NewUpsertStatement(
+		e,
+		columns,
+	), nil
+}

internal/query/projection/instance_member.go

@@ -0,0 +1,113 @@
+package projection
+
+import (
+	"context"
+
+	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore"
+	"github.com/caos/zitadel/internal/eventstore/handler"
+	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
+	"github.com/caos/zitadel/internal/repository/instance"
+	"github.com/caos/zitadel/internal/repository/user"
+)
+
+const (
+	InstanceMemberProjectionTable = "projections.instance_members"
+
+	InstanceMemberIAMIDCol = "instance_id"
+)
+
+type InstanceMemberProjection struct {
+	crdb.StatementHandler
+}
+
+func NewInstanceMemberProjection(ctx context.Context, config crdb.StatementHandlerConfig) *InstanceMemberProjection {
+	p := new(InstanceMemberProjection)
+	config.ProjectionName = InstanceMemberProjectionTable
+	config.Reducers = p.reducers()
+	config.InitCheck = crdb.NewTableCheck(
+		crdb.NewTable(
+			append(memberColumns, crdb.NewColumn(InstanceColumnID, crdb.ColumnTypeText)),
+			crdb.NewPrimaryKey(MemberInstanceID, InstanceColumnID, MemberUserIDCol),
+			crdb.NewIndex("user_idx", []string{MemberUserIDCol}),
+		),
+	)
+
+	p.StatementHandler = crdb.NewStatementHandler(ctx, config)
+	return p
+}
+
+func (p *InstanceMemberProjection) reducers() []handler.AggregateReducer {
+	return []handler.AggregateReducer{
+		{
+			Aggregate: instance.AggregateType,
+			EventRedusers: []handler.EventReducer{
+				{
+					Event:  instance.MemberAddedEventType,
+					Reduce: p.reduceAdded,
+				},
+				{
+					Event:  instance.MemberChangedEventType,
+					Reduce: p.reduceChanged,
+				},
+				{
+					Event:  instance.MemberCascadeRemovedEventType,
+					Reduce: p.reduceCascadeRemoved,
+				},
+				{
+					Event:  instance.MemberRemovedEventType,
+					Reduce: p.reduceRemoved,
+				},
+			},
+		},
+		{
+			Aggregate: user.AggregateType,
+			EventRedusers: []handler.EventReducer{
+				{
+					Event:  user.UserRemovedType,
+					Reduce: p.reduceUserRemoved,
+				},
+			},
+		},
+	}
+}
+
+func (p *InstanceMemberProjection) reduceAdded(event eventstore.Event) (*handler.Statement, error) {
+	e, ok := event.(*instance.MemberAddedEvent)
+	if !ok {
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-pGNCu", "reduce.wrong.event.type %s", instance.MemberAddedEventType)
+	}
+	return reduceMemberAdded(e.MemberAddedEvent, withMemberCol(InstanceMemberIAMIDCol, e.Aggregate().ID))
+}
+
+func (p *InstanceMemberProjection) reduceChanged(event eventstore.Event) (*handler.Statement, error) {
+	e, ok := event.(*instance.MemberChangedEvent)
+	if !ok {
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-5WQcZ", "reduce.wrong.event.type %s", instance.MemberChangedEventType)
+	}
+	return reduceMemberChanged(e.MemberChangedEvent)
+}
+
+func (p *InstanceMemberProjection) reduceCascadeRemoved(event eventstore.Event) (*handler.Statement, error) {
+	e, ok := event.(*instance.MemberCascadeRemovedEvent)
+	if !ok {
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-Dmdf2", "reduce.wrong.event.type %s", instance.MemberCascadeRemovedEventType)
+	}
+	return reduceMemberCascadeRemoved(e.MemberCascadeRemovedEvent)
+}
+
+func (p *InstanceMemberProjection) reduceRemoved(event eventstore.Event) (*handler.Statement, error) {
+	e, ok := event.(*instance.MemberRemovedEvent)
+	if !ok {
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-exVqy", "reduce.wrong.event.type %s", instance.MemberRemovedEventType)
+	}
+	return reduceMemberRemoved(e, withMemberCond(MemberUserIDCol, e.UserID))
+}
+
+func (p *InstanceMemberProjection) reduceUserRemoved(event eventstore.Event) (*handler.Statement, error) {
+	e, ok := event.(*user.UserRemovedEvent)
+	if !ok {
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-mkDHF", "reduce.wrong.event.type %s", user.UserRemovedType)
+	}
+	return reduceMemberRemoved(e, withMemberCond(MemberUserIDCol, e.Aggregate().ID))
+}

internal/query/projection/instance_member_test.go

@@ -9,11 +9,11 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/user"
 )
 
-func TestIAMMemberProjection_reduces(t *testing.T) {
+func TestInstanceMemberProjection_reduces(t *testing.T) {
 	type args struct {
 		event func(t *testing.T) eventstore.Event
 	}
@@ -24,27 +24,27 @@ func TestIAMMemberProjection_reduces(t *testing.T) {
 		want   wantReduce
 	}{
 		{
-			name: "iam.MemberAddedType",
+			name: "instance.MemberAddedType",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.MemberAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.MemberAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 					"userId": "user-id",
 					"roles": ["role"]
 				}`),
-				), iam.MemberAddedEventMapper),
+				), instance.MemberAddedEventMapper),
 			},
-			reduce: (&IAMMemberProjection{}).reduceAdded,
+			reduce: (&InstanceMemberProjection{}).reduceAdded,
 			want: wantReduce{
-				aggregateType:    iam.AggregateType,
+				aggregateType:    instance.AggregateType,
 				sequence:         15,
 				previousSequence: 10,
-				projection:       IAMMemberProjectionTable,
+				projection:       InstanceMemberProjectionTable,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "INSERT INTO projections.iam_members (user_id, roles, creation_date, change_date, sequence, resource_owner, instance_id, iam_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)",
+							expectedStmt: "INSERT INTO projections.instance_members (user_id, roles, creation_date, change_date, sequence, resource_owner, instance_id, instance_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)",
 							expectedArgs: []interface{}{
 								"user-id",
 								pq.StringArray{"role"},
@@ -61,27 +61,27 @@ func TestIAMMemberProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.MemberChangedType",
+			name: "instance.MemberChangedType",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.MemberChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.MemberChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 					"userId": "user-id",
 					"roles": ["role", "changed"]
 				}`),
-				), iam.MemberChangedEventMapper),
+				), instance.MemberChangedEventMapper),
 			},
-			reduce: (&IAMMemberProjection{}).reduceChanged,
+			reduce: (&InstanceMemberProjection{}).reduceChanged,
 			want: wantReduce{
-				aggregateType:    iam.AggregateType,
+				aggregateType:    instance.AggregateType,
 				sequence:         15,
 				previousSequence: 10,
-				projection:       IAMMemberProjectionTable,
+				projection:       InstanceMemberProjectionTable,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "UPDATE projections.iam_members SET (roles, change_date, sequence) = ($1, $2, $3) WHERE (user_id = $4)",
+							expectedStmt: "UPDATE projections.instance_members SET (roles, change_date, sequence) = ($1, $2, $3) WHERE (user_id = $4)",
 							expectedArgs: []interface{}{
 								pq.StringArray{"role", "changed"},
 								anyArg{},
@@ -94,26 +94,26 @@ func TestIAMMemberProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.MemberCascadeRemovedType",
+			name: "instance.MemberCascadeRemovedType",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.MemberCascadeRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.MemberCascadeRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 					"userId": "user-id"
 				}`),
-				), iam.MemberCascadeRemovedEventMapper),
+				), instance.MemberCascadeRemovedEventMapper),
 			},
-			reduce: (&IAMMemberProjection{}).reduceCascadeRemoved,
+			reduce: (&InstanceMemberProjection{}).reduceCascadeRemoved,
 			want: wantReduce{
-				aggregateType:    iam.AggregateType,
+				aggregateType:    instance.AggregateType,
 				sequence:         15,
 				previousSequence: 10,
-				projection:       IAMMemberProjectionTable,
+				projection:       InstanceMemberProjectionTable,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "DELETE FROM projections.iam_members WHERE (user_id = $1)",
+							expectedStmt: "DELETE FROM projections.instance_members WHERE (user_id = $1)",
 							expectedArgs: []interface{}{
 								"user-id",
 							},
@@ -123,26 +123,26 @@ func TestIAMMemberProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.MemberRemovedType",
+			name: "instance.MemberRemovedType",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.MemberRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.MemberRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 					"userId": "user-id"
 				}`),
-				), iam.MemberRemovedEventMapper),
+				), instance.MemberRemovedEventMapper),
 			},
-			reduce: (&IAMMemberProjection{}).reduceRemoved,
+			reduce: (&InstanceMemberProjection{}).reduceRemoved,
 			want: wantReduce{
-				aggregateType:    iam.AggregateType,
+				aggregateType:    instance.AggregateType,
 				sequence:         15,
 				previousSequence: 10,
-				projection:       IAMMemberProjectionTable,
+				projection:       InstanceMemberProjectionTable,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "DELETE FROM projections.iam_members WHERE (user_id = $1)",
+							expectedStmt: "DELETE FROM projections.instance_members WHERE (user_id = $1)",
 							expectedArgs: []interface{}{
 								"user-id",
 							},
@@ -160,16 +160,16 @@ func TestIAMMemberProjection_reduces(t *testing.T) {
 					[]byte(`{}`),
 				), user.UserRemovedEventMapper),
 			},
-			reduce: (&IAMMemberProjection{}).reduceUserRemoved,
+			reduce: (&InstanceMemberProjection{}).reduceUserRemoved,
 			want: wantReduce{
 				aggregateType:    user.AggregateType,
 				sequence:         15,
 				previousSequence: 10,
-				projection:       IAMMemberProjectionTable,
+				projection:       InstanceMemberProjectionTable,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "DELETE FROM projections.iam_members WHERE (user_id = $1)",
+							expectedStmt: "DELETE FROM projections.instance_members WHERE (user_id = $1)",
 							expectedArgs: []interface{}{
 								"agg-id",
 							},

internal/query/projection/instance_test.go

@@ -8,10 +8,10 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 )
 
-func TestIAMProjection_reduces(t *testing.T) {
+func TestInstanceProjection_reduces(t *testing.T) {
 	type args struct {
 		event func(t *testing.T) eventstore.Event
 	}
@@ -25,21 +25,21 @@ func TestIAMProjection_reduces(t *testing.T) {
 			name: "reduceGlobalOrgSet",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.GlobalOrgSetEventType),
-					iam.AggregateType,
+					repository.EventType(instance.GlobalOrgSetEventType),
+					instance.AggregateType,
 					[]byte(`{"globalOrgId": "orgid"}`),
-				), iam.GlobalOrgSetMapper),
+				), instance.GlobalOrgSetMapper),
 			},
 			reduce: (&IAMProjection{}).reduceGlobalOrgSet,
 			want: wantReduce{
-				projection:       IAMProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				projection:       InstanceProjectionTable,
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "UPSERT INTO projections.iam (id, change_date, sequence, global_org_id) VALUES ($1, $2, $3, $4)",
+							expectedStmt: "UPSERT INTO projections.instance (id, change_date, sequence, global_org_id) VALUES ($1, $2, $3, $4)",
 							expectedArgs: []interface{}{
 								"instance-id",
 								anyArg{},
@@ -55,21 +55,21 @@ func TestIAMProjection_reduces(t *testing.T) {
 			name: "reduceProjectIDSet",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.ProjectSetEventType),
-					iam.AggregateType,
+					repository.EventType(instance.ProjectSetEventType),
+					instance.AggregateType,
 					[]byte(`{"iamProjectId": "project-id"}`),
-				), iam.ProjectSetMapper),
+				), instance.ProjectSetMapper),
 			},
 			reduce: (&IAMProjection{}).reduceIAMProjectSet,
 			want: wantReduce{
-				projection:       IAMProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				projection:       InstanceProjectionTable,
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "UPSERT INTO projections.iam (id, change_date, sequence, iam_project_id) VALUES ($1, $2, $3, $4)",
+							expectedStmt: "UPSERT INTO projections.instance (id, change_date, sequence, iam_project_id) VALUES ($1, $2, $3, $4)",
 							expectedArgs: []interface{}{
 								"instance-id",
 								anyArg{},
@@ -85,21 +85,21 @@ func TestIAMProjection_reduces(t *testing.T) {
 			name: "reduceDefaultLanguageSet",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.DefaultLanguageSetEventType),
-					iam.AggregateType,
+					repository.EventType(instance.DefaultLanguageSetEventType),
+					instance.AggregateType,
 					[]byte(`{"language": "en"}`),
-				), iam.DefaultLanguageSetMapper),
+				), instance.DefaultLanguageSetMapper),
 			},
 			reduce: (&IAMProjection{}).reduceDefaultLanguageSet,
 			want: wantReduce{
-				projection:       IAMProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				projection:       InstanceProjectionTable,
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "UPSERT INTO projections.iam (id, change_date, sequence, default_language) VALUES ($1, $2, $3, $4)",
+							expectedStmt: "UPSERT INTO projections.instance (id, change_date, sequence, default_language) VALUES ($1, $2, $3, $4)",
 							expectedArgs: []interface{}{
 								"instance-id",
 								anyArg{},
@@ -115,21 +115,21 @@ func TestIAMProjection_reduces(t *testing.T) {
 			name: "reduceSetupStarted",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SetupStartedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SetupStartedEventType),
+					instance.AggregateType,
 					[]byte(`{"Step": 1}`),
-				), iam.SetupStepMapper),
+				), instance.SetupStepMapper),
 			},
 			reduce: (&IAMProjection{}).reduceSetupEvent,
 			want: wantReduce{
-				projection:       IAMProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				projection:       InstanceProjectionTable,
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "UPSERT INTO projections.iam (id, change_date, sequence, setup_started) VALUES ($1, $2, $3, $4)",
+							expectedStmt: "UPSERT INTO projections.instance (id, change_date, sequence, setup_started) VALUES ($1, $2, $3, $4)",
 							expectedArgs: []interface{}{
 								"instance-id",
 								anyArg{},
@@ -145,21 +145,21 @@ func TestIAMProjection_reduces(t *testing.T) {
 			name: "reduceSetupDone",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SetupDoneEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SetupDoneEventType),
+					instance.AggregateType,
 					[]byte(`{"Step": 1}`),
-				), iam.SetupStepMapper),
+				), instance.SetupStepMapper),
 			},
 			reduce: (&IAMProjection{}).reduceSetupEvent,
 			want: wantReduce{
-				projection:       IAMProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				projection:       InstanceProjectionTable,
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "UPSERT INTO projections.iam (id, change_date, sequence, setup_done) VALUES ($1, $2, $3, $4)",
+							expectedStmt: "UPSERT INTO projections.instance (id, change_date, sequence, setup_done) VALUES ($1, $2, $3, $4)",
 							expectedArgs: []interface{}{
 								"instance-id",
 								anyArg{},

internal/query/projection/label_policy.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/policy"
 )
@@ -154,62 +154,62 @@ func (p *LabelPolicyProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.LabelPolicyAddedEventType,
+					Event:  instance.LabelPolicyAddedEventType,
 					Reduce: p.reduceAdded,
 				},
 				{
-					Event:  iam.LabelPolicyChangedEventType,
+					Event:  instance.LabelPolicyChangedEventType,
 					Reduce: p.reduceChanged,
 				},
 				{
-					Event:  iam.LabelPolicyActivatedEventType,
+					Event:  instance.LabelPolicyActivatedEventType,
 					Reduce: p.reduceActivated,
 				},
 				{
-					Event:  iam.LabelPolicyLogoAddedEventType,
+					Event:  instance.LabelPolicyLogoAddedEventType,
 					Reduce: p.reduceLogoAdded,
 				},
 				{
-					Event:  iam.LabelPolicyLogoRemovedEventType,
+					Event:  instance.LabelPolicyLogoRemovedEventType,
 					Reduce: p.reduceLogoRemoved,
 				},
 				{
-					Event:  iam.LabelPolicyIconAddedEventType,
+					Event:  instance.LabelPolicyIconAddedEventType,
 					Reduce: p.reduceIconAdded,
 				},
 				{
-					Event:  iam.LabelPolicyIconRemovedEventType,
+					Event:  instance.LabelPolicyIconRemovedEventType,
 					Reduce: p.reduceIconRemoved,
 				},
 				{
-					Event:  iam.LabelPolicyLogoDarkAddedEventType,
+					Event:  instance.LabelPolicyLogoDarkAddedEventType,
 					Reduce: p.reduceLogoAdded,
 				},
 				{
-					Event:  iam.LabelPolicyLogoDarkRemovedEventType,
+					Event:  instance.LabelPolicyLogoDarkRemovedEventType,
 					Reduce: p.reduceLogoRemoved,
 				},
 				{
-					Event:  iam.LabelPolicyIconDarkAddedEventType,
+					Event:  instance.LabelPolicyIconDarkAddedEventType,
 					Reduce: p.reduceIconAdded,
 				},
 				{
-					Event:  iam.LabelPolicyIconDarkRemovedEventType,
+					Event:  instance.LabelPolicyIconDarkRemovedEventType,
 					Reduce: p.reduceIconRemoved,
 				},
 				{
-					Event:  iam.LabelPolicyFontAddedEventType,
+					Event:  instance.LabelPolicyFontAddedEventType,
 					Reduce: p.reduceFontAdded,
 				},
 				{
-					Event:  iam.LabelPolicyFontRemovedEventType,
+					Event:  instance.LabelPolicyFontRemovedEventType,
 					Reduce: p.reduceFontRemoved,
 				},
 				{
-					Event:  iam.LabelPolicyAssetsRemovedEventType,
+					Event:  instance.LabelPolicyAssetsRemovedEventType,
 					Reduce: p.reduceAssetsRemoved,
 				},
 			},
@@ -224,11 +224,11 @@ func (p *LabelPolicyProjection) reduceAdded(event eventstore.Event) (*handler.St
 	case *org.LabelPolicyAddedEvent:
 		policyEvent = e.LabelPolicyAddedEvent
 		isDefault = false
-	case *iam.LabelPolicyAddedEvent:
+	case *instance.LabelPolicyAddedEvent:
 		policyEvent = e.LabelPolicyAddedEvent
 		isDefault = true
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-CSE7A", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyAddedEventType, iam.LabelPolicyAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-CSE7A", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyAddedEventType, instance.LabelPolicyAddedEventType})
 	}
 	return crdb.NewCreateStatement(
 		&policyEvent,
@@ -260,10 +260,10 @@ func (p *LabelPolicyProjection) reduceChanged(event eventstore.Event) (*handler.
 	switch e := event.(type) {
 	case *org.LabelPolicyChangedEvent:
 		policyEvent = e.LabelPolicyChangedEvent
-	case *iam.LabelPolicyChangedEvent:
+	case *instance.LabelPolicyChangedEvent:
 		policyEvent = e.LabelPolicyChangedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-qgVug", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyChangedEventType, iam.LabelPolicyChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-qgVug", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyChangedEventType, instance.LabelPolicyChangedEventType})
 	}
 	cols := []handler.Column{
 		handler.NewCol(LabelPolicyChangeDateCol, policyEvent.CreationDate()),
@@ -325,10 +325,10 @@ func (p *LabelPolicyProjection) reduceRemoved(event eventstore.Event) (*handler.
 
 func (p *LabelPolicyProjection) reduceActivated(event eventstore.Event) (*handler.Statement, error) {
 	switch event.(type) {
-	case *org.LabelPolicyActivatedEvent, *iam.LabelPolicyActivatedEvent:
+	case *org.LabelPolicyActivatedEvent, *instance.LabelPolicyActivatedEvent:
 		// everything ok
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-dldEU", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyActivatedEventType, iam.LabelPolicyActivatedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-dldEU", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyActivatedEventType, instance.LabelPolicyActivatedEventType})
 	}
 	return crdb.NewCopyStatement(
 		event,
@@ -368,14 +368,14 @@ func (p *LabelPolicyProjection) reduceLogoAdded(event eventstore.Event) (*handle
 	switch e := event.(type) {
 	case *org.LabelPolicyLogoAddedEvent:
 		storeKey = handler.NewCol(LabelPolicyLightLogoURLCol, e.StoreKey)
-	case *iam.LabelPolicyLogoAddedEvent:
+	case *instance.LabelPolicyLogoAddedEvent:
 		storeKey = handler.NewCol(LabelPolicyLightLogoURLCol, e.StoreKey)
 	case *org.LabelPolicyLogoDarkAddedEvent:
 		storeKey = handler.NewCol(LabelPolicyDarkLogoURLCol, e.StoreKey)
-	case *iam.LabelPolicyLogoDarkAddedEvent:
+	case *instance.LabelPolicyLogoDarkAddedEvent:
 		storeKey = handler.NewCol(LabelPolicyDarkLogoURLCol, e.StoreKey)
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-4wbOI", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyLogoAddedEventType, iam.LabelPolicyLogoAddedEventType, org.LabelPolicyLogoDarkAddedEventType, iam.LabelPolicyLogoDarkAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-4wbOI", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyLogoAddedEventType, instance.LabelPolicyLogoAddedEventType, org.LabelPolicyLogoDarkAddedEventType, instance.LabelPolicyLogoDarkAddedEventType})
 	}
 
 	return crdb.NewUpdateStatement(
@@ -396,14 +396,14 @@ func (p *LabelPolicyProjection) reduceLogoRemoved(event eventstore.Event) (*hand
 	switch event.(type) {
 	case *org.LabelPolicyLogoRemovedEvent:
 		col = LabelPolicyLightLogoURLCol
-	case *iam.LabelPolicyLogoRemovedEvent:
+	case *instance.LabelPolicyLogoRemovedEvent:
 		col = LabelPolicyLightLogoURLCol
 	case *org.LabelPolicyLogoDarkRemovedEvent:
 		col = LabelPolicyDarkLogoURLCol
-	case *iam.LabelPolicyLogoDarkRemovedEvent:
+	case *instance.LabelPolicyLogoDarkRemovedEvent:
 		col = LabelPolicyDarkLogoURLCol
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-kg8H4", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyLogoRemovedEventType, iam.LabelPolicyLogoRemovedEventType, org.LabelPolicyLogoDarkRemovedEventType, iam.LabelPolicyLogoDarkRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-kg8H4", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyLogoRemovedEventType, instance.LabelPolicyLogoRemovedEventType, org.LabelPolicyLogoDarkRemovedEventType, instance.LabelPolicyLogoDarkRemovedEventType})
 	}
 
 	return crdb.NewUpdateStatement(
@@ -424,14 +424,14 @@ func (p *LabelPolicyProjection) reduceIconAdded(event eventstore.Event) (*handle
 	switch e := event.(type) {
 	case *org.LabelPolicyIconAddedEvent:
 		storeKey = handler.NewCol(LabelPolicyLightIconURLCol, e.StoreKey)
-	case *iam.LabelPolicyIconAddedEvent:
+	case *instance.LabelPolicyIconAddedEvent:
 		storeKey = handler.NewCol(LabelPolicyLightIconURLCol, e.StoreKey)
 	case *org.LabelPolicyIconDarkAddedEvent:
 		storeKey = handler.NewCol(LabelPolicyDarkIconURLCol, e.StoreKey)
-	case *iam.LabelPolicyIconDarkAddedEvent:
+	case *instance.LabelPolicyIconDarkAddedEvent:
 		storeKey = handler.NewCol(LabelPolicyDarkIconURLCol, e.StoreKey)
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-e2JFz", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyIconAddedEventType, iam.LabelPolicyIconAddedEventType, org.LabelPolicyIconDarkAddedEventType, iam.LabelPolicyIconDarkAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-e2JFz", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyIconAddedEventType, instance.LabelPolicyIconAddedEventType, org.LabelPolicyIconDarkAddedEventType, instance.LabelPolicyIconDarkAddedEventType})
 	}
 
 	return crdb.NewUpdateStatement(
@@ -452,14 +452,14 @@ func (p *LabelPolicyProjection) reduceIconRemoved(event eventstore.Event) (*hand
 	switch event.(type) {
 	case *org.LabelPolicyIconRemovedEvent:
 		col = LabelPolicyLightIconURLCol
-	case *iam.LabelPolicyIconRemovedEvent:
+	case *instance.LabelPolicyIconRemovedEvent:
 		col = LabelPolicyLightIconURLCol
 	case *org.LabelPolicyIconDarkRemovedEvent:
 		col = LabelPolicyDarkIconURLCol
-	case *iam.LabelPolicyIconDarkRemovedEvent:
+	case *instance.LabelPolicyIconDarkRemovedEvent:
 		col = LabelPolicyDarkIconURLCol
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-gfgbY", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyIconRemovedEventType, iam.LabelPolicyIconRemovedEventType, org.LabelPolicyIconDarkRemovedEventType, iam.LabelPolicyIconDarkRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-gfgbY", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyIconRemovedEventType, instance.LabelPolicyIconRemovedEventType, org.LabelPolicyIconDarkRemovedEventType, instance.LabelPolicyIconDarkRemovedEventType})
 	}
 
 	return crdb.NewUpdateStatement(
@@ -480,10 +480,10 @@ func (p *LabelPolicyProjection) reduceFontAdded(event eventstore.Event) (*handle
 	switch e := event.(type) {
 	case *org.LabelPolicyFontAddedEvent:
 		storeKey = handler.NewCol(LabelPolicyFontURLCol, e.StoreKey)
-	case *iam.LabelPolicyFontAddedEvent:
+	case *instance.LabelPolicyFontAddedEvent:
 		storeKey = handler.NewCol(LabelPolicyFontURLCol, e.StoreKey)
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-65i9W", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyFontAddedEventType, iam.LabelPolicyFontAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-65i9W", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyFontAddedEventType, instance.LabelPolicyFontAddedEventType})
 	}
 
 	return crdb.NewUpdateStatement(
@@ -504,10 +504,10 @@ func (p *LabelPolicyProjection) reduceFontRemoved(event eventstore.Event) (*hand
 	switch event.(type) {
 	case *org.LabelPolicyFontRemovedEvent:
 		col = LabelPolicyFontURLCol
-	case *iam.LabelPolicyFontRemovedEvent:
+	case *instance.LabelPolicyFontRemovedEvent:
 		col = LabelPolicyFontURLCol
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-xf32J", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyFontRemovedEventType, iam.LabelPolicyFontRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-xf32J", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyFontRemovedEventType, instance.LabelPolicyFontRemovedEventType})
 	}
 
 	return crdb.NewUpdateStatement(
@@ -525,10 +525,10 @@ func (p *LabelPolicyProjection) reduceFontRemoved(event eventstore.Event) (*hand
 
 func (p *LabelPolicyProjection) reduceAssetsRemoved(event eventstore.Event) (*handler.Statement, error) {
 	switch event.(type) {
-	case *org.LabelPolicyAssetsRemovedEvent, *iam.LabelPolicyAssetsRemovedEvent:
+	case *org.LabelPolicyAssetsRemovedEvent, *instance.LabelPolicyAssetsRemovedEvent:
 		//ok
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-qi39A", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyAssetsRemovedEventType, iam.LabelPolicyAssetsRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-qi39A", "reduce.wrong.event.type %v", []eventstore.EventType{org.LabelPolicyAssetsRemovedEventType, instance.LabelPolicyAssetsRemovedEventType})
 	}
 
 	return crdb.NewUpdateStatement(

internal/query/projection/label_policy_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -505,17 +505,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceAdded",
+			name: "instance.reduceAdded",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyAddedEventType),
+					instance.AggregateType,
 					[]byte(`{"backgroundColor": "#141735", "fontColor": "#ffffff", "primaryColor": "#5282c1", "warnColor": "#ff3b5b"}`),
-				), iam.LabelPolicyAddedEventMapper),
+				), instance.LabelPolicyAddedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceAdded,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -550,17 +550,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceChanged",
+			name: "instance.reduceChanged",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyChangedEventType),
+					instance.AggregateType,
 					[]byte(`{"backgroundColor": "#141735", "fontColor": "#ffffff", "primaryColor": "#5282c1", "warnColor": "#ff3b5b", "primaryColorDark": "#ffffff","backgroundColorDark": "#ffffff", "warnColorDark": "#ffffff", "fontColorDark": "#ffffff", "hideLoginNameSuffix": true, "errorMsgPopup": true, "disableWatermark": true}`),
-				), iam.LabelPolicyChangedEventMapper),
+				), instance.LabelPolicyChangedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceChanged,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -591,17 +591,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceActivated",
+			name: "instance.reduceActivated",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyActivatedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyActivatedEventType),
+					instance.AggregateType,
 					nil,
-				), iam.LabelPolicyActivatedEventMapper),
+				), instance.LabelPolicyActivatedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceActivated,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -622,17 +622,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceLogoAdded light",
+			name: "instance.reduceLogoAdded light",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyLogoAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyLogoAddedEventType),
+					instance.AggregateType,
 					[]byte(`{"storeKey": "/path/to/logo.png"}`),
-				), iam.LabelPolicyLogoAddedEventMapper),
+				), instance.LabelPolicyLogoAddedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceLogoAdded,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -653,17 +653,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceLogoAdded dark",
+			name: "instance.reduceLogoAdded dark",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyLogoDarkAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyLogoDarkAddedEventType),
+					instance.AggregateType,
 					[]byte(`{"storeKey": "/path/to/logo.png"}`),
-				), iam.LabelPolicyLogoDarkAddedEventMapper),
+				), instance.LabelPolicyLogoDarkAddedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceLogoAdded,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -684,17 +684,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceIconAdded light",
+			name: "instance.reduceIconAdded light",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyIconAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyIconAddedEventType),
+					instance.AggregateType,
 					[]byte(`{"storeKey": "/path/to/icon.png"}`),
-				), iam.LabelPolicyIconAddedEventMapper),
+				), instance.LabelPolicyIconAddedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceIconAdded,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -715,17 +715,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceIconAdded dark",
+			name: "instance.reduceIconAdded dark",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyIconDarkAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyIconDarkAddedEventType),
+					instance.AggregateType,
 					[]byte(`{"storeKey": "/path/to/icon.png"}`),
-				), iam.LabelPolicyIconDarkAddedEventMapper),
+				), instance.LabelPolicyIconDarkAddedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceIconAdded,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -746,17 +746,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceLogoRemoved light",
+			name: "instance.reduceLogoRemoved light",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyLogoRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyLogoRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{"storeKey": "/path/to/logo.png"}`),
-				), iam.LabelPolicyLogoRemovedEventMapper),
+				), instance.LabelPolicyLogoRemovedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceLogoRemoved,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -777,17 +777,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceLogoRemoved dark",
+			name: "instance.reduceLogoRemoved dark",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyLogoDarkRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyLogoDarkRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{"storeKey": "/path/to/logo.png"}`),
-				), iam.LabelPolicyLogoDarkRemovedEventMapper),
+				), instance.LabelPolicyLogoDarkRemovedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceLogoRemoved,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -808,17 +808,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceIconRemoved light",
+			name: "instance.reduceIconRemoved light",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyIconRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyIconRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{"storeKey": "/path/to/icon.png"}`),
-				), iam.LabelPolicyIconRemovedEventMapper),
+				), instance.LabelPolicyIconRemovedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceIconRemoved,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -839,17 +839,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceIconRemoved dark",
+			name: "instance.reduceIconRemoved dark",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyIconDarkRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyIconDarkRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{"storeKey": "/path/to/icon.png"}`),
-				), iam.LabelPolicyIconDarkRemovedEventMapper),
+				), instance.LabelPolicyIconDarkRemovedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceIconRemoved,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -870,17 +870,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceFontAdded",
+			name: "instance.reduceFontAdded",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyFontAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyFontAddedEventType),
+					instance.AggregateType,
 					[]byte(`{"storeKey": "/path/to/font.ttf"}`),
-				), iam.LabelPolicyFontAddedEventMapper),
+				), instance.LabelPolicyFontAddedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceFontAdded,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -901,17 +901,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceFontRemoved",
+			name: "instance.reduceFontRemoved",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyFontRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyFontRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{"storeKey": "/path/to/font.ttf"}`),
-				), iam.LabelPolicyFontRemovedEventMapper),
+				), instance.LabelPolicyFontRemovedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceFontRemoved,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,
@@ -932,17 +932,17 @@ func TestLabelPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceAssetsRemoved",
+			name: "instance.reduceAssetsRemoved",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LabelPolicyAssetsRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LabelPolicyAssetsRemovedEventType),
+					instance.AggregateType,
 					nil,
-				), iam.LabelPolicyAssetsRemovedEventMapper),
+				), instance.LabelPolicyAssetsRemovedEventMapper),
 			},
 			reduce: (&LabelPolicyProjection{}).reduceAssetsRemoved,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LabelPolicyTable,

internal/query/projection/lockout_policy.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/policy"
 )
@@ -76,14 +76,14 @@ func (p *LockoutPolicyProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.LockoutPolicyAddedEventType,
+					Event:  instance.LockoutPolicyAddedEventType,
 					Reduce: p.reduceAdded,
 				},
 				{
-					Event:  iam.LockoutPolicyChangedEventType,
+					Event:  instance.LockoutPolicyChangedEventType,
 					Reduce: p.reduceChanged,
 				},
 			},
@@ -98,11 +98,11 @@ func (p *LockoutPolicyProjection) reduceAdded(event eventstore.Event) (*handler.
 	case *org.LockoutPolicyAddedEvent:
 		policyEvent = e.LockoutPolicyAddedEvent
 		isDefault = false
-	case *iam.LockoutPolicyAddedEvent:
+	case *instance.LockoutPolicyAddedEvent:
 		policyEvent = e.LockoutPolicyAddedEvent
 		isDefault = true
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-d8mZO", "reduce.wrong.event.type, %v", []eventstore.EventType{org.LockoutPolicyAddedEventType, iam.LockoutPolicyAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-d8mZO", "reduce.wrong.event.type, %v", []eventstore.EventType{org.LockoutPolicyAddedEventType, instance.LockoutPolicyAddedEventType})
 	}
 	return crdb.NewCreateStatement(
 		&policyEvent,
@@ -125,10 +125,10 @@ func (p *LockoutPolicyProjection) reduceChanged(event eventstore.Event) (*handle
 	switch e := event.(type) {
 	case *org.LockoutPolicyChangedEvent:
 		policyEvent = e.LockoutPolicyChangedEvent
-	case *iam.LockoutPolicyChangedEvent:
+	case *instance.LockoutPolicyChangedEvent:
 		policyEvent = e.LockoutPolicyChangedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-pT3mQ", "reduce.wrong.event.type, %v", []eventstore.EventType{org.LockoutPolicyChangedEventType, iam.LockoutPolicyChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-pT3mQ", "reduce.wrong.event.type, %v", []eventstore.EventType{org.LockoutPolicyChangedEventType, instance.LockoutPolicyChangedEventType})
 	}
 	cols := []handler.Column{
 		handler.NewCol(LockoutPolicyChangeDateCol, policyEvent.CreationDate()),

internal/query/projection/lockout_policy_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -123,20 +123,20 @@ func TestLockoutPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceAdded",
+			name:   "instance.reduceAdded",
 			reduce: (&LockoutPolicyProjection{}).reduceAdded,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LockoutPolicyAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LockoutPolicyAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"maxPasswordAttempts": 10,
 						"showLockOutFailures": true
 					}`),
-				), iam.LockoutPolicyAddedEventMapper),
+				), instance.LockoutPolicyAddedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LockoutPolicyTable,
@@ -162,20 +162,20 @@ func TestLockoutPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceChanged",
+			name:   "instance.reduceChanged",
 			reduce: (&LockoutPolicyProjection{}).reduceChanged,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LockoutPolicyChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LockoutPolicyChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"maxPasswordAttempts": 10,
 						"showLockOutFailures": true
 					}`),
-				), iam.LockoutPolicyChangedEventMapper),
+				), instance.LockoutPolicyChangedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LockoutPolicyTable,

internal/query/projection/login_name.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/policy"
 	"github.com/caos/zitadel/internal/repository/user"
@@ -175,16 +175,16 @@ func (p *LoginNameProjection) reducers() []handler.AggregateReducer {
 			Aggregate: org.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  org.OrgIAMPolicyAddedEventType,
+					Event:  org.OrgDomainPolicyAddedEventType,
 					Reduce: p.reduceOrgIAMPolicyAdded,
 				},
 				{
-					Event:  org.OrgIAMPolicyChangedEventType,
-					Reduce: p.reduceOrgIAMPolicyChanged,
+					Event:  org.OrgDomainPolicyChangedEventType,
+					Reduce: p.reduceDomainPolicyChanged,
 				},
 				{
-					Event:  org.OrgIAMPolicyRemovedEventType,
-					Reduce: p.reduceOrgIAMPolicyRemoved,
+					Event:  org.OrgDomainPolicyRemovedEventType,
+					Reduce: p.reduceDomainPolicyRemoved,
 				},
 				{
 					Event:  org.OrgDomainPrimarySetEventType,
@@ -201,15 +201,15 @@ func (p *LoginNameProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.OrgIAMPolicyAddedEventType,
+					Event:  instance.InstanceDomainPolicyAddedEventType,
 					Reduce: p.reduceOrgIAMPolicyAdded,
 				},
 				{
-					Event:  iam.OrgIAMPolicyChangedEventType,
-					Reduce: p.reduceOrgIAMPolicyChanged,
+					Event:  instance.InstanceDomainPolicyChangedEventType,
+					Reduce: p.reduceDomainPolicyChanged,
 				},
 			},
 		},
@@ -295,19 +295,19 @@ func (p *LoginNameProjection) reduceUserDomainClaimed(event eventstore.Event) (*
 
 func (p *LoginNameProjection) reduceOrgIAMPolicyAdded(event eventstore.Event) (*handler.Statement, error) {
 	var (
-		policyEvent *policy.OrgIAMPolicyAddedEvent
+		policyEvent *policy.DomainPolicyAddedEvent
 		isDefault   bool
 	)
 
 	switch e := event.(type) {
-	case *org.OrgIAMPolicyAddedEvent:
-		policyEvent = &e.OrgIAMPolicyAddedEvent
+	case *org.OrgDomainPolicyAddedEvent:
+		policyEvent = &e.DomainPolicyAddedEvent
 		isDefault = false
-	case *iam.OrgIAMPolicyAddedEvent:
-		policyEvent = &e.OrgIAMPolicyAddedEvent
+	case *instance.InstanceDomainPolicyAddedEvent:
+		policyEvent = &e.DomainPolicyAddedEvent
 		isDefault = true
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-yCV6S", "reduce.wrong.event.type %v", []eventstore.EventType{org.OrgIAMPolicyAddedEventType, iam.OrgIAMPolicyAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-yCV6S", "reduce.wrong.event.type %v", []eventstore.EventType{org.OrgDomainPolicyAddedEventType, instance.InstanceDomainPolicyAddedEventType})
 	}
 
 	return crdb.NewCreateStatement(
@@ -322,16 +322,16 @@ func (p *LoginNameProjection) reduceOrgIAMPolicyAdded(event eventstore.Event) (*
 	), nil
 }
 
-func (p *LoginNameProjection) reduceOrgIAMPolicyChanged(event eventstore.Event) (*handler.Statement, error) {
-	var policyEvent *policy.OrgIAMPolicyChangedEvent
+func (p *LoginNameProjection) reduceDomainPolicyChanged(event eventstore.Event) (*handler.Statement, error) {
+	var policyEvent *policy.DomainPolicyChangedEvent
 
 	switch e := event.(type) {
-	case *org.OrgIAMPolicyChangedEvent:
-		policyEvent = &e.OrgIAMPolicyChangedEvent
-	case *iam.OrgIAMPolicyChangedEvent:
-		policyEvent = &e.OrgIAMPolicyChangedEvent
+	case *org.OrgDomainPolicyChangedEvent:
+		policyEvent = &e.DomainPolicyChangedEvent
+	case *instance.InstanceDomainPolicyChangedEvent:
+		policyEvent = &e.DomainPolicyChangedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-ArFDd", "reduce.wrong.event.type %v", []eventstore.EventType{org.OrgIAMPolicyChangedEventType, iam.OrgIAMPolicyChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-ArFDd", "reduce.wrong.event.type %v", []eventstore.EventType{org.OrgDomainPolicyChangedEventType, instance.InstanceDomainPolicyChangedEventType})
 	}
 
 	if policyEvent.UserLoginMustBeDomain == nil {
@@ -350,10 +350,10 @@ func (p *LoginNameProjection) reduceOrgIAMPolicyChanged(event eventstore.Event)
 	), nil
 }
 
-func (p *LoginNameProjection) reduceOrgIAMPolicyRemoved(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*org.OrgIAMPolicyRemovedEvent)
+func (p *LoginNameProjection) reduceDomainPolicyRemoved(event eventstore.Event) (*handler.Statement, error) {
+	e, ok := event.(*org.OrgDomainPolicyRemovedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-ysEeB", "reduce.wrong.event.type %s", org.OrgIAMPolicyRemovedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-ysEeB", "reduce.wrong.event.type %s", org.OrgDomainPolicyRemovedEventType)
 	}
 
 	return crdb.NewDeleteStatement(

internal/query/projection/login_name_test.go

@@ -7,7 +7,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/user"
 )
@@ -206,15 +206,15 @@ func TestLoginNameProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "org.OrgIAMPolicyAddedEventType",
+			name: "org.OrgDomainPolicyAddedEventType",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(org.OrgIAMPolicyAddedEventType),
+					repository.EventType(org.OrgDomainPolicyAddedEventType),
 					user.AggregateType,
 					[]byte(`{
 					"userLoginMustBeDomain": true
 				}`),
-				), org.OrgIAMPolicyAddedEventMapper),
+				), org.OrgDomainPolicyAddedEventMapper),
 			},
 			reduce: (&LoginNameProjection{}).reduceOrgIAMPolicyAdded,
 			want: wantReduce{
@@ -238,17 +238,17 @@ func TestLoginNameProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "org.OrgIAMPolicyChangedEventType",
+			name: "org.OrgDomainPolicyChangedEventType",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(org.OrgIAMPolicyChangedEventType),
+					repository.EventType(org.OrgDomainPolicyChangedEventType),
 					user.AggregateType,
 					[]byte(`{
 					"userLoginMustBeDomain": false
 				}`),
-				), org.OrgIAMPolicyChangedEventMapper),
+				), org.OrgDomainPolicyChangedEventMapper),
 			},
-			reduce: (&LoginNameProjection{}).reduceOrgIAMPolicyChanged,
+			reduce: (&LoginNameProjection{}).reduceDomainPolicyChanged,
 			want: wantReduce{
 				aggregateType:    user.AggregateType,
 				sequence:         15,
@@ -268,15 +268,15 @@ func TestLoginNameProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "org.OrgIAMPolicyChangedEventType no change",
+			name: "org.OrgDomainPolicyChangedEventType no change",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(org.OrgIAMPolicyChangedEventType),
+					repository.EventType(org.OrgDomainPolicyChangedEventType),
 					user.AggregateType,
 					[]byte(`{}`),
-				), org.OrgIAMPolicyChangedEventMapper),
+				), org.OrgDomainPolicyChangedEventMapper),
 			},
-			reduce: (&LoginNameProjection{}).reduceOrgIAMPolicyChanged,
+			reduce: (&LoginNameProjection{}).reduceDomainPolicyChanged,
 			want: wantReduce{
 				aggregateType:    user.AggregateType,
 				sequence:         15,
@@ -288,15 +288,15 @@ func TestLoginNameProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "org.OrgIAMPolicyRemovedEventType",
+			name: "org.OrgDomainPolicyRemovedEventType",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(org.OrgIAMPolicyRemovedEventType),
+					repository.EventType(org.OrgDomainPolicyRemovedEventType),
 					user.AggregateType,
 					[]byte(`{}`),
-				), org.OrgIAMPolicyRemovedEventMapper),
+				), org.OrgDomainPolicyRemovedEventMapper),
 			},
-			reduce: (&LoginNameProjection{}).reduceOrgIAMPolicyRemoved,
+			reduce: (&LoginNameProjection{}).reduceDomainPolicyRemoved,
 			want: wantReduce{
 				aggregateType:    user.AggregateType,
 				sequence:         15,
@@ -415,15 +415,15 @@ func TestLoginNameProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.OrgIAMPolicyAddedEventType",
+			name: "iam.OrgDomainPolicyAddedEventType",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.OrgIAMPolicyAddedEventType),
+					repository.EventType(instance.InstanceDomainPolicyAddedEventType),
 					user.AggregateType,
 					[]byte(`{
 					"userLoginMustBeDomain": true
 				}`),
-				), iam.OrgIAMPolicyAddedEventMapper),
+				), instance.InstanceDomainPolicyAddedEventMapper),
 			},
 			reduce: (&LoginNameProjection{}).reduceOrgIAMPolicyAdded,
 			want: wantReduce{
@@ -447,17 +447,17 @@ func TestLoginNameProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.OrgIAMPolicyChangedEventType",
+			name: "iam.OrgDomainPolicyChangedEventType",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.OrgIAMPolicyChangedEventType),
+					repository.EventType(instance.InstanceDomainPolicyChangedEventType),
 					user.AggregateType,
 					[]byte(`{
 					"userLoginMustBeDomain": false
 				}`),
-				), iam.OrgIAMPolicyChangedEventMapper),
+				), instance.InstanceDomainPolicyChangedEventMapper),
 			},
-			reduce: (&LoginNameProjection{}).reduceOrgIAMPolicyChanged,
+			reduce: (&LoginNameProjection{}).reduceDomainPolicyChanged,
 			want: wantReduce{
 				aggregateType:    user.AggregateType,
 				sequence:         15,
@@ -477,15 +477,15 @@ func TestLoginNameProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.OrgIAMPolicyChangedEventType no change",
+			name: "iam.OrgDomainPolicyChangedEventType no change",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.OrgIAMPolicyChangedEventType),
+					repository.EventType(instance.InstanceDomainPolicyChangedEventType),
 					user.AggregateType,
 					[]byte(`{}`),
-				), iam.OrgIAMPolicyChangedEventMapper),
+				), instance.InstanceDomainPolicyChangedEventMapper),
 			},
-			reduce: (&LoginNameProjection{}).reduceOrgIAMPolicyChanged,
+			reduce: (&LoginNameProjection{}).reduceDomainPolicyChanged,
 			want: wantReduce{
 				aggregateType:    user.AggregateType,
 				sequence:         15,

internal/query/projection/login_policy.go

@@ -7,7 +7,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/policy"
 )
@@ -109,30 +109,30 @@ func (p *LoginPolicyProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.LoginPolicyAddedEventType,
+					Event:  instance.LoginPolicyAddedEventType,
 					Reduce: p.reduceLoginPolicyAdded,
 				},
 				{
-					Event:  iam.LoginPolicyChangedEventType,
+					Event:  instance.LoginPolicyChangedEventType,
 					Reduce: p.reduceLoginPolicyChanged,
 				},
 				{
-					Event:  iam.LoginPolicyMultiFactorAddedEventType,
+					Event:  instance.LoginPolicyMultiFactorAddedEventType,
 					Reduce: p.reduceMFAAdded,
 				},
 				{
-					Event:  iam.LoginPolicyMultiFactorRemovedEventType,
+					Event:  instance.LoginPolicyMultiFactorRemovedEventType,
 					Reduce: p.reduceMFARemoved,
 				},
 				{
-					Event:  iam.LoginPolicySecondFactorAddedEventType,
+					Event:  instance.LoginPolicySecondFactorAddedEventType,
 					Reduce: p.reduce2FAAdded,
 				},
 				{
-					Event:  iam.LoginPolicySecondFactorRemovedEventType,
+					Event:  instance.LoginPolicySecondFactorRemovedEventType,
 					Reduce: p.reduce2FARemoved,
 				},
 			},
@@ -144,14 +144,14 @@ func (p *LoginPolicyProjection) reduceLoginPolicyAdded(event eventstore.Event) (
 	var policyEvent policy.LoginPolicyAddedEvent
 	var isDefault bool
 	switch e := event.(type) {
-	case *iam.LoginPolicyAddedEvent:
+	case *instance.LoginPolicyAddedEvent:
 		policyEvent = e.LoginPolicyAddedEvent
 		isDefault = true
 	case *org.LoginPolicyAddedEvent:
 		policyEvent = e.LoginPolicyAddedEvent
 		isDefault = false
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-pYPxS", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyAddedEventType, iam.LoginPolicyAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-pYPxS", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyAddedEventType, instance.LoginPolicyAddedEventType})
 	}
 
 	return crdb.NewCreateStatement(&policyEvent, []handler.Column{
@@ -178,12 +178,12 @@ func (p *LoginPolicyProjection) reduceLoginPolicyAdded(event eventstore.Event) (
 func (p *LoginPolicyProjection) reduceLoginPolicyChanged(event eventstore.Event) (*handler.Statement, error) {
 	var policyEvent policy.LoginPolicyChangedEvent
 	switch e := event.(type) {
-	case *iam.LoginPolicyChangedEvent:
+	case *instance.LoginPolicyChangedEvent:
 		policyEvent = e.LoginPolicyChangedEvent
 	case *org.LoginPolicyChangedEvent:
 		policyEvent = e.LoginPolicyChangedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-BpaO6", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyChangedEventType, iam.LoginPolicyChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-BpaO6", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyChangedEventType, instance.LoginPolicyChangedEventType})
 	}
 
 	cols := []handler.Column{
@@ -236,12 +236,12 @@ func (p *LoginPolicyProjection) reduceLoginPolicyChanged(event eventstore.Event)
 func (p *LoginPolicyProjection) reduceMFAAdded(event eventstore.Event) (*handler.Statement, error) {
 	var policyEvent policy.MultiFactorAddedEvent
 	switch e := event.(type) {
-	case *iam.LoginPolicyMultiFactorAddedEvent:
+	case *instance.LoginPolicyMultiFactorAddedEvent:
 		policyEvent = e.MultiFactorAddedEvent
 	case *org.LoginPolicyMultiFactorAddedEvent:
 		policyEvent = e.MultiFactorAddedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-WMhAV", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyMultiFactorAddedEventType, iam.LoginPolicyMultiFactorAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-WMhAV", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyMultiFactorAddedEventType, instance.LoginPolicyMultiFactorAddedEventType})
 	}
 
 	return crdb.NewUpdateStatement(
@@ -260,12 +260,12 @@ func (p *LoginPolicyProjection) reduceMFAAdded(event eventstore.Event) (*handler
 func (p *LoginPolicyProjection) reduceMFARemoved(event eventstore.Event) (*handler.Statement, error) {
 	var policyEvent policy.MultiFactorRemovedEvent
 	switch e := event.(type) {
-	case *iam.LoginPolicyMultiFactorRemovedEvent:
+	case *instance.LoginPolicyMultiFactorRemovedEvent:
 		policyEvent = e.MultiFactorRemovedEvent
 	case *org.LoginPolicyMultiFactorRemovedEvent:
 		policyEvent = e.MultiFactorRemovedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-czU7n", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyMultiFactorRemovedEventType, iam.LoginPolicyMultiFactorRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-czU7n", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicyMultiFactorRemovedEventType, instance.LoginPolicyMultiFactorRemovedEventType})
 	}
 
 	return crdb.NewUpdateStatement(
@@ -297,12 +297,12 @@ func (p *LoginPolicyProjection) reduceLoginPolicyRemoved(event eventstore.Event)
 func (p *LoginPolicyProjection) reduce2FAAdded(event eventstore.Event) (*handler.Statement, error) {
 	var policyEvent policy.SecondFactorAddedEvent
 	switch e := event.(type) {
-	case *iam.LoginPolicySecondFactorAddedEvent:
+	case *instance.LoginPolicySecondFactorAddedEvent:
 		policyEvent = e.SecondFactorAddedEvent
 	case *org.LoginPolicySecondFactorAddedEvent:
 		policyEvent = e.SecondFactorAddedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-agB2E", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicySecondFactorAddedEventType, iam.LoginPolicySecondFactorAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-agB2E", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicySecondFactorAddedEventType, instance.LoginPolicySecondFactorAddedEventType})
 	}
 
 	return crdb.NewUpdateStatement(
@@ -321,12 +321,12 @@ func (p *LoginPolicyProjection) reduce2FAAdded(event eventstore.Event) (*handler
 func (p *LoginPolicyProjection) reduce2FARemoved(event eventstore.Event) (*handler.Statement, error) {
 	var policyEvent policy.SecondFactorRemovedEvent
 	switch e := event.(type) {
-	case *iam.LoginPolicySecondFactorRemovedEvent:
+	case *instance.LoginPolicySecondFactorRemovedEvent:
 		policyEvent = e.SecondFactorRemovedEvent
 	case *org.LoginPolicySecondFactorRemovedEvent:
 		policyEvent = e.SecondFactorRemovedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-KYJvA", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicySecondFactorRemovedEventType, iam.LoginPolicySecondFactorRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-KYJvA", "reduce.wrong.event.type %v", []eventstore.EventType{org.LoginPolicySecondFactorRemovedEventType, instance.LoginPolicySecondFactorRemovedEventType})
 	}
 
 	return crdb.NewUpdateStatement(

internal/query/projection/login_policy_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -286,12 +286,12 @@ func TestLoginPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceLoginPolicyAdded",
+			name:   "instance.reduceLoginPolicyAdded",
 			reduce: (&LoginPolicyProjection{}).reduceLoginPolicyAdded,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LoginPolicyAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LoginPolicyAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"allowUsernamePassword": true,
 						"allowRegister": true,
@@ -305,10 +305,10 @@ func TestLoginPolicyProjection_reduces(t *testing.T) {
 						"secondFactorCheckLifetime": 10000000,
 						"multiFactorCheckLifetime": 10000000
 			}`),
-				), iam.LoginPolicyAddedEventMapper),
+				), instance.LoginPolicyAddedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LoginPolicyTable,
@@ -341,12 +341,12 @@ func TestLoginPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceLoginPolicyChanged",
+			name:   "instance.reduceLoginPolicyChanged",
 			reduce: (&LoginPolicyProjection{}).reduceLoginPolicyChanged,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LoginPolicyChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LoginPolicyChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 			"allowUsernamePassword": true,
 			"allowRegister": true,
@@ -355,10 +355,10 @@ func TestLoginPolicyProjection_reduces(t *testing.T) {
 			"hidePasswordReset": true,
 			"passwordlessType": 1
 			}`),
-				), iam.LoginPolicyChangedEventMapper),
+				), instance.LoginPolicyChangedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LoginPolicyTable,
@@ -383,19 +383,19 @@ func TestLoginPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceMFAAdded",
+			name:   "instance.reduceMFAAdded",
 			reduce: (&LoginPolicyProjection{}).reduceMFAAdded,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LoginPolicyMultiFactorAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LoginPolicyMultiFactorAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 		"mfaType": 1
 		}`),
-				), iam.MultiFactorAddedEventMapper),
+				), instance.MultiFactorAddedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LoginPolicyTable,
@@ -415,19 +415,19 @@ func TestLoginPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceMFARemoved",
+			name:   "instance.reduceMFARemoved",
 			reduce: (&LoginPolicyProjection{}).reduceMFARemoved,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LoginPolicyMultiFactorRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LoginPolicyMultiFactorRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 			"mfaType": 1
 			}`),
-				), iam.MultiFactorRemovedEventMapper),
+				), instance.MultiFactorRemovedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LoginPolicyTable,
@@ -447,19 +447,19 @@ func TestLoginPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduce2FAAdded",
+			name:   "instance.reduce2FAAdded",
 			reduce: (&LoginPolicyProjection{}).reduce2FAAdded,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LoginPolicySecondFactorAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LoginPolicySecondFactorAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 			"mfaType": 2
 			}`),
-				), iam.SecondFactorAddedEventMapper),
+				), instance.SecondFactorAddedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LoginPolicyTable,
@@ -479,19 +479,19 @@ func TestLoginPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduce2FARemoved",
+			name:   "instance.reduce2FARemoved",
 			reduce: (&LoginPolicyProjection{}).reduce2FARemoved,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.LoginPolicySecondFactorRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.LoginPolicySecondFactorRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 			"mfaType": 2
 			}`),
-				), iam.SecondFactorRemovedEventMapper),
+				), instance.SecondFactorRemovedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       LoginPolicyTable,

internal/query/projection/mail_template.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/policy"
 )
@@ -72,14 +72,14 @@ func (p *MailTemplateProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.MailTemplateAddedEventType,
+					Event:  instance.MailTemplateAddedEventType,
 					Reduce: p.reduceAdded,
 				},
 				{
-					Event:  iam.MailTemplateChangedEventType,
+					Event:  instance.MailTemplateChangedEventType,
 					Reduce: p.reduceChanged,
 				},
 			},
@@ -94,11 +94,11 @@ func (p *MailTemplateProjection) reduceAdded(event eventstore.Event) (*handler.S
 	case *org.MailTemplateAddedEvent:
 		templateEvent = e.MailTemplateAddedEvent
 		isDefault = false
-	case *iam.MailTemplateAddedEvent:
+	case *instance.MailTemplateAddedEvent:
 		templateEvent = e.MailTemplateAddedEvent
 		isDefault = true
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-0pJ3f", "reduce.wrong.event.type, %v", []eventstore.EventType{org.MailTemplateAddedEventType, iam.MailTemplateAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-0pJ3f", "reduce.wrong.event.type, %v", []eventstore.EventType{org.MailTemplateAddedEventType, instance.MailTemplateAddedEventType})
 	}
 	return crdb.NewCreateStatement(
 		&templateEvent,
@@ -119,10 +119,10 @@ func (p *MailTemplateProjection) reduceChanged(event eventstore.Event) (*handler
 	switch e := event.(type) {
 	case *org.MailTemplateChangedEvent:
 		policyEvent = e.MailTemplateChangedEvent
-	case *iam.MailTemplateChangedEvent:
+	case *instance.MailTemplateChangedEvent:
 		policyEvent = e.MailTemplateChangedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-gJ03f", "reduce.wrong.event.type, %v", []eventstore.EventType{org.MailTemplateChangedEventType, iam.MailTemplateChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-gJ03f", "reduce.wrong.event.type, %v", []eventstore.EventType{org.MailTemplateChangedEventType, instance.MailTemplateChangedEventType})
 	}
 	cols := []handler.Column{
 		handler.NewCol(MailTemplateChangeDateCol, policyEvent.CreationDate()),

internal/query/projection/mail_template_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -118,19 +118,19 @@ func TestMailTemplateProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceAdded",
+			name:   "instance.reduceAdded",
 			reduce: (&MailTemplateProjection{}).reduceAdded,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.MailTemplateAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.MailTemplateAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"template": "PHRhYmxlPjwvdGFibGU+"
 					}`),
-				), iam.MailTemplateAddedEventMapper),
+				), instance.MailTemplateAddedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       MailTemplateTable,
@@ -154,19 +154,19 @@ func TestMailTemplateProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceChanged",
+			name:   "instance.reduceChanged",
 			reduce: (&MailTemplateProjection{}).reduceChanged,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.MailTemplateChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.MailTemplateChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"template": "PHRhYmxlPjwvdGFibGU+"
 					}`),
-				), iam.MailTemplateChangedEventMapper),
+				), instance.MailTemplateChangedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       MailTemplateTable,

internal/query/projection/message_text_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -588,22 +588,22 @@ func TestMessageTextProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceAdded",
+			name:   "instance.reduceAdded",
 			reduce: (&MessageTextProjection{}).reduceAdded,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.CustomTextSetEventType),
-					iam.AggregateType,
+					repository.EventType(instance.CustomTextSetEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"key": "Title",
 						"language": "en",
 						"template": "InitCode",
 						"text": "Test"
 					}`),
-				), iam.CustomTextSetEventMapper),
+				), instance.CustomTextSetEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       MessageTextTable,
@@ -628,21 +628,21 @@ func TestMessageTextProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceRemoved.Title",
+			name: "instance.reduceRemoved.Title",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.CustomTextRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.CustomTextRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"key": "Title",
 						"language": "en",
 						"template": "InitCode"
 					}`),
-				), iam.CustomTextRemovedEventMapper),
+				), instance.CustomTextRemovedEventMapper),
 			},
 			reduce: (&MessageTextProjection{}).reduceRemoved,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       MessageTextTable,

internal/query/projection/message_texts.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/policy"
 )
@@ -86,18 +86,18 @@ func (p *MessageTextProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.CustomTextSetEventType,
+					Event:  instance.CustomTextSetEventType,
 					Reduce: p.reduceAdded,
 				},
 				{
-					Event:  iam.CustomTextRemovedEventType,
+					Event:  instance.CustomTextRemovedEventType,
 					Reduce: p.reduceRemoved,
 				},
 				{
-					Event:  iam.CustomTextTemplateRemovedEventType,
+					Event:  instance.CustomTextTemplateRemovedEventType,
 					Reduce: p.reduceTemplateRemoved,
 				},
 			},
@@ -110,10 +110,10 @@ func (p *MessageTextProjection) reduceAdded(event eventstore.Event) (*handler.St
 	switch e := event.(type) {
 	case *org.CustomTextSetEvent:
 		templateEvent = e.CustomTextSetEvent
-	case *iam.CustomTextSetEvent:
+	case *instance.CustomTextSetEvent:
 		templateEvent = e.CustomTextSetEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-2n90r", "reduce.wrong.event.type %v", []eventstore.EventType{org.CustomTextSetEventType, iam.CustomTextSetEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-2n90r", "reduce.wrong.event.type %v", []eventstore.EventType{org.CustomTextSetEventType, instance.CustomTextSetEventType})
 	}
 	if !isMessageTemplate(templateEvent.Template) {
 		return crdb.NewNoOpStatement(event), nil
@@ -160,10 +160,10 @@ func (p *MessageTextProjection) reduceRemoved(event eventstore.Event) (*handler.
 	switch e := event.(type) {
 	case *org.CustomTextRemovedEvent:
 		templateEvent = e.CustomTextRemovedEvent
-	case *iam.CustomTextRemovedEvent:
+	case *instance.CustomTextRemovedEvent:
 		templateEvent = e.CustomTextRemovedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-fm0ge", "reduce.wrong.event.type %v", []eventstore.EventType{org.CustomTextRemovedEventType, iam.CustomTextRemovedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-fm0ge", "reduce.wrong.event.type %v", []eventstore.EventType{org.CustomTextRemovedEventType, instance.CustomTextRemovedEventType})
 	}
 	if !isMessageTemplate(templateEvent.Template) {
 		return crdb.NewNoOpStatement(event), nil
@@ -209,7 +209,7 @@ func (p *MessageTextProjection) reduceTemplateRemoved(event eventstore.Event) (*
 	switch e := event.(type) {
 	case *org.CustomTextTemplateRemovedEvent:
 		templateEvent = e.CustomTextTemplateRemovedEvent
-	case *iam.CustomTextTemplateRemovedEvent:
+	case *instance.CustomTextTemplateRemovedEvent:
 		templateEvent = e.CustomTextTemplateRemovedEvent
 	default:
 		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-2n9rs", "reduce.wrong.event.type %s", org.CustomTextTemplateRemovedEventType)

internal/query/projection/oidc_settings.go

@@ -7,7 +7,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/project"
 )
 
@@ -61,11 +61,11 @@ func (p *OIDCSettingsProjection) reducers() []handler.AggregateReducer {
 			Aggregate: project.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.OIDCSettingsAddedEventType,
+					Event:  instance.OIDCSettingsAddedEventType,
 					Reduce: p.reduceOIDCSettingsAdded,
 				},
 				{
-					Event:  iam.OIDCSettingsChangedEventType,
+					Event:  instance.OIDCSettingsChangedEventType,
 					Reduce: p.reduceOIDCSettingsChanged,
 				},
 			},
@@ -74,9 +74,9 @@ func (p *OIDCSettingsProjection) reducers() []handler.AggregateReducer {
 }
 
 func (p *OIDCSettingsProjection) reduceOIDCSettingsAdded(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.OIDCSettingsAddedEvent)
+	e, ok := event.(*instance.OIDCSettingsAddedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-f9nwf", "reduce.wrong.event.type %s", iam.OIDCSettingsAddedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-f9nwf", "reduce.wrong.event.type %s", instance.OIDCSettingsAddedEventType)
 	}
 	return crdb.NewCreateStatement(
 		e,
@@ -96,9 +96,9 @@ func (p *OIDCSettingsProjection) reduceOIDCSettingsAdded(event eventstore.Event)
 }
 
 func (p *OIDCSettingsProjection) reduceOIDCSettingsChanged(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.OIDCSettingsChangedEvent)
+	e, ok := event.(*instance.OIDCSettingsChangedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-8JJ2d", "reduce.wrong.event.type %s", iam.OIDCSettingsChangedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-8JJ2d", "reduce.wrong.event.type %s", instance.OIDCSettingsChangedEventType)
 	}
 
 	columns := make([]handler.Column, 0, 6)

internal/query/projection/oidc_settings_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 )
 
 func TestOIDCSettingsProjection_reduces(t *testing.T) {
@@ -25,15 +25,15 @@ func TestOIDCSettingsProjection_reduces(t *testing.T) {
 			name: "reduceOIDCSettingsChanged",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.OIDCSettingsChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.OIDCSettingsChangedEventType),
+					instance.AggregateType,
 					[]byte(`{"accessTokenLifetime": 10000000, "idTokenLifetime": 10000000, "refreshTokenIdleExpiration": 10000000, "refreshTokenExpiration": 10000000}`),
-				), iam.OIDCSettingsChangedEventMapper),
+				), instance.OIDCSettingsChangedEventMapper),
 			},
 			reduce: (&OIDCSettingsProjection{}).reduceOIDCSettingsChanged,
 			want: wantReduce{
 				projection:       OIDCSettingsProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{
@@ -58,15 +58,15 @@ func TestOIDCSettingsProjection_reduces(t *testing.T) {
 			name: "reduceOIDCSettingsAdded",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.OIDCSettingsAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.OIDCSettingsAddedEventType),
+					instance.AggregateType,
 					[]byte(`{"accessTokenLifetime": 10000000, "idTokenLifetime": 10000000, "refreshTokenIdleExpiration": 10000000, "refreshTokenExpiration": 10000000}`),
-				), iam.OIDCSettingsAddedEventMapper),
+				), instance.OIDCSettingsAddedEventMapper),
 			},
 			reduce: (&OIDCSettingsProjection{}).reduceOIDCSettingsAdded,
 			want: wantReduce{
 				projection:       OIDCSettingsProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{

internal/query/projection/org_iam_policy.go

@@ -8,80 +8,80 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/policy"
 )
 
 const (
-	OrgIAMPolicyTable = "projections.org_iam_policies"
+	DomainPolicyTable = "projections.domain_policies"
 
-	OrgIAMPolicyIDCol                    = "id"
-	OrgIAMPolicyCreationDateCol          = "creation_date"
-	OrgIAMPolicyChangeDateCol            = "change_date"
-	OrgIAMPolicySequenceCol              = "sequence"
-	OrgIAMPolicyStateCol                 = "state"
-	OrgIAMPolicyUserLoginMustBeDomainCol = "user_login_must_be_domain"
-	OrgIAMPolicyIsDefaultCol             = "is_default"
-	OrgIAMPolicyResourceOwnerCol         = "resource_owner"
-	OrgIAMPolicyInstanceIDCol            = "instance_id"
+	DomainPolicyIDCol                    = "id"
+	DomainPolicyCreationDateCol          = "creation_date"
+	DomainPolicyChangeDateCol            = "change_date"
+	DomainPolicySequenceCol              = "sequence"
+	DomainPolicyStateCol                 = "state"
+	DomainPolicyUserLoginMustBeDomainCol = "user_login_must_be_domain"
+	DomainPolicyIsDefaultCol             = "is_default"
+	DomainPolicyResourceOwnerCol         = "resource_owner"
+	DomainPolicyInstanceIDCol            = "instance_id"
 )
 
-type OrgIAMPolicyProjection struct {
+type DomainPolicyProjection struct {
 	crdb.StatementHandler
 }
 
-func NewOrgIAMPolicyProjection(ctx context.Context, config crdb.StatementHandlerConfig) *OrgIAMPolicyProjection {
-	p := new(OrgIAMPolicyProjection)
-	config.ProjectionName = OrgIAMPolicyTable
+func NewDomainPolicyProjection(ctx context.Context, config crdb.StatementHandlerConfig) *DomainPolicyProjection {
+	p := new(DomainPolicyProjection)
+	config.ProjectionName = DomainPolicyTable
 	config.Reducers = p.reducers()
 	config.InitCheck = crdb.NewTableCheck(
 		crdb.NewTable([]*crdb.Column{
-			crdb.NewColumn(OrgIAMPolicyIDCol, crdb.ColumnTypeText),
-			crdb.NewColumn(OrgIAMPolicyCreationDateCol, crdb.ColumnTypeTimestamp),
-			crdb.NewColumn(OrgIAMPolicyChangeDateCol, crdb.ColumnTypeTimestamp),
-			crdb.NewColumn(OrgIAMPolicySequenceCol, crdb.ColumnTypeInt64),
-			crdb.NewColumn(OrgIAMPolicyStateCol, crdb.ColumnTypeEnum),
-			crdb.NewColumn(OrgIAMPolicyUserLoginMustBeDomainCol, crdb.ColumnTypeBool),
-			crdb.NewColumn(OrgIAMPolicyIsDefaultCol, crdb.ColumnTypeBool, crdb.Default(false)),
-			crdb.NewColumn(OrgIAMPolicyResourceOwnerCol, crdb.ColumnTypeText),
-			crdb.NewColumn(OrgIAMPolicyInstanceIDCol, crdb.ColumnTypeText),
+			crdb.NewColumn(DomainPolicyIDCol, crdb.ColumnTypeText),
+			crdb.NewColumn(DomainPolicyCreationDateCol, crdb.ColumnTypeTimestamp),
+			crdb.NewColumn(DomainPolicyChangeDateCol, crdb.ColumnTypeTimestamp),
+			crdb.NewColumn(DomainPolicySequenceCol, crdb.ColumnTypeInt64),
+			crdb.NewColumn(DomainPolicyStateCol, crdb.ColumnTypeEnum),
+			crdb.NewColumn(DomainPolicyUserLoginMustBeDomainCol, crdb.ColumnTypeBool),
+			crdb.NewColumn(DomainPolicyIsDefaultCol, crdb.ColumnTypeBool, crdb.Default(false)),
+			crdb.NewColumn(DomainPolicyResourceOwnerCol, crdb.ColumnTypeText),
+			crdb.NewColumn(DomainPolicyInstanceIDCol, crdb.ColumnTypeText),
 		},
-			crdb.NewPrimaryKey(OrgIAMPolicyInstanceIDCol, OrgIAMPolicyIDCol),
+			crdb.NewPrimaryKey(DomainPolicyInstanceIDCol, DomainPolicyIDCol),
 		),
 	)
 	p.StatementHandler = crdb.NewStatementHandler(ctx, config)
 	return p
 }
 
-func (p *OrgIAMPolicyProjection) reducers() []handler.AggregateReducer {
+func (p *DomainPolicyProjection) reducers() []handler.AggregateReducer {
 	return []handler.AggregateReducer{
 		{
 			Aggregate: org.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  org.OrgIAMPolicyAddedEventType,
+					Event:  org.OrgDomainPolicyAddedEventType,
 					Reduce: p.reduceAdded,
 				},
 				{
-					Event:  org.OrgIAMPolicyChangedEventType,
+					Event:  org.OrgDomainPolicyChangedEventType,
 					Reduce: p.reduceChanged,
 				},
 				{
-					Event:  org.OrgIAMPolicyRemovedEventType,
+					Event:  org.OrgDomainPolicyRemovedEventType,
 					Reduce: p.reduceRemoved,
 				},
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.OrgIAMPolicyAddedEventType,
+					Event:  instance.InstanceDomainPolicyAddedEventType,
 					Reduce: p.reduceAdded,
 				},
 				{
-					Event:  iam.OrgIAMPolicyChangedEventType,
+					Event:  instance.InstanceDomainPolicyChangedEventType,
 					Reduce: p.reduceChanged,
 				},
 			},
@@ -89,67 +89,67 @@ func (p *OrgIAMPolicyProjection) reducers() []handler.AggregateReducer {
 	}
 }
 
-func (p *OrgIAMPolicyProjection) reduceAdded(event eventstore.Event) (*handler.Statement, error) {
-	var policyEvent policy.OrgIAMPolicyAddedEvent
+func (p *DomainPolicyProjection) reduceAdded(event eventstore.Event) (*handler.Statement, error) {
+	var policyEvent policy.DomainPolicyAddedEvent
 	var isDefault bool
 	switch e := event.(type) {
-	case *org.OrgIAMPolicyAddedEvent:
-		policyEvent = e.OrgIAMPolicyAddedEvent
+	case *org.OrgDomainPolicyAddedEvent:
+		policyEvent = e.DomainPolicyAddedEvent
 		isDefault = false
-	case *iam.OrgIAMPolicyAddedEvent:
-		policyEvent = e.OrgIAMPolicyAddedEvent
+	case *instance.InstanceDomainPolicyAddedEvent:
+		policyEvent = e.DomainPolicyAddedEvent
 		isDefault = true
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-CSE7A", "reduce.wrong.event.type %v", []eventstore.EventType{org.OrgIAMPolicyAddedEventType, iam.OrgIAMPolicyAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-CSE7A", "reduce.wrong.event.type %v", []eventstore.EventType{org.OrgDomainPolicyAddedEventType, instance.InstanceDomainPolicyAddedEventType})
 	}
 	return crdb.NewCreateStatement(
 		&policyEvent,
 		[]handler.Column{
-			handler.NewCol(OrgIAMPolicyCreationDateCol, policyEvent.CreationDate()),
-			handler.NewCol(OrgIAMPolicyChangeDateCol, policyEvent.CreationDate()),
-			handler.NewCol(OrgIAMPolicySequenceCol, policyEvent.Sequence()),
-			handler.NewCol(OrgIAMPolicyIDCol, policyEvent.Aggregate().ID),
-			handler.NewCol(OrgIAMPolicyStateCol, domain.PolicyStateActive),
-			handler.NewCol(OrgIAMPolicyUserLoginMustBeDomainCol, policyEvent.UserLoginMustBeDomain),
-			handler.NewCol(OrgIAMPolicyIsDefaultCol, isDefault),
-			handler.NewCol(OrgIAMPolicyResourceOwnerCol, policyEvent.Aggregate().ResourceOwner),
-			handler.NewCol(OrgIAMPolicyInstanceIDCol, policyEvent.Aggregate().InstanceID),
+			handler.NewCol(DomainPolicyCreationDateCol, policyEvent.CreationDate()),
+			handler.NewCol(DomainPolicyChangeDateCol, policyEvent.CreationDate()),
+			handler.NewCol(DomainPolicySequenceCol, policyEvent.Sequence()),
+			handler.NewCol(DomainPolicyIDCol, policyEvent.Aggregate().ID),
+			handler.NewCol(DomainPolicyStateCol, domain.PolicyStateActive),
+			handler.NewCol(DomainPolicyUserLoginMustBeDomainCol, policyEvent.UserLoginMustBeDomain),
+			handler.NewCol(DomainPolicyIsDefaultCol, isDefault),
+			handler.NewCol(DomainPolicyResourceOwnerCol, policyEvent.Aggregate().ResourceOwner),
+			handler.NewCol(DomainPolicyInstanceIDCol, policyEvent.Aggregate().InstanceID),
 		}), nil
 }
 
-func (p *OrgIAMPolicyProjection) reduceChanged(event eventstore.Event) (*handler.Statement, error) {
-	var policyEvent policy.OrgIAMPolicyChangedEvent
+func (p *DomainPolicyProjection) reduceChanged(event eventstore.Event) (*handler.Statement, error) {
+	var policyEvent policy.DomainPolicyChangedEvent
 	switch e := event.(type) {
-	case *org.OrgIAMPolicyChangedEvent:
-		policyEvent = e.OrgIAMPolicyChangedEvent
-	case *iam.OrgIAMPolicyChangedEvent:
-		policyEvent = e.OrgIAMPolicyChangedEvent
+	case *org.OrgDomainPolicyChangedEvent:
+		policyEvent = e.DomainPolicyChangedEvent
+	case *instance.InstanceDomainPolicyChangedEvent:
+		policyEvent = e.DomainPolicyChangedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-qgVug", "reduce.wrong.event.type %v", []eventstore.EventType{org.OrgIAMPolicyChangedEventType, iam.OrgIAMPolicyChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-qgVug", "reduce.wrong.event.type %v", []eventstore.EventType{org.OrgDomainPolicyChangedEventType, instance.InstanceDomainPolicyChangedEventType})
 	}
 	cols := []handler.Column{
-		handler.NewCol(OrgIAMPolicyChangeDateCol, policyEvent.CreationDate()),
-		handler.NewCol(OrgIAMPolicySequenceCol, policyEvent.Sequence()),
+		handler.NewCol(DomainPolicyChangeDateCol, policyEvent.CreationDate()),
+		handler.NewCol(DomainPolicySequenceCol, policyEvent.Sequence()),
 	}
 	if policyEvent.UserLoginMustBeDomain != nil {
-		cols = append(cols, handler.NewCol(OrgIAMPolicyUserLoginMustBeDomainCol, *policyEvent.UserLoginMustBeDomain))
+		cols = append(cols, handler.NewCol(DomainPolicyUserLoginMustBeDomainCol, *policyEvent.UserLoginMustBeDomain))
 	}
 	return crdb.NewUpdateStatement(
 		&policyEvent,
 		cols,
 		[]handler.Condition{
-			handler.NewCond(OrgIAMPolicyIDCol, policyEvent.Aggregate().ID),
+			handler.NewCond(DomainPolicyIDCol, policyEvent.Aggregate().ID),
 		}), nil
 }
 
-func (p *OrgIAMPolicyProjection) reduceRemoved(event eventstore.Event) (*handler.Statement, error) {
-	policyEvent, ok := event.(*org.OrgIAMPolicyRemovedEvent)
+func (p *DomainPolicyProjection) reduceRemoved(event eventstore.Event) (*handler.Statement, error) {
+	policyEvent, ok := event.(*org.OrgDomainPolicyRemovedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-JAENd", "reduce.wrong.event.type %s", org.OrgIAMPolicyRemovedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-JAENd", "reduce.wrong.event.type %s", org.OrgDomainPolicyRemovedEventType)
 	}
 	return crdb.NewDeleteStatement(
 		policyEvent,
 		[]handler.Condition{
-			handler.NewCond(OrgIAMPolicyIDCol, policyEvent.Aggregate().ID),
+			handler.NewCond(DomainPolicyIDCol, policyEvent.Aggregate().ID),
 		}), nil
 }

internal/query/projection/org_iam_policy_test.go

@@ -8,11 +8,11 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
-func TestOrgIAMPolicyProjection_reduces(t *testing.T) {
+func TestDomainPolicyProjection_reduces(t *testing.T) {
 	type args struct {
 		event func(t *testing.T) eventstore.Event
 	}
@@ -26,23 +26,23 @@ func TestOrgIAMPolicyProjection_reduces(t *testing.T) {
 			name: "org.reduceAdded",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(org.OrgIAMPolicyAddedEventType),
+					repository.EventType(org.OrgDomainPolicyAddedEventType),
 					org.AggregateType,
 					[]byte(`{
 						"userLoginMustBeDomain": true
 }`),
-				), org.OrgIAMPolicyAddedEventMapper),
+				), org.OrgDomainPolicyAddedEventMapper),
 			},
-			reduce: (&OrgIAMPolicyProjection{}).reduceAdded,
+			reduce: (&DomainPolicyProjection{}).reduceAdded,
 			want: wantReduce{
 				aggregateType:    eventstore.AggregateType("org"),
 				sequence:         15,
 				previousSequence: 10,
-				projection:       OrgIAMPolicyTable,
+				projection:       DomainPolicyTable,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "INSERT INTO projections.org_iam_policies (creation_date, change_date, sequence, id, state, user_login_must_be_domain, is_default, resource_owner, instance_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)",
+							expectedStmt: "INSERT INTO projections.domain_policies (creation_date, change_date, sequence, id, state, user_login_must_be_domain, is_default, resource_owner, instance_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)",
 							expectedArgs: []interface{}{
 								anyArg{},
 								anyArg{},
@@ -61,25 +61,25 @@ func TestOrgIAMPolicyProjection_reduces(t *testing.T) {
 		},
 		{
 			name:   "org.reduceChanged",
-			reduce: (&OrgIAMPolicyProjection{}).reduceChanged,
+			reduce: (&DomainPolicyProjection{}).reduceChanged,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(org.OrgIAMPolicyChangedEventType),
+					repository.EventType(org.OrgDomainPolicyChangedEventType),
 					org.AggregateType,
 					[]byte(`{
 						"userLoginMustBeDomain": true
 		}`),
-				), org.OrgIAMPolicyChangedEventMapper),
+				), org.OrgDomainPolicyChangedEventMapper),
 			},
 			want: wantReduce{
 				aggregateType:    eventstore.AggregateType("org"),
 				sequence:         15,
 				previousSequence: 10,
-				projection:       OrgIAMPolicyTable,
+				projection:       DomainPolicyTable,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "UPDATE projections.org_iam_policies SET (change_date, sequence, user_login_must_be_domain) = ($1, $2, $3) WHERE (id = $4)",
+							expectedStmt: "UPDATE projections.domain_policies SET (change_date, sequence, user_login_must_be_domain) = ($1, $2, $3) WHERE (id = $4)",
 							expectedArgs: []interface{}{
 								anyArg{},
 								uint64(15),
@@ -93,23 +93,23 @@ func TestOrgIAMPolicyProjection_reduces(t *testing.T) {
 		},
 		{
 			name:   "org.reduceRemoved",
-			reduce: (&OrgIAMPolicyProjection{}).reduceRemoved,
+			reduce: (&DomainPolicyProjection{}).reduceRemoved,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(org.OrgIAMPolicyRemovedEventType),
+					repository.EventType(org.OrgDomainPolicyRemovedEventType),
 					org.AggregateType,
 					nil,
-				), org.OrgIAMPolicyRemovedEventMapper),
+				), org.OrgDomainPolicyRemovedEventMapper),
 			},
 			want: wantReduce{
 				aggregateType:    eventstore.AggregateType("org"),
 				sequence:         15,
 				previousSequence: 10,
-				projection:       OrgIAMPolicyTable,
+				projection:       DomainPolicyTable,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "DELETE FROM projections.org_iam_policies WHERE (id = $1)",
+							expectedStmt: "DELETE FROM projections.domain_policies WHERE (id = $1)",
 							expectedArgs: []interface{}{
 								"agg-id",
 							},
@@ -119,26 +119,26 @@ func TestOrgIAMPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceAdded",
-			reduce: (&OrgIAMPolicyProjection{}).reduceAdded,
+			name:   "instance.reduceAdded",
+			reduce: (&DomainPolicyProjection{}).reduceAdded,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.OrgIAMPolicyAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.InstanceDomainPolicyAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"userLoginMustBeDomain": true
 					}`),
-				), iam.OrgIAMPolicyAddedEventMapper),
+				), instance.InstanceDomainPolicyAddedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
-				projection:       OrgIAMPolicyTable,
+				projection:       DomainPolicyTable,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "INSERT INTO projections.org_iam_policies (creation_date, change_date, sequence, id, state, user_login_must_be_domain, is_default, resource_owner, instance_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)",
+							expectedStmt: "INSERT INTO projections.domain_policies (creation_date, change_date, sequence, id, state, user_login_must_be_domain, is_default, resource_owner, instance_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)",
 							expectedArgs: []interface{}{
 								anyArg{},
 								anyArg{},
@@ -156,26 +156,26 @@ func TestOrgIAMPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceChanged",
-			reduce: (&OrgIAMPolicyProjection{}).reduceChanged,
+			name:   "instance.reduceChanged",
+			reduce: (&DomainPolicyProjection{}).reduceChanged,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.OrgIAMPolicyChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.InstanceDomainPolicyChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"userLoginMustBeDomain": true
 					}`),
-				), iam.OrgIAMPolicyChangedEventMapper),
+				), instance.InstanceDomainPolicyChangedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
-				projection:       OrgIAMPolicyTable,
+				projection:       DomainPolicyTable,
 				executer: &testExecuter{
 					executions: []execution{
 						{
-							expectedStmt: "UPDATE projections.org_iam_policies SET (change_date, sequence, user_login_must_be_domain) = ($1, $2, $3) WHERE (id = $4)",
+							expectedStmt: "UPDATE projections.domain_policies SET (change_date, sequence, user_login_must_be_domain) = ($1, $2, $3) WHERE (id = $4)",
 							expectedArgs: []interface{}{
 								anyArg{},
 								uint64(15),

internal/query/projection/password_age_policy.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/policy"
 )
@@ -76,14 +76,14 @@ func (p *PasswordAgeProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.PasswordAgePolicyAddedEventType,
+					Event:  instance.PasswordAgePolicyAddedEventType,
 					Reduce: p.reduceAdded,
 				},
 				{
-					Event:  iam.PasswordAgePolicyChangedEventType,
+					Event:  instance.PasswordAgePolicyChangedEventType,
 					Reduce: p.reduceChanged,
 				},
 			},
@@ -98,11 +98,11 @@ func (p *PasswordAgeProjection) reduceAdded(event eventstore.Event) (*handler.St
 	case *org.PasswordAgePolicyAddedEvent:
 		policyEvent = e.PasswordAgePolicyAddedEvent
 		isDefault = false
-	case *iam.PasswordAgePolicyAddedEvent:
+	case *instance.PasswordAgePolicyAddedEvent:
 		policyEvent = e.PasswordAgePolicyAddedEvent
 		isDefault = true
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-CJqF0", "reduce.wrong.event.type %v", []eventstore.EventType{org.PasswordAgePolicyAddedEventType, iam.PasswordAgePolicyAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-CJqF0", "reduce.wrong.event.type %v", []eventstore.EventType{org.PasswordAgePolicyAddedEventType, instance.PasswordAgePolicyAddedEventType})
 	}
 	return crdb.NewCreateStatement(
 		&policyEvent,
@@ -125,10 +125,10 @@ func (p *PasswordAgeProjection) reduceChanged(event eventstore.Event) (*handler.
 	switch e := event.(type) {
 	case *org.PasswordAgePolicyChangedEvent:
 		policyEvent = e.PasswordAgePolicyChangedEvent
-	case *iam.PasswordAgePolicyChangedEvent:
+	case *instance.PasswordAgePolicyChangedEvent:
 		policyEvent = e.PasswordAgePolicyChangedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-i7FZt", "reduce.wrong.event.type %v", []eventstore.EventType{org.PasswordAgePolicyChangedEventType, iam.PasswordAgePolicyChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-i7FZt", "reduce.wrong.event.type %v", []eventstore.EventType{org.PasswordAgePolicyChangedEventType, instance.PasswordAgePolicyChangedEventType})
 	}
 	cols := []handler.Column{
 		handler.NewCol(AgePolicyChangeDateCol, policyEvent.CreationDate()),

internal/query/projection/password_age_policy_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -123,20 +123,20 @@ func TestPasswordAgeProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceAdded",
+			name:   "instance.reduceAdded",
 			reduce: (&PasswordAgeProjection{}).reduceAdded,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.PasswordAgePolicyAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.PasswordAgePolicyAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"expireWarnDays": 10,
 						"maxAgeDays": 13
 					}`),
-				), iam.PasswordAgePolicyAddedEventMapper),
+				), instance.PasswordAgePolicyAddedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       PasswordAgeTable,
@@ -162,20 +162,20 @@ func TestPasswordAgeProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceChanged",
+			name:   "instance.reduceChanged",
 			reduce: (&PasswordAgeProjection{}).reduceChanged,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.PasswordAgePolicyChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.PasswordAgePolicyChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"expireWarnDays": 10,
 						"maxAgeDays": 13
 					}`),
-				), iam.PasswordAgePolicyChangedEventMapper),
+				), instance.PasswordAgePolicyChangedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       PasswordAgeTable,

internal/query/projection/password_complexity_policy.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/policy"
 )
@@ -82,14 +82,14 @@ func (p *PasswordComplexityProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.PasswordComplexityPolicyAddedEventType,
+					Event:  instance.PasswordComplexityPolicyAddedEventType,
 					Reduce: p.reduceAdded,
 				},
 				{
-					Event:  iam.PasswordComplexityPolicyChangedEventType,
+					Event:  instance.PasswordComplexityPolicyChangedEventType,
 					Reduce: p.reduceChanged,
 				},
 			},
@@ -104,11 +104,11 @@ func (p *PasswordComplexityProjection) reduceAdded(event eventstore.Event) (*han
 	case *org.PasswordComplexityPolicyAddedEvent:
 		policyEvent = e.PasswordComplexityPolicyAddedEvent
 		isDefault = false
-	case *iam.PasswordComplexityPolicyAddedEvent:
+	case *instance.PasswordComplexityPolicyAddedEvent:
 		policyEvent = e.PasswordComplexityPolicyAddedEvent
 		isDefault = true
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-KTHmJ", "reduce.wrong.event.type %v", []eventstore.EventType{org.PasswordComplexityPolicyAddedEventType, iam.PasswordComplexityPolicyAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-KTHmJ", "reduce.wrong.event.type %v", []eventstore.EventType{org.PasswordComplexityPolicyAddedEventType, instance.PasswordComplexityPolicyAddedEventType})
 	}
 	return crdb.NewCreateStatement(
 		&policyEvent,
@@ -134,10 +134,10 @@ func (p *PasswordComplexityProjection) reduceChanged(event eventstore.Event) (*h
 	switch e := event.(type) {
 	case *org.PasswordComplexityPolicyChangedEvent:
 		policyEvent = e.PasswordComplexityPolicyChangedEvent
-	case *iam.PasswordComplexityPolicyChangedEvent:
+	case *instance.PasswordComplexityPolicyChangedEvent:
 		policyEvent = e.PasswordComplexityPolicyChangedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-cf3Xb", "reduce.wrong.event.type %v", []eventstore.EventType{org.PasswordComplexityPolicyChangedEventType, iam.PasswordComplexityPolicyChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-cf3Xb", "reduce.wrong.event.type %v", []eventstore.EventType{org.PasswordComplexityPolicyChangedEventType, instance.PasswordComplexityPolicyChangedEventType})
 	}
 	cols := []handler.Column{
 		handler.NewCol(ComplexityPolicyChangeDateCol, policyEvent.CreationDate()),

internal/query/projection/password_complexity_policy_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -135,12 +135,12 @@ func TestPasswordComplexityProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceAdded",
+			name:   "instance.reduceAdded",
 			reduce: (&PasswordComplexityProjection{}).reduceAdded,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.PasswordComplexityPolicyAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.PasswordComplexityPolicyAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 			"minLength": 10,
 			"hasLowercase": true,
@@ -148,10 +148,10 @@ func TestPasswordComplexityProjection_reduces(t *testing.T) {
 			"HasNumber": true,
 			"HasSymbol": true
 					}`),
-				), iam.PasswordComplexityPolicyAddedEventMapper),
+				), instance.PasswordComplexityPolicyAddedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       PasswordComplexityTable,
@@ -180,12 +180,12 @@ func TestPasswordComplexityProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceChanged",
+			name:   "instance.reduceChanged",
 			reduce: (&PasswordComplexityProjection{}).reduceChanged,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.PasswordComplexityPolicyChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.PasswordComplexityPolicyChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 			"minLength": 10,
 			"hasLowercase": true,
@@ -193,10 +193,10 @@ func TestPasswordComplexityProjection_reduces(t *testing.T) {
 			"HasNumber": true,
 			"HasSymbol": true
 					}`),
-				), iam.PasswordComplexityPolicyChangedEventMapper),
+				), instance.PasswordComplexityPolicyChangedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       PasswordComplexityTable,

internal/query/projection/privacy_policy.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 	"github.com/caos/zitadel/internal/repository/policy"
 )
@@ -78,14 +78,14 @@ func (p *PrivacyPolicyProjection) reducers() []handler.AggregateReducer {
 			},
 		},
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.PrivacyPolicyAddedEventType,
+					Event:  instance.PrivacyPolicyAddedEventType,
 					Reduce: p.reduceAdded,
 				},
 				{
-					Event:  iam.PrivacyPolicyChangedEventType,
+					Event:  instance.PrivacyPolicyChangedEventType,
 					Reduce: p.reduceChanged,
 				},
 			},
@@ -100,11 +100,11 @@ func (p *PrivacyPolicyProjection) reduceAdded(event eventstore.Event) (*handler.
 	case *org.PrivacyPolicyAddedEvent:
 		policyEvent = e.PrivacyPolicyAddedEvent
 		isDefault = false
-	case *iam.PrivacyPolicyAddedEvent:
+	case *instance.PrivacyPolicyAddedEvent:
 		policyEvent = e.PrivacyPolicyAddedEvent
 		isDefault = true
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-kRNh8", "reduce.wrong.event.type %v", []eventstore.EventType{org.PrivacyPolicyAddedEventType, iam.PrivacyPolicyAddedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-kRNh8", "reduce.wrong.event.type %v", []eventstore.EventType{org.PrivacyPolicyAddedEventType, instance.PrivacyPolicyAddedEventType})
 	}
 	return crdb.NewCreateStatement(
 		&policyEvent,
@@ -128,10 +128,10 @@ func (p *PrivacyPolicyProjection) reduceChanged(event eventstore.Event) (*handle
 	switch e := event.(type) {
 	case *org.PrivacyPolicyChangedEvent:
 		policyEvent = e.PrivacyPolicyChangedEvent
-	case *iam.PrivacyPolicyChangedEvent:
+	case *instance.PrivacyPolicyChangedEvent:
 		policyEvent = e.PrivacyPolicyChangedEvent
 	default:
-		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-91weZ", "reduce.wrong.event.type %v", []eventstore.EventType{org.PrivacyPolicyChangedEventType, iam.PrivacyPolicyChangedEventType})
+		return nil, errors.ThrowInvalidArgumentf(nil, "PROJE-91weZ", "reduce.wrong.event.type %v", []eventstore.EventType{org.PrivacyPolicyChangedEventType, instance.PrivacyPolicyChangedEventType})
 	}
 	cols := []handler.Column{
 		handler.NewCol(PrivacyPolicyChangeDateCol, policyEvent.CreationDate()),

internal/query/projection/privacy_policy_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/org"
 )
 
@@ -127,21 +127,21 @@ func TestPrivacyPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceAdded",
+			name:   "instance.reduceAdded",
 			reduce: (&PrivacyPolicyProjection{}).reduceAdded,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.PrivacyPolicyAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.PrivacyPolicyAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"tosLink": "http://tos.link",
 						"privacyLink": "http://privacy.link",
 						"helpLink": "http://help.link"
 					}`),
-				), iam.PrivacyPolicyAddedEventMapper),
+				), instance.PrivacyPolicyAddedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       PrivacyPolicyTable,
@@ -168,21 +168,21 @@ func TestPrivacyPolicyProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name:   "iam.reduceChanged",
+			name:   "instance.reduceChanged",
 			reduce: (&PrivacyPolicyProjection{}).reduceChanged,
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.PrivacyPolicyChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.PrivacyPolicyChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"tosLink": "http://tos.link",
 						"privacyLink": "http://privacy.link",
 						"helpLink": "http://help.link"
 					}`),
-				), iam.PrivacyPolicyChangedEventMapper),
+				), instance.PrivacyPolicyChangedEventMapper),
 			},
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       PrivacyPolicyTable,

internal/query/projection/projection.go

@@ -44,7 +44,7 @@ func Start(ctx context.Context, sqlClient *sql.DB, es *eventstore.Eventstore, co
 	NewPasswordAgeProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["password_age_policy"]))
 	NewLockoutPolicyProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["lockout_policy"]))
 	NewPrivacyPolicyProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["privacy_policy"]))
-	NewOrgIAMPolicyProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["org_iam_policy"]))
+	NewDomainPolicyProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["org_iam_policy"]))
 	NewLabelPolicyProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["label_policy"]))
 	NewProjectGrantProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["project_grants"]))
 	NewProjectRoleProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["project_roles"]))
@@ -61,7 +61,7 @@ func Start(ctx context.Context, sqlClient *sql.DB, es *eventstore.Eventstore, co
 	NewUserProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["users"]))
 	NewLoginNameProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["login_names"]))
 	NewOrgMemberProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["org_members"]))
-	NewIAMMemberProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["iam_members"]))
+	NewInstanceMemberProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["iam_members"]))
 	NewProjectMemberProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["project_members"]))
 	NewProjectGrantMemberProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["project_grant_members"]))
 	NewAuthNKeyProjection(ctx, applyCustomConfig(projectionConfig, config.Customizations["authn_keys"]))

internal/query/projection/secret_generator.go

@@ -7,7 +7,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/project"
 )
 
@@ -66,15 +66,15 @@ func (p *SecretGeneratorProjection) reducers() []handler.AggregateReducer {
 			Aggregate: project.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.SecretGeneratorAddedEventType,
+					Event:  instance.SecretGeneratorAddedEventType,
 					Reduce: p.reduceSecretGeneratorAdded,
 				},
 				{
-					Event:  iam.SecretGeneratorChangedEventType,
+					Event:  instance.SecretGeneratorChangedEventType,
 					Reduce: p.reduceSecretGeneratorChanged,
 				},
 				{
-					Event:  iam.SecretGeneratorRemovedEventType,
+					Event:  instance.SecretGeneratorRemovedEventType,
 					Reduce: p.reduceSecretGeneratorRemoved,
 				},
 			},
@@ -83,9 +83,9 @@ func (p *SecretGeneratorProjection) reducers() []handler.AggregateReducer {
 }
 
 func (p *SecretGeneratorProjection) reduceSecretGeneratorAdded(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.SecretGeneratorAddedEvent)
+	e, ok := event.(*instance.SecretGeneratorAddedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-sk99F", "reduce.wrong.event.type %s", iam.SecretGeneratorAddedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-sk99F", "reduce.wrong.event.type %s", instance.SecretGeneratorAddedEventType)
 	}
 	return crdb.NewCreateStatement(
 		e,
@@ -108,9 +108,9 @@ func (p *SecretGeneratorProjection) reduceSecretGeneratorAdded(event eventstore.
 }
 
 func (p *SecretGeneratorProjection) reduceSecretGeneratorChanged(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.SecretGeneratorChangedEvent)
+	e, ok := event.(*instance.SecretGeneratorChangedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-s00Fs", "reduce.wrong.event.type %s", iam.SecretGeneratorChangedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-s00Fs", "reduce.wrong.event.type %s", instance.SecretGeneratorChangedEventType)
 	}
 
 	columns := make([]handler.Column, 0, 7)
@@ -145,9 +145,9 @@ func (p *SecretGeneratorProjection) reduceSecretGeneratorChanged(event eventstor
 }
 
 func (p *SecretGeneratorProjection) reduceSecretGeneratorRemoved(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.SecretGeneratorRemovedEvent)
+	e, ok := event.(*instance.SecretGeneratorRemovedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-fmiIf", "reduce.wrong.event.type %s", iam.SecretGeneratorRemovedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-fmiIf", "reduce.wrong.event.type %s", instance.SecretGeneratorRemovedEventType)
 	}
 	return crdb.NewDeleteStatement(
 		e,

internal/query/projection/secret_generator_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 )
 
 func TestSecretGeneratorProjection_reduces(t *testing.T) {
@@ -26,15 +26,15 @@ func TestSecretGeneratorProjection_reduces(t *testing.T) {
 			name: "reduceSecretGeneratorRemoved",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SecretGeneratorRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SecretGeneratorRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{"generatorType": 1}`),
-				), iam.SecretGeneratorRemovedEventMapper),
+				), instance.SecretGeneratorRemovedEventMapper),
 			},
 			reduce: (&SecretGeneratorProjection{}).reduceSecretGeneratorRemoved,
 			want: wantReduce{
 				projection:       SecretGeneratorProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{
@@ -54,15 +54,15 @@ func TestSecretGeneratorProjection_reduces(t *testing.T) {
 			name: "reduceSecretGeneratorChanged",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SecretGeneratorChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SecretGeneratorChangedEventType),
+					instance.AggregateType,
 					[]byte(`{"generatorType": 1, "length": 4, "expiry": 10000000, "includeLowerLetters": true, "includeUpperLetters": true, "includeDigits": true, "includeSymbols": true}`),
-				), iam.SecretGeneratorChangedEventMapper),
+				), instance.SecretGeneratorChangedEventMapper),
 			},
 			reduce: (&SecretGeneratorProjection{}).reduceSecretGeneratorChanged,
 			want: wantReduce{
 				projection:       SecretGeneratorProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{
@@ -90,15 +90,15 @@ func TestSecretGeneratorProjection_reduces(t *testing.T) {
 			name: "reduceSecretGeneratorAdded",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SecretGeneratorAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SecretGeneratorAddedEventType),
+					instance.AggregateType,
 					[]byte(`{"generatorType": 1, "length": 4, "expiry": 10000000, "includeLowerLetters": true, "includeUpperLetters": true, "includeDigits": true, "includeSymbols": true}`),
-				), iam.SecretGeneratorAddedEventMapper),
+				), instance.SecretGeneratorAddedEventMapper),
 			},
 			reduce: (&SecretGeneratorProjection{}).reduceSecretGeneratorAdded,
 			want: wantReduce{
 				projection:       SecretGeneratorProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{

internal/query/projection/sms.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 )
 
 const (
@@ -69,26 +69,26 @@ func NewSMSConfigProjection(ctx context.Context, config crdb.StatementHandlerCon
 func (p *SMSConfigProjection) reducers() []handler.AggregateReducer {
 	return []handler.AggregateReducer{
 		{
-			Aggregate: iam.AggregateType,
+			Aggregate: instance.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.SMSConfigTwilioAddedEventType,
+					Event:  instance.SMSConfigTwilioAddedEventType,
 					Reduce: p.reduceSMSConfigTwilioAdded,
 				},
 				{
-					Event:  iam.SMSConfigTwilioChangedEventType,
+					Event:  instance.SMSConfigTwilioChangedEventType,
 					Reduce: p.reduceSMSConfigTwilioChanged,
 				},
 				{
-					Event:  iam.SMSConfigActivatedEventType,
+					Event:  instance.SMSConfigActivatedEventType,
 					Reduce: p.reduceSMSConfigActivated,
 				},
 				{
-					Event:  iam.SMSConfigDeactivatedEventType,
+					Event:  instance.SMSConfigDeactivatedEventType,
 					Reduce: p.reduceSMSConfigDeactivated,
 				},
 				{
-					Event:  iam.SMSConfigRemovedEventType,
+					Event:  instance.SMSConfigRemovedEventType,
 					Reduce: p.reduceSMSConfigRemoved,
 				},
 			},
@@ -97,9 +97,9 @@ func (p *SMSConfigProjection) reducers() []handler.AggregateReducer {
 }
 
 func (p *SMSConfigProjection) reduceSMSConfigTwilioAdded(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.SMSConfigTwilioAddedEvent)
+	e, ok := event.(*instance.SMSConfigTwilioAddedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-s8efs", "reduce.wrong.event.type %s", iam.SMSConfigTwilioAddedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-s8efs", "reduce.wrong.event.type %s", instance.SMSConfigTwilioAddedEventType)
 	}
 
 	return crdb.NewMultiStatement(
@@ -129,9 +129,9 @@ func (p *SMSConfigProjection) reduceSMSConfigTwilioAdded(event eventstore.Event)
 }
 
 func (p *SMSConfigProjection) reduceSMSConfigTwilioChanged(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.SMSConfigTwilioChangedEvent)
+	e, ok := event.(*instance.SMSConfigTwilioChangedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-fi99F", "reduce.wrong.event.type %s", iam.SMSConfigTwilioChangedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-fi99F", "reduce.wrong.event.type %s", instance.SMSConfigTwilioChangedEventType)
 	}
 	columns := make([]handler.Column, 0)
 	if e.SID != nil {
@@ -163,9 +163,9 @@ func (p *SMSConfigProjection) reduceSMSConfigTwilioChanged(event eventstore.Even
 }
 
 func (p *SMSConfigProjection) reduceSMSConfigActivated(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.SMSConfigActivatedEvent)
+	e, ok := event.(*instance.SMSConfigActivatedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-fj9Ef", "reduce.wrong.event.type %s", iam.SMSConfigActivatedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-fj9Ef", "reduce.wrong.event.type %s", instance.SMSConfigActivatedEventType)
 	}
 	return crdb.NewUpdateStatement(
 		e,
@@ -181,9 +181,9 @@ func (p *SMSConfigProjection) reduceSMSConfigActivated(event eventstore.Event) (
 }
 
 func (p *SMSConfigProjection) reduceSMSConfigDeactivated(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.SMSConfigDeactivatedEvent)
+	e, ok := event.(*instance.SMSConfigDeactivatedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-dj9Js", "reduce.wrong.event.type %s", iam.SMSConfigDeactivatedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-dj9Js", "reduce.wrong.event.type %s", instance.SMSConfigDeactivatedEventType)
 	}
 	return crdb.NewUpdateStatement(
 		e,
@@ -199,9 +199,9 @@ func (p *SMSConfigProjection) reduceSMSConfigDeactivated(event eventstore.Event)
 }
 
 func (p *SMSConfigProjection) reduceSMSConfigRemoved(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.SMSConfigRemovedEvent)
+	e, ok := event.(*instance.SMSConfigRemovedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-s9JJf", "reduce.wrong.event.type %s", iam.SMSConfigRemovedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-s9JJf", "reduce.wrong.event.type %s", instance.SMSConfigRemovedEventType)
 	}
 	return crdb.NewDeleteStatement(
 		e,

internal/query/projection/sms_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 )
 
 var (
@@ -28,11 +28,11 @@ func TestSMSProjection_reduces(t *testing.T) {
 		want   wantReduce
 	}{
 		{
-			name: "iam.reduceSMSTwilioAdded",
+			name: "instance.reduceSMSTwilioAdded",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SMSConfigTwilioAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SMSConfigTwilioAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"id": "id",
 						"sid": "sid",
@@ -43,11 +43,11 @@ func TestSMSProjection_reduces(t *testing.T) {
 						},
 						"senderNumber": "sender-number"
 					}`),
-				), iam.SMSConfigTwilioAddedEventMapper),
+				), instance.SMSConfigTwilioAddedEventMapper),
 			},
 			reduce: (&SMSConfigProjection{}).reduceSMSConfigTwilioAdded,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       SMSConfigProjectionTable,
@@ -80,21 +80,21 @@ func TestSMSProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceSMSConfigTwilioChanged",
+			name: "instance.reduceSMSConfigTwilioChanged",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SMSConfigTwilioChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SMSConfigTwilioChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"id": "id",
 						"sid": "sid",
 						"senderNumber": "sender-number"
 					}`),
-				), iam.SMSConfigTwilioChangedEventMapper),
+				), instance.SMSConfigTwilioChangedEventMapper),
 			},
 			reduce: (&SMSConfigProjection{}).reduceSMSConfigTwilioChanged,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       SMSConfigProjectionTable,
@@ -121,19 +121,19 @@ func TestSMSProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceSMSConfigActivated",
+			name: "instance.reduceSMSConfigActivated",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SMSConfigActivatedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SMSConfigActivatedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"id": "id"
 					}`),
-				), iam.SMSConfigActivatedEventMapper),
+				), instance.SMSConfigActivatedEventMapper),
 			},
 			reduce: (&SMSConfigProjection{}).reduceSMSConfigActivated,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       SMSConfigProjectionTable,
@@ -153,19 +153,19 @@ func TestSMSProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceSMSConfigDeactivated",
+			name: "instance.reduceSMSConfigDeactivated",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SMSConfigDeactivatedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SMSConfigDeactivatedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"id": "id"
 					}`),
-				), iam.SMSConfigDeactivatedEventMapper),
+				), instance.SMSConfigDeactivatedEventMapper),
 			},
 			reduce: (&SMSConfigProjection{}).reduceSMSConfigDeactivated,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       SMSConfigProjectionTable,
@@ -185,19 +185,19 @@ func TestSMSProjection_reduces(t *testing.T) {
 			},
 		},
 		{
-			name: "iam.reduceSMSConfigRemoved",
+			name: "instance.reduceSMSConfigRemoved",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SMSConfigRemovedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SMSConfigRemovedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"id": "id"
 					}`),
-				), iam.SMSConfigRemovedEventMapper),
+				), instance.SMSConfigRemovedEventMapper),
 			},
 			reduce: (&SMSConfigProjection{}).reduceSMSConfigRemoved,
 			want: wantReduce{
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				projection:       SMSConfigProjectionTable,

internal/query/projection/smtp.go

@@ -7,7 +7,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/handler/crdb"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 	"github.com/caos/zitadel/internal/repository/project"
 )
 
@@ -64,15 +64,15 @@ func (p *SMTPConfigProjection) reducers() []handler.AggregateReducer {
 			Aggregate: project.AggregateType,
 			EventRedusers: []handler.EventReducer{
 				{
-					Event:  iam.SMTPConfigAddedEventType,
+					Event:  instance.SMTPConfigAddedEventType,
 					Reduce: p.reduceSMTPConfigAdded,
 				},
 				{
-					Event:  iam.SMTPConfigChangedEventType,
+					Event:  instance.SMTPConfigChangedEventType,
 					Reduce: p.reduceSMTPConfigChanged,
 				},
 				{
-					Event:  iam.SMTPConfigPasswordChangedEventType,
+					Event:  instance.SMTPConfigPasswordChangedEventType,
 					Reduce: p.reduceSMTPConfigPasswordChanged,
 				},
 			},
@@ -81,9 +81,9 @@ func (p *SMTPConfigProjection) reducers() []handler.AggregateReducer {
 }
 
 func (p *SMTPConfigProjection) reduceSMTPConfigAdded(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.SMTPConfigAddedEvent)
+	e, ok := event.(*instance.SMTPConfigAddedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-sk99F", "reduce.wrong.event.type %s", iam.SMTPConfigAddedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-sk99F", "reduce.wrong.event.type %s", instance.SMTPConfigAddedEventType)
 	}
 	return crdb.NewCreateStatement(
 		e,
@@ -105,9 +105,9 @@ func (p *SMTPConfigProjection) reduceSMTPConfigAdded(event eventstore.Event) (*h
 }
 
 func (p *SMTPConfigProjection) reduceSMTPConfigChanged(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.SMTPConfigChangedEvent)
+	e, ok := event.(*instance.SMTPConfigChangedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-wl0wd", "reduce.wrong.event.type %s", iam.SMTPConfigChangedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-wl0wd", "reduce.wrong.event.type %s", instance.SMTPConfigChangedEventType)
 	}
 
 	columns := make([]handler.Column, 0, 7)
@@ -138,9 +138,9 @@ func (p *SMTPConfigProjection) reduceSMTPConfigChanged(event eventstore.Event) (
 }
 
 func (p *SMTPConfigProjection) reduceSMTPConfigPasswordChanged(event eventstore.Event) (*handler.Statement, error) {
-	e, ok := event.(*iam.SMTPConfigPasswordChangedEvent)
+	e, ok := event.(*instance.SMTPConfigPasswordChangedEvent)
 	if !ok {
-		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-fk02f", "reduce.wrong.event.type %s", iam.SMTPConfigChangedEventType)
+		return nil, errors.ThrowInvalidArgumentf(nil, "HANDL-fk02f", "reduce.wrong.event.type %s", instance.SMTPConfigChangedEventType)
 	}
 
 	return crdb.NewUpdateStatement(

internal/query/projection/smtp_test.go

@@ -7,7 +7,7 @@ import (
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/handler"
 	"github.com/caos/zitadel/internal/eventstore/repository"
-	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/caos/zitadel/internal/repository/instance"
 )
 
 func TestSMTPConfigProjection_reduces(t *testing.T) {
@@ -24,8 +24,8 @@ func TestSMTPConfigProjection_reduces(t *testing.T) {
 			name: "reduceSMTPConfigChanged",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SMTPConfigChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SMTPConfigChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"tls": true,
 						"senderAddress": "sender",
@@ -34,12 +34,12 @@ func TestSMTPConfigProjection_reduces(t *testing.T) {
 						"user": "user"
 					}`,
 					),
-				), iam.SMTPConfigChangedEventMapper),
+				), instance.SMTPConfigChangedEventMapper),
 			},
 			reduce: (&SMTPConfigProjection{}).reduceSMTPConfigChanged,
 			want: wantReduce{
 				projection:       SMTPConfigProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{
@@ -65,8 +65,8 @@ func TestSMTPConfigProjection_reduces(t *testing.T) {
 			name: "reduceSMTPConfigAdded",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SMTPConfigAddedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SMTPConfigAddedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"tls": true,
 						"senderAddress": "sender",
@@ -79,12 +79,12 @@ func TestSMTPConfigProjection_reduces(t *testing.T) {
 							"keyId": "key-id"
 						}
 					}`),
-				), iam.SMTPConfigAddedEventMapper),
+				), instance.SMTPConfigAddedEventMapper),
 			},
 			reduce: (&SMTPConfigProjection{}).reduceSMTPConfigAdded,
 			want: wantReduce{
 				projection:       SMTPConfigProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{
@@ -114,8 +114,8 @@ func TestSMTPConfigProjection_reduces(t *testing.T) {
 			name: "reduceSMTPConfigPasswordChanged",
 			args: args{
 				event: getEvent(testEvent(
-					repository.EventType(iam.SMTPConfigPasswordChangedEventType),
-					iam.AggregateType,
+					repository.EventType(instance.SMTPConfigPasswordChangedEventType),
+					instance.AggregateType,
 					[]byte(`{
 						"password": {
 							"cryptoType": 0,
@@ -123,12 +123,12 @@ func TestSMTPConfigProjection_reduces(t *testing.T) {
 							"keyId": "key-id"
 						}
 					}`),
-				), iam.SMTPConfigPasswordChangedEventMapper),
+				), instance.SMTPConfigPasswordChangedEventMapper),
 			},
 			reduce: (&SMTPConfigProjection{}).reduceSMTPConfigPasswordChanged,
 			want: wantReduce{
 				projection:       SMTPConfigProjectionTable,
-				aggregateType:    eventstore.AggregateType("iam"),
+				aggregateType:    eventstore.AggregateType("instance"),
 				sequence:         15,
 				previousSequence: 10,
 				executer: &testExecuter{