instance custom domain event tests done

backend/v3/storage/database/repository/instance.go

@@ -30,7 +30,7 @@ func InstanceRepository(client database.QueryExecutor) domain.InstanceRepository
 
 const (
 	queryInstanceStmt = `SELECT instances.id, instances.name, instances.default_org_id, instances.iam_project_id, instances.console_client_id, instances.console_app_id, instances.default_language, instances.created_at, instances.updated_at` +
-		` , CASE WHEN count(instance_domains.domain) > 0 THEN jsonb_agg(json_build_object('domain', instance_domains.domain, 'isVerified', instance_domains.is_verified, 'isPrimary', instance_domains.is_primary, 'isGenerated', instance_domains.is_generated, 'validationType', instance_domains.validation_type, 'createdAt', instance_domains.created_at, 'updatedAt', instance_domains.updated_at)) ELSE NULL::JSONB END domains` +
+		` , CASE WHEN count(instance_domains.domain) > 0 THEN jsonb_agg(json_build_object('domain', instance_domains.domain, 'isPrimary', instance_domains.is_primary, 'isGenerated', instance_domains.is_generated, 'createdAt', instance_domains.created_at, 'updatedAt', instance_domains.updated_at)) ELSE NULL::JSONB END domains` +
 		` FROM zitadel.instances`
 )
 

backend/v3/storage/database/repository/instance_domain.go

@@ -19,7 +19,7 @@ type instanceDomain struct {
 // repository
 // -------------------------------------------------------------
 
-const queryInstanceDomainStmt = `SELECT instance_domains.instance_id, instance_domains.domain, instance_domains.is_verified, instance_domains.is_primary, instance_domains.validation_type, instance_domains.created_at, instance_domains.updated_at ` +
+const queryInstanceDomainStmt = `SELECT instance_domains.instance_id, instance_domains.domain, instance_domains.is_primary, instance_domains.created_at, instance_domains.updated_at ` +
 	`FROM zitadel.instance_domains`
 
 // Get implements [domain.InstanceDomainRepository].
@@ -56,11 +56,11 @@ func (i *instanceDomain) List(ctx context.Context, opts ...database.QueryOption)
 func (i *instanceDomain) Add(ctx context.Context, domain *domain.AddInstanceDomain) error {
 	var builder database.StatementBuilder
 
-	builder.WriteString(`INSERT INTO zitadel.instance_domains (instance_id, domain, is_verified, is_primary, validation_type) VALUES (`)
-	builder.WriteArgs(domain.InstanceID, domain.Domain, domain.IsVerified, domain.IsPrimary, domain.ValidationType)
+	builder.WriteString(`INSERT INTO zitadel.instance_domains (instance_id, domain, is_primary, is_generated, type, created_at, updated_at) VALUES (`)
+	builder.WriteArgs(domain.InstanceID, domain.Domain, domain.IsPrimary, domain.IsGenerated, domain.Type, domain.CreatedAt, domain.UpdatedAt)
 	builder.WriteString(`) RETURNING created_at, updated_at`)
 
-	return i.client.QueryRow(ctx, builder.String(), builder.Args()...).Scan(&domain.CreatedAt, &domain.UpdatedAt)
+	return i.client.QueryRow(ctx, builder.String(), builder.Args()...).Scan(domain.CreatedAt, domain.UpdatedAt)
 }
 
 // Remove implements [domain.InstanceDomainRepository].
@@ -93,26 +93,21 @@ func (i *instanceDomain) Update(ctx context.Context, condition database.Conditio
 // changes
 // -------------------------------------------------------------
 
-// SetValidationType implements [domain.InstanceDomainRepository].
-func (i instanceDomain) SetValidationType(verificationType domain.DomainValidationType) database.Change {
-	return database.NewChange(i.ValidationTypeColumn(false), verificationType)
-}
-
 // SetPrimary implements [domain.InstanceDomainRepository].
 func (i instanceDomain) SetPrimary() database.Change {
 	return database.NewChange(i.IsPrimaryColumn(false), true)
 }
 
-// SetVerified implements [domain.InstanceDomainRepository].
-func (i instanceDomain) SetVerified() database.Change {
-	return database.NewChange(i.IsVerifiedColumn(false), true)
-}
-
 // SetUpdatedAt implements [domain.OrganizationDomainRepository].
 func (i instanceDomain) SetUpdatedAt(updatedAt time.Time) database.Change {
 	return database.NewChange(i.UpdatedAtColumn(false), updatedAt)
 }
 
+// SetType implements [domain.InstanceDomainRepository].
+func (i instanceDomain) SetType(typ domain.DomainType) database.Change {
+	return database.NewChange(i.TypeColumn(false), typ)
+}
+
 // -------------------------------------------------------------
 // conditions
 // -------------------------------------------------------------
@@ -132,9 +127,9 @@ func (i instanceDomain) IsPrimaryCondition(isPrimary bool) database.Condition {
 	return database.NewBooleanCondition(i.IsPrimaryColumn(true), isPrimary)
 }
 
-// IsVerifiedCondition implements [domain.InstanceDomainRepository].
-func (i instanceDomain) IsVerifiedCondition(isVerified bool) database.Condition {
-	return database.NewBooleanCondition(i.IsVerifiedColumn(true), isVerified)
+// TypeCondition implements [domain.InstanceDomainRepository].
+func (i instanceDomain) TypeCondition(typ domain.DomainType) database.Condition {
+	return database.NewTextCondition(i.TypeColumn(true), database.TextOperationEqual, typ)
 }
 
 // -------------------------------------------------------------
@@ -174,14 +169,6 @@ func (instanceDomain) IsPrimaryColumn(qualified bool) database.Column {
 	return database.NewColumn("is_primary")
 }
 
-// IsVerifiedColumn implements [domain.InstanceDomainRepository].
-func (instanceDomain) IsVerifiedColumn(qualified bool) database.Column {
-	if qualified {
-		return database.NewColumn("instance_domains.is_verified")
-	}
-	return database.NewColumn("is_verified")
-}
-
 // UpdatedAtColumn implements [domain.InstanceDomainRepository].
 // Subtle: this method shadows the method ([domain.InstanceRepository]).UpdatedAtColumn of instanceDomain.instance.
 func (instanceDomain) UpdatedAtColumn(qualified bool) database.Column {
@@ -191,14 +178,6 @@ func (instanceDomain) UpdatedAtColumn(qualified bool) database.Column {
 	return database.NewColumn("updated_at")
 }
 
-// ValidationTypeColumn implements [domain.InstanceDomainRepository].
-func (instanceDomain) ValidationTypeColumn(qualified bool) database.Column {
-	if qualified {
-		return database.NewColumn("instance_domains.validation_type")
-	}
-	return database.NewColumn("validation_type")
-}
-
 // IsGeneratedColumn implements [domain.InstanceDomainRepository].
 func (instanceDomain) IsGeneratedColumn(qualified bool) database.Column {
 	if qualified {
@@ -207,6 +186,14 @@ func (instanceDomain) IsGeneratedColumn(qualified bool) database.Column {
 	return database.NewColumn("is_generated")
 }
 
+// TypeColumn implements [domain.InstanceDomainRepository].
+func (instanceDomain) TypeColumn(qualified bool) database.Column {
+	if qualified {
+		return database.NewColumn("instance_domains.type")
+	}
+	return database.NewColumn("type")
+}
+
 // -------------------------------------------------------------
 // scanners
 // -------------------------------------------------------------

backend/v3/storage/database/repository/instance_domain_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	"github.com/brianvoe/gofakeit/v6"
-	"github.com/muhlemmer/gu"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -39,41 +38,25 @@ func TestAddInstanceDomain(t *testing.T) {
 		{
 			name: "happy path",
 			instanceDomain: domain.AddInstanceDomain{
-				InstanceID:     instanceID,
-				Domain:         gofakeit.DomainName(),
-				IsVerified:     false,
-				IsPrimary:      false,
-				ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
-			},
-		},
-		{
-			name: "add verified domain",
-			instanceDomain: domain.AddInstanceDomain{
-				InstanceID:     instanceID,
-				Domain:         gofakeit.DomainName(),
-				IsVerified:     true,
-				IsPrimary:      false,
-				ValidationType: gu.Ptr(domain.DomainValidationTypeHTTP),
+				InstanceID: instanceID,
+				Domain:     gofakeit.DomainName(),
+				IsPrimary:  false,
 			},
 		},
 		{
 			name: "add primary domain",
 			instanceDomain: domain.AddInstanceDomain{
-				InstanceID:     instanceID,
-				Domain:         gofakeit.DomainName(),
-				IsVerified:     true,
-				IsPrimary:      true,
-				ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
+				InstanceID: instanceID,
+				Domain:     gofakeit.DomainName(),
+				IsPrimary:  true,
 			},
 		},
 		{
 			name: "add domain without domain name",
 			instanceDomain: domain.AddInstanceDomain{
-				InstanceID:     instanceID,
-				Domain:         "",
-				IsVerified:     false,
-				IsPrimary:      false,
-				ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
+				InstanceID: instanceID,
+				Domain:     "",
+				IsPrimary:  false,
 			},
 			err: new(database.CheckError),
 		},
@@ -83,11 +66,9 @@ func TestAddInstanceDomain(t *testing.T) {
 				domainName := gofakeit.DomainName()
 
 				instanceDomain := &domain.AddInstanceDomain{
-					InstanceID:     instanceID,
-					Domain:         domainName,
-					IsVerified:     false,
-					IsPrimary:      false,
-					ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
+					InstanceID: instanceID,
+					Domain:     domainName,
+					IsPrimary:  false,
 				}
 
 				err := domainRepo.Add(ctx, instanceDomain)
@@ -95,11 +76,9 @@ func TestAddInstanceDomain(t *testing.T) {
 
 				// return same domain again
 				return &domain.AddInstanceDomain{
-					InstanceID:     instanceID,
-					Domain:         domainName,
-					IsVerified:     true,
-					IsPrimary:      true,
-					ValidationType: gu.Ptr(domain.DomainValidationTypeHTTP),
+					InstanceID: instanceID,
+					Domain:     domainName,
+					IsPrimary:  true,
 				}
 			},
 			err: new(database.UniqueError),
@@ -107,21 +86,17 @@ func TestAddInstanceDomain(t *testing.T) {
 		{
 			name: "add domain with non-existent instance",
 			instanceDomain: domain.AddInstanceDomain{
-				InstanceID:     "non-existent-instance",
-				Domain:         gofakeit.DomainName(),
-				IsVerified:     false,
-				IsPrimary:      false,
-				ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
+				InstanceID: "non-existent-instance",
+				Domain:     gofakeit.DomainName(),
+				IsPrimary:  false,
 			},
 			err: new(database.ForeignKeyError),
 		},
 		{
 			name: "add domain without instance id",
 			instanceDomain: domain.AddInstanceDomain{
-				Domain:         gofakeit.DomainName(),
-				IsVerified:     false,
-				IsPrimary:      false,
-				ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
+				Domain:    gofakeit.DomainName(),
+				IsPrimary: false,
 			},
 			err: new(database.ForeignKeyError),
 		},
@@ -186,18 +161,14 @@ func TestGetInstanceDomain(t *testing.T) {
 	domainName2 := gofakeit.DomainName()
 
 	domain1 := &domain.AddInstanceDomain{
-		InstanceID:     instanceID,
-		Domain:         domainName1,
-		IsVerified:     true,
-		IsPrimary:      true,
-		ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
+		InstanceID: instanceID,
+		Domain:     domainName1,
+		IsPrimary:  true,
 	}
 	domain2 := &domain.AddInstanceDomain{
-		InstanceID:     instanceID,
-		Domain:         domainName2,
-		IsVerified:     false,
-		IsPrimary:      false,
-		ValidationType: gu.Ptr(domain.DomainValidationTypeHTTP),
+		InstanceID: instanceID,
+		Domain:     domainName2,
+		IsPrimary:  false,
 	}
 
 	err = domainRepo.Add(t.Context(), domain1)
@@ -217,11 +188,9 @@ func TestGetInstanceDomain(t *testing.T) {
 				database.WithCondition(domainRepo.IsPrimaryCondition(true)),
 			},
 			expected: &domain.InstanceDomain{
-				InstanceID:     instanceID,
-				Domain:         domainName1,
-				IsVerified:     true,
-				IsPrimary:      true,
-				ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
+				InstanceID: instanceID,
+				Domain:     domainName1,
+				IsPrimary:  true,
 			},
 		},
 		{
@@ -230,24 +199,9 @@ func TestGetInstanceDomain(t *testing.T) {
 				database.WithCondition(domainRepo.DomainCondition(database.TextOperationEqual, domainName2)),
 			},
 			expected: &domain.InstanceDomain{
-				InstanceID:     instanceID,
-				Domain:         domainName2,
-				IsVerified:     false,
-				IsPrimary:      false,
-				ValidationType: gu.Ptr(domain.DomainValidationTypeHTTP),
-			},
-		},
-		{
-			name: "get verified domain",
-			opts: []database.QueryOption{
-				database.WithCondition(domainRepo.IsVerifiedCondition(true)),
-			},
-			expected: &domain.InstanceDomain{
-				InstanceID:     instanceID,
-				Domain:         domainName1,
-				IsVerified:     true,
-				IsPrimary:      true,
-				ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
+				InstanceID: instanceID,
+				Domain:     domainName2,
+				IsPrimary:  false,
 			},
 		},
 		{
@@ -272,9 +226,7 @@ func TestGetInstanceDomain(t *testing.T) {
 			require.NoError(t, err)
 			assert.Equal(t, test.expected.InstanceID, result.InstanceID)
 			assert.Equal(t, test.expected.Domain, result.Domain)
-			assert.Equal(t, test.expected.IsVerified, result.IsVerified)
 			assert.Equal(t, test.expected.IsPrimary, result.IsPrimary)
-			assert.Equal(t, test.expected.ValidationType, result.ValidationType)
 			assert.NotEmpty(t, result.CreatedAt)
 			assert.NotEmpty(t, result.UpdatedAt)
 		})
@@ -307,25 +259,19 @@ func TestListInstanceDomains(t *testing.T) {
 	domainRepo := instanceRepo.Domains(false)
 	domains := []domain.AddInstanceDomain{
 		{
-			InstanceID:     instanceID,
-			Domain:         gofakeit.DomainName(),
-			IsVerified:     true,
-			IsPrimary:      true,
-			ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
+			InstanceID: instanceID,
+			Domain:     gofakeit.DomainName(),
+			IsPrimary:  true,
 		},
 		{
-			InstanceID:     instanceID,
-			Domain:         gofakeit.DomainName(),
-			IsVerified:     false,
-			IsPrimary:      false,
-			ValidationType: gu.Ptr(domain.DomainValidationTypeHTTP),
+			InstanceID: instanceID,
+			Domain:     gofakeit.DomainName(),
+			IsPrimary:  false,
 		},
 		{
-			InstanceID:     instanceID,
-			Domain:         gofakeit.DomainName(),
-			IsVerified:     true,
-			IsPrimary:      false,
-			ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
+			InstanceID: instanceID,
+			Domain:     gofakeit.DomainName(),
+			IsPrimary:  false,
 		},
 	}
 
@@ -344,13 +290,6 @@ func TestListInstanceDomains(t *testing.T) {
 			opts:          []database.QueryOption{},
 			expectedCount: 3,
 		},
-		{
-			name: "list verified domains",
-			opts: []database.QueryOption{
-				database.WithCondition(domainRepo.IsVerifiedCondition(true)),
-			},
-			expectedCount: 2,
-		},
 		{
 			name: "list primary domains",
 			opts: []database.QueryOption{
@@ -419,11 +358,9 @@ func TestUpdateInstanceDomain(t *testing.T) {
 	domainRepo := instanceRepo.Domains(false)
 	domainName := gofakeit.DomainName()
 	instanceDomain := &domain.AddInstanceDomain{
-		InstanceID:     instanceID,
-		Domain:         domainName,
-		IsVerified:     false,
-		IsPrimary:      false,
-		ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
+		InstanceID: instanceID,
+		Domain:     domainName,
+		IsPrimary:  false,
 	}
 
 	err = domainRepo.Add(t.Context(), instanceDomain)
@@ -436,38 +373,16 @@ func TestUpdateInstanceDomain(t *testing.T) {
 		expected  int64
 		err       error
 	}{
-		{
-			name:      "set verified",
-			condition: domainRepo.DomainCondition(database.TextOperationEqual, domainName),
-			changes:   []database.Change{domainRepo.SetVerified()},
-			expected:  1,
-		},
 		{
 			name:      "set primary",
 			condition: domainRepo.DomainCondition(database.TextOperationEqual, domainName),
 			changes:   []database.Change{domainRepo.SetPrimary()},
 			expected:  1,
 		},
-		{
-			name:      "set validation type",
-			condition: domainRepo.DomainCondition(database.TextOperationEqual, domainName),
-			changes:   []database.Change{domainRepo.SetValidationType(domain.DomainValidationTypeHTTP)},
-			expected:  1,
-		},
-		{
-			name:      "multiple changes",
-			condition: domainRepo.DomainCondition(database.TextOperationEqual, domainName),
-			changes: []database.Change{
-				domainRepo.SetVerified(),
-				domainRepo.SetPrimary(),
-				domainRepo.SetValidationType(domain.DomainValidationTypeDNS),
-			},
-			expected: 1,
-		},
 		{
 			name:      "update non-existent domain",
 			condition: domainRepo.DomainCondition(database.TextOperationEqual, "non-existent.com"),
-			changes:   []database.Change{domainRepo.SetVerified()},
+			changes:   []database.Change{domainRepo.SetPrimary()},
 			expected:  0,
 		},
 		{
@@ -533,18 +448,14 @@ func TestRemoveInstanceDomain(t *testing.T) {
 	domainName2 := gofakeit.DomainName()
 
 	domain1 := &domain.AddInstanceDomain{
-		InstanceID:     instanceID,
-		Domain:         domainName1,
-		IsVerified:     true,
-		IsPrimary:      true,
-		ValidationType: gu.Ptr(domain.DomainValidationTypeDNS),
+		InstanceID: instanceID,
+		Domain:     domainName1,
+		IsPrimary:  true,
 	}
 	domain2 := &domain.AddInstanceDomain{
-		InstanceID:     instanceID,
-		Domain:         domainName2,
-		IsVerified:     false,
-		IsPrimary:      false,
-		ValidationType: gu.Ptr(domain.DomainValidationTypeHTTP),
+		InstanceID: instanceID,
+		Domain:     domainName2,
+		IsPrimary:  false,
 	}
 
 	err = domainRepo.Add(t.Context(), domain1)
@@ -628,16 +539,6 @@ func TestInstanceDomainConditions(t *testing.T) {
 			condition: domainRepo.IsPrimaryCondition(false),
 			expected:  "instance_domains.is_primary = $1",
 		},
-		{
-			name:      "is verified true",
-			condition: domainRepo.IsVerifiedCondition(true),
-			expected:  "instance_domains.is_verified = $1",
-		},
-		{
-			name:      "is verified false",
-			condition: domainRepo.IsVerifiedCondition(false),
-			expected:  "instance_domains.is_verified = $1",
-		},
 	}
 
 	for _, test := range tests {
@@ -658,26 +559,11 @@ func TestInstanceDomainChanges(t *testing.T) {
 		change   database.Change
 		expected string
 	}{
-		{
-			name:     "set verified",
-			change:   domainRepo.SetVerified(),
-			expected: "is_verified = $1",
-		},
 		{
 			name:     "set primary",
 			change:   domainRepo.SetPrimary(),
 			expected: "is_primary = $1",
 		},
-		{
-			name:     "set validation type DNS",
-			change:   domainRepo.SetValidationType(domain.DomainValidationTypeDNS),
-			expected: "validation_type = $1",
-		},
-		{
-			name:     "set validation type HTTP",
-			change:   domainRepo.SetValidationType(domain.DomainValidationTypeHTTP),
-			expected: "validation_type = $1",
-		},
 	}
 
 	for _, test := range tests {