feat: instance domain APIs with relational tables (#11051)

# Which Problems Are Solved

This PR implements the endpoints listed in
https://github.com/zitadel/zitadel/issues/10444 .

# How the Problems Are Solved

The implementation follows the same pattern as the Instance one. The
`Add` and `Remove` are implementing the `Commander` interface, while
`List` Domains endpoints are implementing the `Querier` interace.

The PR adds also some forgotten calls to the relational logic for the
Instance API. The commits are identifiable by the label `instance:`
prepended to them. This is the complete list: bafce01b0 , 6fe7257ab ,
e27bc9c34 , 8133ede73 , fde667953 , a3e1135ed , ee1a6f9c1

# Additional Context

- Closes #10444

---------

Co-authored-by: Elio Bischof <[email protected]>
Co-authored-by: Lebogang Phoshoko <[email protected]>
Co-authored-by: Wim Van Laer <[email protected]>
Co-authored-by: Max Peintner <[email protected]>
Co-authored-by: Gayathri Vijayan <[email protected]>

backend/v3/api/instance/v2/convert/domain.go

@@ -0,0 +1,191 @@
+package convert
+
+import (
+	"google.golang.org/protobuf/types/known/timestamppb"
+
+	"github.com/zitadel/zitadel/backend/v3/domain"
+	filter_v2 "github.com/zitadel/zitadel/pkg/grpc/filter/v2"
+	instance_v2 "github.com/zitadel/zitadel/pkg/grpc/instance/v2"
+	instance_v2beta "github.com/zitadel/zitadel/pkg/grpc/instance/v2beta"
+)
+
+/*
+ * Domain Model to GRPC v2Beta
+ */
+
+func DomainInstanceDomainListModelToGRPCBetaResponse(dms []*domain.InstanceDomain) []*instance_v2beta.Domain {
+	toReturn := make([]*instance_v2beta.Domain, len(dms))
+	for i, domain := range dms {
+		isGenerated := domain.IsGenerated != nil && *domain.IsGenerated
+		isPrimary := domain.IsPrimary != nil && *domain.IsPrimary
+		toReturn[i] = &instance_v2beta.Domain{
+			InstanceId:   domain.InstanceID,
+			CreationDate: timestamppb.New(domain.CreatedAt),
+			Domain:       domain.Domain,
+			Primary:      isPrimary,
+			Generated:    isGenerated,
+		}
+	}
+
+	return toReturn
+}
+
+func TrustedDomainInstanceDomainListModelToGRPCBetaResponse(dms []*domain.InstanceDomain) []*instance_v2beta.TrustedDomain {
+	toReturn := make([]*instance_v2beta.TrustedDomain, len(dms))
+	for i, domain := range dms {
+		toReturn[i] = &instance_v2beta.TrustedDomain{
+			InstanceId:   domain.InstanceID,
+			CreationDate: timestamppb.New(domain.CreatedAt),
+			Domain:       domain.Domain,
+		}
+	}
+
+	return toReturn
+}
+
+/*
+ * Domain Model to GRPC v2
+ */
+
+func DomainInstanceDomainListModelToGRPCResponse(dms []*domain.InstanceDomain) []*instance_v2.CustomDomain {
+	toReturn := make([]*instance_v2.CustomDomain, len(dms))
+	for i, domain := range dms {
+		isGenerated := domain.IsGenerated != nil && *domain.IsGenerated
+		isPrimary := domain.IsPrimary != nil && *domain.IsPrimary
+		toReturn[i] = &instance_v2.CustomDomain{
+			InstanceId:   domain.InstanceID,
+			CreationDate: timestamppb.New(domain.CreatedAt),
+			Domain:       domain.Domain,
+			Primary:      isPrimary,
+			Generated:    isGenerated,
+		}
+	}
+
+	return toReturn
+}
+
+func TrustedDomainInstanceDomainListModelToGRPCResponse(dms []*domain.InstanceDomain) []*instance_v2.TrustedDomain {
+	toReturn := make([]*instance_v2.TrustedDomain, len(dms))
+	for i, domain := range dms {
+		toReturn[i] = &instance_v2.TrustedDomain{
+			InstanceId:   domain.InstanceID,
+			CreationDate: timestamppb.New(domain.CreatedAt),
+			Domain:       domain.Domain,
+		}
+	}
+
+	return toReturn
+}
+
+/*
+ * GRPC v2Beta Requests to GRPC v2
+ */
+
+func ListCustomDomainsBetaRequestToV2Request(in *instance_v2beta.ListCustomDomainsRequest) *instance_v2.ListCustomDomainsRequest {
+	return &instance_v2.ListCustomDomainsRequest{
+		InstanceId: in.GetInstanceId(),
+		Pagination: &filter_v2.PaginationRequest{
+			Offset: in.GetPagination().GetOffset(),
+			Limit:  in.GetPagination().GetLimit(),
+			Asc:    in.GetPagination().GetAsc(),
+		},
+		SortingColumn: listCustomDomainsBetaSortingColToV2Request(in.GetSortingColumn()),
+		Filters:       listCustomDomainsQueriesToV2Request(in.GetQueries()),
+	}
+}
+
+func listCustomDomainsBetaSortingColToV2Request(domainFieldName instance_v2beta.DomainFieldName) instance_v2.DomainFieldName {
+	switch domainFieldName {
+	case instance_v2beta.DomainFieldName_DOMAIN_FIELD_NAME_CREATION_DATE:
+		return instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_CREATION_DATE
+	case instance_v2beta.DomainFieldName_DOMAIN_FIELD_NAME_DOMAIN:
+		return instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_DOMAIN
+	case instance_v2beta.DomainFieldName_DOMAIN_FIELD_NAME_GENERATED:
+		return instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_GENERATED
+	case instance_v2beta.DomainFieldName_DOMAIN_FIELD_NAME_PRIMARY:
+		return instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_PRIMARY
+	case instance_v2beta.DomainFieldName_DOMAIN_FIELD_NAME_UNSPECIFIED:
+		fallthrough
+	default:
+		return instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_UNSPECIFIED
+	}
+}
+
+func listCustomDomainsQueriesToV2Request(domainSearchQuery []*instance_v2beta.DomainSearchQuery) []*instance_v2.CustomDomainFilter {
+	toReturn := make([]*instance_v2.CustomDomainFilter, len(domainSearchQuery))
+
+	for i, query := range domainSearchQuery {
+		switch assertedType := query.GetQuery().(type) {
+		case *instance_v2beta.DomainSearchQuery_DomainQuery:
+			filter := &instance_v2.CustomDomainFilter_DomainFilter{
+				DomainFilter: &instance_v2.DomainFilter{
+					Domain: assertedType.DomainQuery.GetDomain(),
+					Method: assertedType.DomainQuery.GetMethod(),
+				},
+			}
+			toReturn[i] = &instance_v2.CustomDomainFilter{
+				Filter: filter,
+			}
+		case *instance_v2beta.DomainSearchQuery_GeneratedQuery:
+			filter := &instance_v2.CustomDomainFilter_GeneratedFilter{
+				GeneratedFilter: assertedType.GeneratedQuery.GetGenerated(),
+			}
+			toReturn[i] = &instance_v2.CustomDomainFilter{
+				Filter: filter,
+			}
+		case *instance_v2beta.DomainSearchQuery_PrimaryQuery:
+			filter := &instance_v2.CustomDomainFilter_PrimaryFilter{
+				PrimaryFilter: assertedType.PrimaryQuery.GetPrimary(),
+			}
+			toReturn[i] = &instance_v2.CustomDomainFilter{
+				Filter: filter,
+			}
+		}
+	}
+	return toReturn
+}
+
+func ListTrustedDomainsBetaRequestToV2Request(in *instance_v2beta.ListTrustedDomainsRequest) *instance_v2.ListTrustedDomainsRequest {
+	return &instance_v2.ListTrustedDomainsRequest{
+		InstanceId: in.GetInstanceId(),
+		Pagination: &filter_v2.PaginationRequest{
+			Offset: in.GetPagination().GetOffset(),
+			Limit:  in.GetPagination().GetLimit(),
+			Asc:    in.GetPagination().GetAsc(),
+		},
+		SortingColumn: listTrustedDomainsBetaSortingColToV2Request(in.GetSortingColumn()),
+		Filters:       listTrustedDomainsQueriesToV2Request(in.GetQueries()),
+	}
+}
+
+func listTrustedDomainsBetaSortingColToV2Request(domainFieldName instance_v2beta.TrustedDomainFieldName) instance_v2.TrustedDomainFieldName {
+	switch domainFieldName {
+	case instance_v2beta.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_CREATION_DATE:
+		return instance_v2.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_CREATION_DATE
+	case instance_v2beta.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_DOMAIN:
+		return instance_v2.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_DOMAIN
+	case instance_v2beta.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_UNSPECIFIED:
+		fallthrough
+	default:
+		return instance_v2.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_UNSPECIFIED
+	}
+}
+
+func listTrustedDomainsQueriesToV2Request(domainSearchQuery []*instance_v2beta.TrustedDomainSearchQuery) []*instance_v2.TrustedDomainFilter {
+	toReturn := make([]*instance_v2.TrustedDomainFilter, len(domainSearchQuery))
+
+	for i, query := range domainSearchQuery {
+		if assertedType, ok := query.GetQuery().(*instance_v2beta.TrustedDomainSearchQuery_DomainQuery); ok {
+			filter := &instance_v2.TrustedDomainFilter_DomainFilter{
+				DomainFilter: &instance_v2.DomainFilter{
+					Domain: assertedType.DomainQuery.GetDomain(),
+					Method: assertedType.DomainQuery.GetMethod(),
+				},
+			}
+			toReturn[i] = &instance_v2.TrustedDomainFilter{
+				Filter: filter,
+			}
+		}
+	}
+	return toReturn
+}

backend/v3/api/instance/v2/convert/domain_test.go

@@ -0,0 +1,426 @@
+package convert
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"google.golang.org/protobuf/types/known/timestamppb"
+
+	"github.com/zitadel/zitadel/backend/v3/domain"
+	filter_v2 "github.com/zitadel/zitadel/pkg/grpc/filter/v2"
+	filter_v2beta "github.com/zitadel/zitadel/pkg/grpc/filter/v2beta"
+	instance_v2 "github.com/zitadel/zitadel/pkg/grpc/instance/v2"
+	instance_v2beta "github.com/zitadel/zitadel/pkg/grpc/instance/v2beta"
+	"github.com/zitadel/zitadel/pkg/grpc/object/v2"
+)
+
+func TestListCustomDomainsBetaRequestToV2Request(t *testing.T) {
+	t.Parallel()
+
+	tt := []struct {
+		testName        string
+		inputRequest    *instance_v2beta.ListCustomDomainsRequest
+		expectedRequest *instance_v2.ListCustomDomainsRequest
+	}{
+		{
+			testName: "with all fields",
+			inputRequest: &instance_v2beta.ListCustomDomainsRequest{
+				InstanceId: "instance1",
+				Pagination: &filter_v2beta.PaginationRequest{
+					Offset: 0,
+					Limit:  10,
+					Asc:    true,
+				},
+				SortingColumn: instance_v2beta.DomainFieldName_DOMAIN_FIELD_NAME_DOMAIN,
+				Queries: []*instance_v2beta.DomainSearchQuery{
+					{
+						Query: &instance_v2beta.DomainSearchQuery_DomainQuery{
+							DomainQuery: &instance_v2beta.DomainQuery{
+								Domain: "test.com",
+								Method: object.TextQueryMethod_TEXT_QUERY_METHOD_EQUALS,
+							},
+						},
+					},
+					{
+						Query: &instance_v2beta.DomainSearchQuery_GeneratedQuery{
+							GeneratedQuery: &instance_v2beta.DomainGeneratedQuery{
+								Generated: true,
+							},
+						},
+					},
+					{
+						Query: &instance_v2beta.DomainSearchQuery_PrimaryQuery{
+							PrimaryQuery: &instance_v2beta.DomainPrimaryQuery{
+								Primary: true,
+							},
+						},
+					},
+				},
+			},
+			expectedRequest: &instance_v2.ListCustomDomainsRequest{
+				InstanceId: "instance1",
+				Pagination: &filter_v2.PaginationRequest{
+					Offset: 0,
+					Limit:  10,
+					Asc:    true,
+				},
+				SortingColumn: instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_DOMAIN,
+				Filters: []*instance_v2.CustomDomainFilter{
+					{
+						Filter: &instance_v2.CustomDomainFilter_DomainFilter{
+							DomainFilter: &instance_v2.DomainFilter{
+								Domain: "test.com",
+								Method: object.TextQueryMethod_TEXT_QUERY_METHOD_EQUALS,
+							},
+						},
+					},
+					{
+						Filter: &instance_v2.CustomDomainFilter_GeneratedFilter{
+							GeneratedFilter: true,
+						},
+					},
+					{
+						Filter: &instance_v2.CustomDomainFilter_PrimaryFilter{
+							PrimaryFilter: true,
+						},
+					},
+				},
+			},
+		},
+		{
+			testName:     "empty request",
+			inputRequest: &instance_v2beta.ListCustomDomainsRequest{},
+			expectedRequest: &instance_v2.ListCustomDomainsRequest{
+				Pagination: &filter_v2.PaginationRequest{},
+				Filters:    []*instance_v2.CustomDomainFilter{},
+			},
+		},
+		{
+			testName: "with sorting only",
+			inputRequest: &instance_v2beta.ListCustomDomainsRequest{
+				SortingColumn: instance_v2beta.DomainFieldName_DOMAIN_FIELD_NAME_CREATION_DATE,
+			},
+			expectedRequest: &instance_v2.ListCustomDomainsRequest{
+				Pagination:    &filter_v2.PaginationRequest{},
+				SortingColumn: instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_CREATION_DATE,
+				Filters:       []*instance_v2.CustomDomainFilter{},
+			},
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.testName, func(t *testing.T) {
+			t.Parallel()
+			got := ListCustomDomainsBetaRequestToV2Request(tc.inputRequest)
+			assert.Equal(t, tc.expectedRequest, got)
+		})
+	}
+}
+
+func Test_listCustomDomainsBetaSortingColToV2Request(t *testing.T) {
+	t.Parallel()
+
+	tt := []struct {
+		testName         string
+		inputFieldName   instance_v2beta.DomainFieldName
+		expecteFieldName instance_v2.DomainFieldName
+	}{
+		{
+			testName:         "creation date",
+			inputFieldName:   instance_v2beta.DomainFieldName_DOMAIN_FIELD_NAME_CREATION_DATE,
+			expecteFieldName: instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_CREATION_DATE,
+		},
+		{
+			testName:         "domain",
+			inputFieldName:   instance_v2beta.DomainFieldName_DOMAIN_FIELD_NAME_DOMAIN,
+			expecteFieldName: instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_DOMAIN,
+		},
+		{
+			testName:         "generated",
+			inputFieldName:   instance_v2beta.DomainFieldName_DOMAIN_FIELD_NAME_GENERATED,
+			expecteFieldName: instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_GENERATED,
+		},
+		{
+			testName:         "primary",
+			inputFieldName:   instance_v2beta.DomainFieldName_DOMAIN_FIELD_NAME_PRIMARY,
+			expecteFieldName: instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_PRIMARY,
+		},
+		{
+			testName:         "unspecified",
+			inputFieldName:   instance_v2beta.DomainFieldName_DOMAIN_FIELD_NAME_UNSPECIFIED,
+			expecteFieldName: instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_UNSPECIFIED,
+		},
+		{
+			testName:         "default",
+			inputFieldName:   instance_v2beta.DomainFieldName(99),
+			expecteFieldName: instance_v2.DomainFieldName_DOMAIN_FIELD_NAME_UNSPECIFIED,
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.testName, func(t *testing.T) {
+			t.Parallel()
+			got := listCustomDomainsBetaSortingColToV2Request(tc.inputFieldName)
+			assert.Equal(t, tc.expecteFieldName, got)
+		})
+	}
+}
+
+func TestListTrustedDomainsBetaRequestToV2Request(t *testing.T) {
+	t.Parallel()
+
+	tt := []struct {
+		testName        string
+		inputRequest    *instance_v2beta.ListTrustedDomainsRequest
+		expectedRequest *instance_v2.ListTrustedDomainsRequest
+	}{
+		{
+			testName: "with all fields",
+			inputRequest: &instance_v2beta.ListTrustedDomainsRequest{
+				InstanceId: "instance1",
+				Pagination: &filter_v2beta.PaginationRequest{
+					Offset: 0,
+					Limit:  10,
+					Asc:    true,
+				},
+				SortingColumn: instance_v2beta.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_DOMAIN,
+				Queries: []*instance_v2beta.TrustedDomainSearchQuery{
+					{
+						Query: &instance_v2beta.TrustedDomainSearchQuery_DomainQuery{
+							DomainQuery: &instance_v2beta.DomainQuery{
+								Domain: "test.com",
+								Method: object.TextQueryMethod_TEXT_QUERY_METHOD_EQUALS,
+							},
+						},
+					},
+				},
+			},
+			expectedRequest: &instance_v2.ListTrustedDomainsRequest{
+				InstanceId: "instance1",
+				Pagination: &filter_v2.PaginationRequest{
+					Offset: 0,
+					Limit:  10,
+					Asc:    true,
+				},
+				SortingColumn: instance_v2.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_DOMAIN,
+				Filters: []*instance_v2.TrustedDomainFilter{
+					{
+						Filter: &instance_v2.TrustedDomainFilter_DomainFilter{
+							DomainFilter: &instance_v2.DomainFilter{
+								Domain: "test.com",
+								Method: object.TextQueryMethod_TEXT_QUERY_METHOD_EQUALS,
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			testName:     "empty request",
+			inputRequest: &instance_v2beta.ListTrustedDomainsRequest{},
+			expectedRequest: &instance_v2.ListTrustedDomainsRequest{
+				Pagination: &filter_v2.PaginationRequest{},
+				Filters:    []*instance_v2.TrustedDomainFilter{},
+			},
+		},
+		{
+			testName: "with sorting only",
+			inputRequest: &instance_v2beta.ListTrustedDomainsRequest{
+				SortingColumn: instance_v2beta.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_CREATION_DATE,
+			},
+			expectedRequest: &instance_v2.ListTrustedDomainsRequest{
+				Pagination:    &filter_v2.PaginationRequest{},
+				SortingColumn: instance_v2.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_CREATION_DATE,
+				Filters:       []*instance_v2.TrustedDomainFilter{},
+			},
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.testName, func(t *testing.T) {
+			t.Parallel()
+			got := ListTrustedDomainsBetaRequestToV2Request(tc.inputRequest)
+			assert.Equal(t, tc.expectedRequest, got)
+		})
+	}
+}
+
+func Test_listTrustedDomainsBetaSortingColToV2Request(t *testing.T) {
+	t.Parallel()
+
+	tt := []struct {
+		testName         string
+		inputFieldName   instance_v2beta.TrustedDomainFieldName
+		expecteFieldName instance_v2.TrustedDomainFieldName
+	}{
+		{
+			testName:         "creation date",
+			inputFieldName:   instance_v2beta.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_CREATION_DATE,
+			expecteFieldName: instance_v2.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_CREATION_DATE,
+		},
+		{
+			testName:         "domain",
+			inputFieldName:   instance_v2beta.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_DOMAIN,
+			expecteFieldName: instance_v2.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_DOMAIN,
+		},
+		{
+			testName:         "unspecified",
+			inputFieldName:   instance_v2beta.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_UNSPECIFIED,
+			expecteFieldName: instance_v2.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_UNSPECIFIED,
+		},
+		{
+			testName:         "default",
+			inputFieldName:   instance_v2beta.TrustedDomainFieldName(99),
+			expecteFieldName: instance_v2.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_UNSPECIFIED,
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.testName, func(t *testing.T) {
+			t.Parallel()
+			got := listTrustedDomainsBetaSortingColToV2Request(tc.inputFieldName)
+			assert.Equal(t, tc.expecteFieldName, got)
+		})
+	}
+}
+
+func TestTrustedDomainInstanceDomainListModelToGRPCBetaResponse(t *testing.T) {
+	t.Parallel()
+
+	testTime := time.Now()
+
+	tt := []struct {
+		name     string
+		input    []*domain.InstanceDomain
+		expected []*instance_v2beta.TrustedDomain
+	}{
+		{
+			name: "single domain",
+			input: []*domain.InstanceDomain{
+				{
+					InstanceID: "instance1",
+					CreatedAt:  testTime,
+					Domain:     "test.com",
+				},
+			},
+			expected: []*instance_v2beta.TrustedDomain{
+				{
+					InstanceId:   "instance1",
+					CreationDate: timestamppb.New(testTime),
+					Domain:       "test.com",
+				},
+			},
+		},
+		{
+			name: "multiple domains",
+			input: []*domain.InstanceDomain{
+				{
+					InstanceID: "instance1",
+					CreatedAt:  testTime,
+					Domain:     "test1.com",
+				},
+				{
+					InstanceID: "instance2",
+					CreatedAt:  testTime,
+					Domain:     "test2.com",
+				},
+			},
+			expected: []*instance_v2beta.TrustedDomain{
+				{
+					InstanceId:   "instance1",
+					CreationDate: timestamppb.New(testTime),
+					Domain:       "test1.com",
+				},
+				{
+					InstanceId:   "instance2",
+					CreationDate: timestamppb.New(testTime),
+					Domain:       "test2.com",
+				},
+			},
+		},
+		{
+			name:     "empty list",
+			input:    []*domain.InstanceDomain{},
+			expected: []*instance_v2beta.TrustedDomain{},
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			got := TrustedDomainInstanceDomainListModelToGRPCBetaResponse(tc.input)
+			assert.Equal(t, tc.expected, got)
+		})
+	}
+}
+
+func TestTrustedDomainInstanceDomainListModelToGRPCResponse(t *testing.T) {
+	t.Parallel()
+
+	testTime := time.Now()
+
+	tt := []struct {
+		name     string
+		input    []*domain.InstanceDomain
+		expected []*instance_v2.TrustedDomain
+	}{
+		{
+			name: "single domain",
+			input: []*domain.InstanceDomain{
+				{
+					InstanceID: "instance1",
+					CreatedAt:  testTime,
+					Domain:     "test.com",
+				},
+			},
+			expected: []*instance_v2.TrustedDomain{
+				{
+					InstanceId:   "instance1",
+					CreationDate: timestamppb.New(testTime),
+					Domain:       "test.com",
+				},
+			},
+		},
+		{
+			name: "multiple domains",
+			input: []*domain.InstanceDomain{
+				{
+					InstanceID: "instance1",
+					CreatedAt:  testTime,
+					Domain:     "test1.com",
+				},
+				{
+					InstanceID: "instance2",
+					CreatedAt:  testTime,
+					Domain:     "test2.com",
+				},
+			},
+			expected: []*instance_v2.TrustedDomain{
+				{
+					InstanceId:   "instance1",
+					CreationDate: timestamppb.New(testTime),
+					Domain:       "test1.com",
+				},
+				{
+					InstanceId:   "instance2",
+					CreationDate: timestamppb.New(testTime),
+					Domain:       "test2.com",
+				},
+			},
+		},
+		{
+			name:     "empty list",
+			input:    []*domain.InstanceDomain{},
+			expected: []*instance_v2.TrustedDomain{},
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			got := TrustedDomainInstanceDomainListModelToGRPCResponse(tc.input)
+			assert.Equal(t, tc.expected, got)
+		})
+	}
+}

backend/v3/api/instance/v2/convert/instance.go

@@ -5,15 +5,42 @@ import (
 
 	"github.com/zitadel/zitadel/backend/v3/domain"
 	"github.com/zitadel/zitadel/cmd/build"
-	instance "github.com/zitadel/zitadel/pkg/grpc/instance/v2beta"
+	"github.com/zitadel/zitadel/pkg/grpc/filter/v2"
+	instance_v2 "github.com/zitadel/zitadel/pkg/grpc/instance/v2"
+	instance_v2beta "github.com/zitadel/zitadel/pkg/grpc/instance/v2beta"
 )
 
+/*
+ * Domain Model to GRPC v2Beta
+ */
+
+func DomainInstanceListModelToGRPCBetaResponse(instances []*domain.Instance) []*instance_v2beta.Instance {
+	toReturn := make([]*instance_v2beta.Instance, len(instances))
+
+	for i, inst := range instances {
+		toReturn[i] = DomainInstanceModelToGRPCBetaResponse(inst)
+	}
+
+	return toReturn
+}
+
+func DomainInstanceModelToGRPCBetaResponse(inst *domain.Instance) *instance_v2beta.Instance {
+	return &instance_v2beta.Instance{
+		Id:           inst.ID,
+		ChangeDate:   timestamppb.New(inst.UpdatedAt),
+		CreationDate: timestamppb.New(inst.CreatedAt),
+		Name:         inst.Name,
+		Version:      build.Version(),
+		Domains:      DomainInstanceDomainListModelToGRPCBetaResponse(inst.Domains),
+	}
+}
+
 /*
  * Domain Model to GRPC v2
  */
 
-func DomainInstanceListModelToGRPCResponse(instances []*domain.Instance) []*instance.Instance {
-	toReturn := make([]*instance.Instance, len(instances))
+func DomainInstanceListModelToGRPCResponse(instances []*domain.Instance) []*instance_v2.Instance {
+	toReturn := make([]*instance_v2.Instance, len(instances))
 
 	for i, inst := range instances {
 		toReturn[i] = DomainInstanceModelToGRPCResponse(inst)
@@ -22,31 +49,72 @@ func DomainInstanceListModelToGRPCResponse(instances []*domain.Instance) []*inst
 	return toReturn
 }
 
-func DomainInstanceModelToGRPCResponse(inst *domain.Instance) *instance.Instance {
-	return &instance.Instance{
-		Id:           inst.ID,
-		ChangeDate:   timestamppb.New(inst.UpdatedAt),
-		CreationDate: timestamppb.New(inst.CreatedAt),
-		State:        instance.State_STATE_RUNNING, // TODO(IAM-Marco): Not sure what to put here
-		Name:         inst.Name,
-		Version:      build.Version(),
-		Domains:      domainInstanceDomainListModelToGRPCResponse(inst.Domains),
+func DomainInstanceModelToGRPCResponse(inst *domain.Instance) *instance_v2.Instance {
+	return &instance_v2.Instance{
+		Id:            inst.ID,
+		ChangeDate:    timestamppb.New(inst.UpdatedAt),
+		CreationDate:  timestamppb.New(inst.CreatedAt),
+		State:         instance_v2.State_STATE_RUNNING, // TODO(IAM-Marco): Not sure what to put here
+		Name:          inst.Name,
+		Version:       build.Version(),
+		CustomDomains: DomainInstanceDomainListModelToGRPCResponse(inst.Domains),
 	}
 }
 
-func domainInstanceDomainListModelToGRPCResponse(dms []*domain.InstanceDomain) []*instance.Domain {
-	toReturn := make([]*instance.Domain, len(dms))
-	for i, domain := range dms {
-		isGenerated := domain.IsGenerated != nil && *domain.IsGenerated
-		isPrimary := domain.IsPrimary != nil && *domain.IsPrimary
-		toReturn[i] = &instance.Domain{
-			InstanceId:   domain.InstanceID,
-			CreationDate: timestamppb.New(domain.CreatedAt),
-			Domain:       domain.Domain,
-			Primary:      isPrimary,
-			Generated:    isGenerated,
+/*
+ * GRPC v2Beta Requests to GRPC v2
+ */
+
+func ListInstancesBetaRequestToV2Request(in *instance_v2beta.ListInstancesRequest) *instance_v2.ListInstancesRequest {
+	return &instance_v2.ListInstancesRequest{
+		Pagination: &filter.PaginationRequest{
+			Offset: in.GetPagination().GetOffset(),
+			Limit:  in.GetPagination().GetLimit(),
+			Asc:    in.GetPagination().GetAsc(),
+		},
+		SortingColumn: listInstancesBetaSortingColToV2Request(in.SortingColumn),
+		Filters:       listInstancesQueriesToV2Request(in.GetQueries()),
+	}
+}
+
+func listInstancesQueriesToV2Request(queries []*instance_v2beta.Query) []*instance_v2.Filter {
+	toReturn := make([]*instance_v2.Filter, len(queries))
+	for i, query := range queries {
+		switch assertedQuery := query.GetQuery().(type) {
+		case *instance_v2beta.Query_DomainQuery:
+			filter := &instance_v2.Filter_CustomDomainsFilter{
+				CustomDomainsFilter: &instance_v2.CustomDomainsFilter{
+					Domains: assertedQuery.DomainQuery.GetDomains(),
+				},
+			}
+			toReturn[i] = &instance_v2.Filter{Filter: filter}
+		case *instance_v2beta.Query_IdQuery:
+			filter := &instance_v2.Filter_InIdsFilter{
+				InIdsFilter: &filter.InIDsFilter{
+					Ids: assertedQuery.IdQuery.GetIds(),
+				},
+			}
+			toReturn[i] = &instance_v2.Filter{Filter: filter}
 		}
 	}
-
 	return toReturn
 }
+
+func listInstancesBetaSortingColToV2Request(fieldName *instance_v2beta.FieldName) instance_v2.FieldName {
+	if fieldName == nil {
+		return instance_v2.FieldName_FIELD_NAME_UNSPECIFIED
+	}
+
+	switch *fieldName {
+	case instance_v2beta.FieldName_FIELD_NAME_CREATION_DATE:
+		return instance_v2.FieldName_FIELD_NAME_CREATION_DATE
+	case instance_v2beta.FieldName_FIELD_NAME_ID:
+		return instance_v2.FieldName_FIELD_NAME_ID
+	case instance_v2beta.FieldName_FIELD_NAME_NAME:
+		return instance_v2.FieldName_FIELD_NAME_NAME
+	case instance_v2beta.FieldName_FIELD_NAME_UNSPECIFIED:
+		fallthrough
+	default:
+		return instance_v2.FieldName_FIELD_NAME_UNSPECIFIED
+	}
+}

backend/v3/api/instance/v2/convert/instance_test.go

@@ -9,9 +9,99 @@ import (
 	"google.golang.org/protobuf/types/known/timestamppb"
 
 	"github.com/zitadel/zitadel/backend/v3/domain"
-	instance "github.com/zitadel/zitadel/pkg/grpc/instance/v2beta"
+	filter_v2 "github.com/zitadel/zitadel/pkg/grpc/filter/v2"
+	filter_v2beta "github.com/zitadel/zitadel/pkg/grpc/filter/v2beta"
+	instance_v2 "github.com/zitadel/zitadel/pkg/grpc/instance/v2"
+	instance_v2beta "github.com/zitadel/zitadel/pkg/grpc/instance/v2beta"
 )
 
+func TestDomainInstanceModelToGRPCBetaResponse(t *testing.T) {
+	// Given
+	t.Parallel()
+
+	now := time.Now().UTC()
+	yesterday := now.AddDate(0, 0, -1)
+
+	inputInstance := &domain.Instance{
+		ID:        "instance-1",
+		Name:      "Instance One",
+		CreatedAt: yesterday,
+		UpdatedAt: now,
+		Domains: []*domain.InstanceDomain{
+			{
+				InstanceID: "instance-1",
+				Domain:     "d1.example.com",
+				IsPrimary:  gu.Ptr(true),
+				CreatedAt:  yesterday,
+			},
+			{
+				InstanceID:  "instance-1",
+				Domain:      "d2.example.com",
+				IsGenerated: gu.Ptr(true),
+				CreatedAt:   yesterday,
+			},
+			{
+				InstanceID:  "instance-1",
+				Domain:      "d3.example.com",
+				IsPrimary:   gu.Ptr(true),
+				IsGenerated: gu.Ptr(false),
+				CreatedAt:   yesterday,
+			},
+			{
+				InstanceID:  "instance-1",
+				Domain:      "d4.example.com",
+				IsPrimary:   gu.Ptr(false),
+				IsGenerated: gu.Ptr(true),
+				CreatedAt:   yesterday,
+			},
+		},
+	}
+
+	expectedInstance := &instance_v2beta.Instance{
+		Id:           "instance-1",
+		ChangeDate:   timestamppb.New(now),
+		CreationDate: timestamppb.New(yesterday),
+		Name:         "Instance One",
+		Version:      "",
+		Domains: []*instance_v2beta.Domain{
+			{
+				InstanceId:   "instance-1",
+				CreationDate: timestamppb.New(yesterday),
+				Domain:       "d1.example.com",
+				Primary:      true,
+				Generated:    false,
+			},
+			{
+				InstanceId:   "instance-1",
+				CreationDate: timestamppb.New(yesterday),
+				Domain:       "d2.example.com",
+				Primary:      false,
+				Generated:    true,
+			},
+			{
+				InstanceId:   "instance-1",
+				CreationDate: timestamppb.New(yesterday),
+				Domain:       "d3.example.com",
+				Primary:      true,
+				Generated:    false,
+			},
+			{
+				InstanceId:   "instance-1",
+				CreationDate: timestamppb.New(yesterday),
+				Domain:       "d4.example.com",
+				Primary:      false,
+				Generated:    true,
+			},
+		},
+	}
+
+	// Test
+	res := DomainInstanceModelToGRPCBetaResponse(inputInstance)
+
+	// Verify
+	assert.Equal(t, expectedInstance, res)
+}
+
 func TestDomainInstanceModelToGRPCResponse(t *testing.T) {
 	// Given
 	t.Parallel()
@@ -54,14 +144,14 @@ func TestDomainInstanceModelToGRPCResponse(t *testing.T) {
 		},
 	}
 
-	expectedInstance := &instance.Instance{
+	expectedInstance := &instance_v2.Instance{
 		Id:           "instance-1",
 		ChangeDate:   timestamppb.New(now),
 		CreationDate: timestamppb.New(yesterday),
-		State:        instance.State_STATE_RUNNING,
+		State:        instance_v2.State_STATE_RUNNING,
 		Name:         "Instance One",
 		Version:      "",
-		Domains: []*instance.Domain{
+		CustomDomains: []*instance_v2.CustomDomain{
 			{
 				InstanceId:   "instance-1",
 				CreationDate: timestamppb.New(yesterday),
@@ -100,19 +190,19 @@ func TestDomainInstanceModelToGRPCResponse(t *testing.T) {
 	assert.Equal(t, expectedInstance, res)
 }
 
-func TestDomainInstanceListModelToGRPCResponse(t *testing.T) {
+func TestDomainInstanceListModelToGRPCBetaResponse(t *testing.T) {
 	t.Parallel()
 	now := time.Now()
 
 	tt := []struct {
 		testName       string
 		inputResult    []*domain.Instance
-		expectedResult []*instance.Instance
+		expectedResult []*instance_v2beta.Instance
 	}{
 		{
 			testName:       "empty result",
 			inputResult:    []*domain.Instance{},
-			expectedResult: []*instance.Instance{},
+			expectedResult: []*instance_v2beta.Instance{},
 		},
 		{
 			testName: "single instance without domains",
@@ -125,14 +215,13 @@ func TestDomainInstanceListModelToGRPCResponse(t *testing.T) {
 					Domains:   nil,
 				},
 			},
-			expectedResult: []*instance.Instance{
+			expectedResult: []*instance_v2beta.Instance{
 				{
 					Id:           "instance1",
 					Name:         "test-instance",
 					CreationDate: timestamppb.New(now),
 					ChangeDate:   timestamppb.New(now),
-					State:        instance.State_STATE_RUNNING,
-					Domains:      []*instance.Domain{},
+					Domains:      []*instance_v2beta.Domain{},
 				},
 			},
 		},
@@ -162,14 +251,13 @@ func TestDomainInstanceListModelToGRPCResponse(t *testing.T) {
 					Domains:   nil,
 				},
 			},
-			expectedResult: []*instance.Instance{
+			expectedResult: []*instance_v2beta.Instance{
 				{
 					Id:           "instance1",
 					Name:         "test-instance-1",
 					CreationDate: timestamppb.New(now),
 					ChangeDate:   timestamppb.New(now),
-					State:        instance.State_STATE_RUNNING,
-					Domains: []*instance.Domain{
+					Domains: []*instance_v2beta.Domain{
 						{
 							InstanceId:   "instance1",
 							Domain:       "domain1.com",
@@ -184,8 +272,110 @@ func TestDomainInstanceListModelToGRPCResponse(t *testing.T) {
 					Name:         "test-instance-2",
 					CreationDate: timestamppb.New(now),
 					ChangeDate:   timestamppb.New(now),
-					State:        instance.State_STATE_RUNNING,
-					Domains:      []*instance.Domain{},
+					Domains:      []*instance_v2beta.Domain{},
+				},
+			},
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.testName, func(t *testing.T) {
+			t.Parallel()
+			// Test
+			result := DomainInstanceListModelToGRPCBetaResponse(tc.inputResult)
+
+			// Verify
+			assert.Equal(t, tc.expectedResult, result)
+		})
+	}
+}
+
+func TestDomainInstanceListModelToGRPCResponse(t *testing.T) {
+	t.Parallel()
+	now := time.Now()
+
+	tt := []struct {
+		testName       string
+		inputResult    []*domain.Instance
+		expectedResult []*instance_v2.Instance
+	}{
+		{
+			testName:       "empty result",
+			inputResult:    []*domain.Instance{},
+			expectedResult: []*instance_v2.Instance{},
+		},
+		{
+			testName: "single instance without domains",
+			inputResult: []*domain.Instance{
+				{
+					ID:        "instance1",
+					Name:      "test-instance",
+					CreatedAt: now,
+					UpdatedAt: now,
+					Domains:   nil,
+				},
+			},
+			expectedResult: []*instance_v2.Instance{
+				{
+					Id:            "instance1",
+					Name:          "test-instance",
+					CreationDate:  timestamppb.New(now),
+					ChangeDate:    timestamppb.New(now),
+					State:         instance_v2.State_STATE_RUNNING,
+					CustomDomains: []*instance_v2.CustomDomain{},
+				},
+			},
+		},
+		{
+			testName: "multiple instances with domains",
+			inputResult: []*domain.Instance{
+				{
+					ID:        "instance1",
+					Name:      "test-instance-1",
+					CreatedAt: now,
+					UpdatedAt: now,
+					Domains: []*domain.InstanceDomain{
+						{
+							InstanceID:  "instance1",
+							Domain:      "domain1.com",
+							CreatedAt:   now,
+							IsPrimary:   gu.Ptr(true),
+							IsGenerated: gu.Ptr(false),
+						},
+					},
+				},
+				{
+					ID:        "instance2",
+					Name:      "test-instance-2",
+					CreatedAt: now,
+					UpdatedAt: now,
+					Domains:   nil,
+				},
+			},
+			expectedResult: []*instance_v2.Instance{
+				{
+					Id:           "instance1",
+					Name:         "test-instance-1",
+					CreationDate: timestamppb.New(now),
+					ChangeDate:   timestamppb.New(now),
+					State:        instance_v2.State_STATE_RUNNING,
+					CustomDomains: []*instance_v2.CustomDomain{
+						{
+							InstanceId:   "instance1",
+							Domain:       "domain1.com",
+							CreationDate: timestamppb.New(now),
+							Primary:      true,
+							Generated:    false,
+						},
+					},
+				},
+				{
+					Id:            "instance2",
+					Name:          "test-instance-2",
+					CreationDate:  timestamppb.New(now),
+					ChangeDate:    timestamppb.New(now),
+					State:         instance_v2.State_STATE_RUNNING,
+					CustomDomains: []*instance_v2.CustomDomain{},
 				},
 			},
 		},
@@ -202,3 +392,140 @@ func TestDomainInstanceListModelToGRPCResponse(t *testing.T) {
 		})
 	}
 }
+
+func TestListInstancesBetaRequestToV2Request(t *testing.T) {
+	t.Parallel()
+
+	tt := []struct {
+		name    string
+		request *instance_v2beta.ListInstancesRequest
+		want    *instance_v2.ListInstancesRequest
+	}{
+		{
+			name: "empty request",
+			request: &instance_v2beta.ListInstancesRequest{
+				Pagination: &filter_v2beta.PaginationRequest{},
+			},
+			want: &instance_v2.ListInstancesRequest{
+				Pagination:    &filter_v2.PaginationRequest{},
+				SortingColumn: instance_v2.FieldName_FIELD_NAME_UNSPECIFIED,
+				Filters:       []*instance_v2.Filter{},
+			},
+		},
+		{
+			name: "request with all fields",
+			request: &instance_v2beta.ListInstancesRequest{
+				Pagination: &filter_v2beta.PaginationRequest{
+					Offset: 10,
+					Limit:  20,
+					Asc:    true,
+				},
+				SortingColumn: gu.Ptr(instance_v2beta.FieldName_FIELD_NAME_NAME),
+				Queries: []*instance_v2beta.Query{
+					{
+						Query: &instance_v2beta.Query_DomainQuery{
+							DomainQuery: &instance_v2beta.DomainsQuery{
+								Domains: []string{"domain1.com", "domain2.com"},
+							},
+						},
+					},
+					{
+						Query: &instance_v2beta.Query_IdQuery{
+							IdQuery: &instance_v2beta.IdsQuery{
+								Ids: []string{"id1", "id2"},
+							},
+						},
+					},
+				},
+			},
+			want: &instance_v2.ListInstancesRequest{
+				Pagination: &filter_v2.PaginationRequest{
+					Offset: 10,
+					Limit:  20,
+					Asc:    true,
+				},
+				SortingColumn: instance_v2.FieldName_FIELD_NAME_NAME,
+				Filters: []*instance_v2.Filter{
+					{
+						Filter: &instance_v2.Filter_CustomDomainsFilter{
+							CustomDomainsFilter: &instance_v2.CustomDomainsFilter{
+								Domains: []string{"domain1.com", "domain2.com"},
+							},
+						},
+					},
+					{
+						Filter: &instance_v2.Filter_InIdsFilter{
+							InIdsFilter: &filter_v2.InIDsFilter{
+								Ids: []string{"id1", "id2"},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			name: "request with different sorting field",
+			request: &instance_v2beta.ListInstancesRequest{
+				Pagination:    &filter_v2beta.PaginationRequest{},
+				SortingColumn: gu.Ptr(instance_v2beta.FieldName_FIELD_NAME_CREATION_DATE),
+			},
+			want: &instance_v2.ListInstancesRequest{
+				Pagination:    &filter_v2.PaginationRequest{},
+				SortingColumn: instance_v2.FieldName_FIELD_NAME_CREATION_DATE,
+				Filters:       []*instance_v2.Filter{},
+			},
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			got := ListInstancesBetaRequestToV2Request(tc.request)
+			assert.Equal(t, tc.want, got)
+		})
+	}
+}
+
+func TestListInstancesBetaSortingColToV2Request(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name      string
+		fieldName *instance_v2beta.FieldName
+		want      instance_v2.FieldName
+	}{
+		{
+			name:      "nil field name",
+			fieldName: nil,
+			want:      instance_v2.FieldName_FIELD_NAME_UNSPECIFIED,
+		},
+		{
+			name:      "creation date field",
+			fieldName: gu.Ptr(instance_v2beta.FieldName_FIELD_NAME_CREATION_DATE),
+			want:      instance_v2.FieldName_FIELD_NAME_CREATION_DATE,
+		},
+		{
+			name:      "id field",
+			fieldName: gu.Ptr(instance_v2beta.FieldName_FIELD_NAME_ID),
+			want:      instance_v2.FieldName_FIELD_NAME_ID,
+		},
+		{
+			name:      "name field",
+			fieldName: gu.Ptr(instance_v2beta.FieldName_FIELD_NAME_NAME),
+			want:      instance_v2.FieldName_FIELD_NAME_NAME,
+		},
+		{
+			name:      "unspecified field",
+			fieldName: gu.Ptr(instance_v2beta.FieldName_FIELD_NAME_UNSPECIFIED),
+			want:      instance_v2.FieldName_FIELD_NAME_UNSPECIFIED,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			got := listInstancesBetaSortingColToV2Request(tt.fieldName)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

backend/v3/api/instance/v2/domain.go

@@ -0,0 +1,287 @@
+package instancev2
+
+import (
+	"context"
+
+	"connectrpc.com/connect"
+	"google.golang.org/protobuf/types/known/timestamppb"
+
+	"github.com/zitadel/zitadel/backend/v3/api/instance/v2/convert"
+	"github.com/zitadel/zitadel/backend/v3/domain"
+	"github.com/zitadel/zitadel/backend/v3/storage/database/repository"
+	"github.com/zitadel/zitadel/internal/api/authz"
+	filter_v2 "github.com/zitadel/zitadel/pkg/grpc/filter/v2"
+	filter_v2beta "github.com/zitadel/zitadel/pkg/grpc/filter/v2beta"
+	instance_v2 "github.com/zitadel/zitadel/pkg/grpc/instance/v2"
+	instance_v2beta "github.com/zitadel/zitadel/pkg/grpc/instance/v2beta"
+)
+
+// =================
+// v2Beta endpoints
+// =================
+
+func AddCustomDomainBeta(ctx context.Context, request *connect.Request[instance_v2beta.AddCustomDomainRequest]) (*connect.Response[instance_v2beta.AddCustomDomainResponse], error) {
+	addCustomDomainCmd := domain.NewAddInstanceDomainCommand(request.Msg.GetInstanceId(), request.Msg.GetDomain(), domain.DomainTypeCustom)
+	oidcConfigUpdateCmd := domain.NewOIDCConfigurationUpdate(request.Msg.GetDomain(), authz.GetInstance(ctx).ProjectID(), authz.GetInstance(ctx).ConsoleApplicationID())
+
+	batchExec := domain.BatchExecutors(
+		addCustomDomainCmd,
+		oidcConfigUpdateCmd,
+	)
+
+	err := domain.Invoke(
+		ctx,
+		batchExec,
+		domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()),
+		// domain.WithOIDCConfigurationRepo(repository.OIDCConfigurationRepository()),
+	)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &connect.Response[instance_v2beta.AddCustomDomainResponse]{
+		Msg: &instance_v2beta.AddCustomDomainResponse{
+			// TODO(IAM-Marco): Return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10881
+			CreationDate: timestamppb.Now(),
+		},
+	}, nil
+}
+
+func RemoveCustomDomainBeta(ctx context.Context, request *connect.Request[instance_v2beta.RemoveCustomDomainRequest]) (*connect.Response[instance_v2beta.RemoveCustomDomainResponse], error) {
+	removeCustomDomainCmd := domain.NewRemoveInstanceDomainCommand(request.Msg.GetInstanceId(), request.Msg.GetDomain(), domain.DomainTypeCustom)
+
+	err := domain.Invoke(ctx, removeCustomDomainCmd, domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()))
+	if err != nil {
+		return nil, err
+	}
+
+	var deletionDate *timestamppb.Timestamp
+	if removeCustomDomainCmd.DeleteTime != nil {
+		deletionDate = timestamppb.New(*removeCustomDomainCmd.DeleteTime)
+	}
+	return &connect.Response[instance_v2beta.RemoveCustomDomainResponse]{
+		Msg: &instance_v2beta.RemoveCustomDomainResponse{
+			// TODO(IAM-Marco): Return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10881
+			DeletionDate: deletionDate,
+		},
+	}, nil
+}
+
+func ListCustomDomainsBeta(ctx context.Context, request *connect.Request[instance_v2beta.ListCustomDomainsRequest]) (*connect.Response[instance_v2beta.ListCustomDomainsResponse], error) {
+	listCustomDomainsQuery := domain.NewListInstanceDomainsQuery(convert.ListCustomDomainsBetaRequestToV2Request(request.Msg))
+
+	err := domain.Invoke(ctx, listCustomDomainsQuery, domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()))
+	if err != nil {
+		return nil, err
+	}
+
+	customDomains := listCustomDomainsQuery.Result()
+	return &connect.Response[instance_v2beta.ListCustomDomainsResponse]{
+		Msg: &instance_v2beta.ListCustomDomainsResponse{
+			Domains: convert.DomainInstanceDomainListModelToGRPCBetaResponse(customDomains),
+			Pagination: &filter_v2beta.PaginationResponse{
+				// TODO(IAM-Marco): return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10955
+				TotalResult:  uint64(len(customDomains)),
+				AppliedLimit: uint64(request.Msg.GetPagination().GetLimit()),
+			},
+		},
+	}, nil
+}
+
+func AddTrustedDomainBeta(ctx context.Context, request *connect.Request[instance_v2beta.AddTrustedDomainRequest]) (*connect.Response[instance_v2beta.AddTrustedDomainResponse], error) {
+	addTrustedDomainCmd := domain.NewAddInstanceDomainCommand(request.Msg.GetInstanceId(), request.Msg.GetDomain(), domain.DomainTypeTrusted)
+
+	err := domain.Invoke(
+		ctx,
+		addTrustedDomainCmd,
+		domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()),
+	)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &connect.Response[instance_v2beta.AddTrustedDomainResponse]{
+		Msg: &instance_v2beta.AddTrustedDomainResponse{
+			// TODO(IAM-Marco): Return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10881
+			CreationDate: timestamppb.Now(),
+		},
+	}, nil
+}
+
+func RemoveTrustedDomainBeta(ctx context.Context, request *connect.Request[instance_v2beta.RemoveTrustedDomainRequest]) (*connect.Response[instance_v2beta.RemoveTrustedDomainResponse], error) {
+	removeTrustedDomainCmd := domain.NewRemoveInstanceDomainCommand(request.Msg.GetInstanceId(), request.Msg.GetDomain(), domain.DomainTypeTrusted)
+
+	err := domain.Invoke(ctx, removeTrustedDomainCmd, domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()))
+	if err != nil {
+		return nil, err
+	}
+
+	var deletionDate *timestamppb.Timestamp
+	if removeTrustedDomainCmd.DeleteTime != nil {
+		deletionDate = timestamppb.New(*removeTrustedDomainCmd.DeleteTime)
+	}
+	return &connect.Response[instance_v2beta.RemoveTrustedDomainResponse]{
+		Msg: &instance_v2beta.RemoveTrustedDomainResponse{
+			// TODO(IAM-Marco): Return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10881
+			DeletionDate: deletionDate,
+		},
+	}, nil
+}
+
+func ListTrustedDomainsBeta(ctx context.Context, request *connect.Request[instance_v2beta.ListTrustedDomainsRequest]) (*connect.Response[instance_v2beta.ListTrustedDomainsResponse], error) {
+	listTrustedDomainsQuery := domain.NewListInstanceTrustedDomainsQuery(convert.ListTrustedDomainsBetaRequestToV2Request(request.Msg))
+
+	err := domain.Invoke(ctx, listTrustedDomainsQuery, domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()))
+	if err != nil {
+		return nil, err
+	}
+
+	trustedDomains := listTrustedDomainsQuery.Result()
+	return &connect.Response[instance_v2beta.ListTrustedDomainsResponse]{
+		Msg: &instance_v2beta.ListTrustedDomainsResponse{
+			TrustedDomain: convert.TrustedDomainInstanceDomainListModelToGRPCBetaResponse(trustedDomains),
+			Pagination: &filter_v2beta.PaginationResponse{
+				// TODO(IAM-Marco): return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10955
+				TotalResult:  uint64(len(trustedDomains)),
+				AppliedLimit: uint64(request.Msg.GetPagination().GetLimit()),
+			},
+		},
+	}, nil
+}
+
+// =================
+// v2 endpoints
+// =================
+
+func AddCustomDomain(ctx context.Context, request *connect.Request[instance_v2.AddCustomDomainRequest]) (*connect.Response[instance_v2.AddCustomDomainResponse], error) {
+	addCustomDomainCmd := domain.NewAddInstanceDomainCommand(request.Msg.GetInstanceId(), request.Msg.GetCustomDomain(), domain.DomainTypeCustom)
+	oidcConfigUpdateCmd := domain.NewOIDCConfigurationUpdate(request.Msg.GetCustomDomain(), authz.GetInstance(ctx).ProjectID(), authz.GetInstance(ctx).ConsoleApplicationID())
+
+	batchExec := domain.BatchExecutors(
+		addCustomDomainCmd,
+		oidcConfigUpdateCmd,
+	)
+
+	err := domain.Invoke(
+		ctx,
+		batchExec,
+		domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()),
+		// domain.WithOIDCConfigurationRepo(repository.OIDCConfigurationRepository()),
+	)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &connect.Response[instance_v2.AddCustomDomainResponse]{
+		Msg: &instance_v2.AddCustomDomainResponse{
+			// TODO(IAM-Marco): Return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10881
+			CreationDate: timestamppb.Now(),
+		},
+	}, nil
+}
+
+func RemoveCustomDomain(ctx context.Context, request *connect.Request[instance_v2.RemoveCustomDomainRequest]) (*connect.Response[instance_v2.RemoveCustomDomainResponse], error) {
+	removeCustomDomainCmd := domain.NewRemoveInstanceDomainCommand(request.Msg.GetInstanceId(), request.Msg.GetCustomDomain(), domain.DomainTypeCustom)
+
+	err := domain.Invoke(ctx, removeCustomDomainCmd, domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()))
+	if err != nil {
+		return nil, err
+	}
+
+	var deletionDate *timestamppb.Timestamp
+	if removeCustomDomainCmd.DeleteTime != nil {
+		deletionDate = timestamppb.New(*removeCustomDomainCmd.DeleteTime)
+	}
+	return &connect.Response[instance_v2.RemoveCustomDomainResponse]{
+		Msg: &instance_v2.RemoveCustomDomainResponse{
+			// TODO(IAM-Marco): Return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10881
+			DeletionDate: deletionDate,
+		},
+	}, nil
+}
+
+func ListCustomDomains(ctx context.Context, request *connect.Request[instance_v2.ListCustomDomainsRequest]) (*connect.Response[instance_v2.ListCustomDomainsResponse], error) {
+	listCustomDomainsQuery := domain.NewListInstanceDomainsQuery(request.Msg)
+
+	err := domain.Invoke(ctx, listCustomDomainsQuery, domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()))
+	if err != nil {
+		return nil, err
+	}
+
+	customDomains := listCustomDomainsQuery.Result()
+	return &connect.Response[instance_v2.ListCustomDomainsResponse]{
+		Msg: &instance_v2.ListCustomDomainsResponse{
+			Domains: convert.DomainInstanceDomainListModelToGRPCResponse(customDomains),
+			Pagination: &filter_v2.PaginationResponse{
+				// TODO(IAM-Marco): return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10955
+				TotalResult:  uint64(len(customDomains)),
+				AppliedLimit: uint64(request.Msg.GetPagination().GetLimit()),
+			},
+		},
+	}, nil
+}
+
+func AddTrustedDomain(ctx context.Context, request *connect.Request[instance_v2.AddTrustedDomainRequest]) (*connect.Response[instance_v2.AddTrustedDomainResponse], error) {
+	addTrustedDomainCmd := domain.NewAddInstanceDomainCommand(request.Msg.GetInstanceId(), request.Msg.GetTrustedDomain(), domain.DomainTypeTrusted)
+
+	err := domain.Invoke(
+		ctx,
+		addTrustedDomainCmd,
+		domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()),
+	)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &connect.Response[instance_v2.AddTrustedDomainResponse]{
+		Msg: &instance_v2.AddTrustedDomainResponse{
+			// TODO(IAM-Marco): Return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10881
+			CreationDate: timestamppb.Now(),
+		},
+	}, nil
+}
+
+func RemoveTrustedDomain(ctx context.Context, request *connect.Request[instance_v2.RemoveTrustedDomainRequest]) (*connect.Response[instance_v2.RemoveTrustedDomainResponse], error) {
+	removeTrustedDomainCmd := domain.NewRemoveInstanceDomainCommand(request.Msg.GetInstanceId(), request.Msg.GetTrustedDomain(), domain.DomainTypeTrusted)
+
+	err := domain.Invoke(ctx, removeTrustedDomainCmd, domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()))
+	if err != nil {
+		return nil, err
+	}
+
+	var deletionDate *timestamppb.Timestamp
+	if removeTrustedDomainCmd.DeleteTime != nil {
+		deletionDate = timestamppb.New(*removeTrustedDomainCmd.DeleteTime)
+	}
+	return &connect.Response[instance_v2.RemoveTrustedDomainResponse]{
+		Msg: &instance_v2.RemoveTrustedDomainResponse{
+			// TODO(IAM-Marco): Return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10881
+			DeletionDate: deletionDate,
+		},
+	}, nil
+}
+
+func ListTrustedDomains(ctx context.Context, request *connect.Request[instance_v2.ListTrustedDomainsRequest]) (*connect.Response[instance_v2.ListTrustedDomainsResponse], error) {
+	listTrustedDomainsQuery := domain.NewListInstanceTrustedDomainsQuery(request.Msg)
+
+	err := domain.Invoke(ctx, listTrustedDomainsQuery, domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()))
+	if err != nil {
+		return nil, err
+	}
+
+	trustedDomains := listTrustedDomainsQuery.Result()
+	return &connect.Response[instance_v2.ListTrustedDomainsResponse]{
+		Msg: &instance_v2.ListTrustedDomainsResponse{
+			TrustedDomain: convert.TrustedDomainInstanceDomainListModelToGRPCResponse(trustedDomains),
+			Pagination: &filter_v2.PaginationResponse{
+				// TODO(IAM-Marco): return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10955
+				TotalResult:  uint64(len(trustedDomains)),
+				AppliedLimit: uint64(request.Msg.GetPagination().GetLimit()),
+			},
+		},
+	}, nil
+}

backend/v3/api/instance/v2/instance.go

@@ -2,61 +2,62 @@ package instancev2
 
 import (
 	"context"
-	"errors"
 
 	"connectrpc.com/connect"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
 	"github.com/zitadel/zitadel/backend/v3/api/instance/v2/convert"
 	"github.com/zitadel/zitadel/backend/v3/domain"
-	"github.com/zitadel/zitadel/backend/v3/storage/database"
 	"github.com/zitadel/zitadel/backend/v3/storage/database/repository"
-	"github.com/zitadel/zitadel/internal/zerrors"
-	filter "github.com/zitadel/zitadel/pkg/grpc/filter/v2beta"
-	instance "github.com/zitadel/zitadel/pkg/grpc/instance/v2beta"
+	filter_v2 "github.com/zitadel/zitadel/pkg/grpc/filter/v2"
+	filter_v2beta "github.com/zitadel/zitadel/pkg/grpc/filter/v2beta"
+	instance_v2 "github.com/zitadel/zitadel/pkg/grpc/instance/v2"
+	instance_v2beta "github.com/zitadel/zitadel/pkg/grpc/instance/v2beta"
 )
 
-func DeleteInstance(ctx context.Context, request *connect.Request[instance.DeleteInstanceRequest]) (*connect.Response[instance.DeleteInstanceResponse], error) {
+// =================
+// v2Beta endpoints
+// =================
+
+func DeleteInstanceBeta(ctx context.Context, request *connect.Request[instance_v2beta.DeleteInstanceRequest]) (*connect.Response[instance_v2beta.DeleteInstanceResponse], error) {
 	instanceDeleteCmd := domain.NewDeleteInstanceCommand(request.Msg.GetInstanceId())
 
 	err := domain.Invoke(ctx, instanceDeleteCmd, domain.WithInstanceRepo(repository.InstanceRepository()))
 
 	if err != nil {
-		if errors.Is(err, &database.NoRowFoundError{}) {
-			return nil, zerrors.ThrowNotFound(err, "INST-QVrUwc", "instance not found")
-		}
 		return nil, err
 	}
 
-	return &connect.Response[instance.DeleteInstanceResponse]{
-		Msg: &instance.DeleteInstanceResponse{
+	var deletionDate *timestamppb.Timestamp
+	if instanceDeleteCmd.DeleteTime != nil {
+		deletionDate = timestamppb.New(*instanceDeleteCmd.DeleteTime)
+	}
+	return &connect.Response[instance_v2beta.DeleteInstanceResponse]{
+		Msg: &instance_v2beta.DeleteInstanceResponse{
 			// TODO(IAM-Marco): Change this with the real update date when OrganizationRepo.Update()
 			// returns the timestamp
-			DeletionDate: timestamppb.Now(),
+			DeletionDate: deletionDate,
 		},
 	}, nil
 }
 
-func GetInstance(ctx context.Context, request *connect.Request[instance.GetInstanceRequest]) (*connect.Response[instance.GetInstanceResponse], error) {
+func GetInstanceBeta(ctx context.Context, request *connect.Request[instance_v2beta.GetInstanceRequest]) (*connect.Response[instance_v2beta.GetInstanceResponse], error) {
 	instanceGetCmd := domain.NewGetInstanceCommand(request.Msg.GetInstanceId())
 
 	err := domain.Invoke(ctx, instanceGetCmd, domain.WithInstanceRepo(repository.InstanceRepository()))
 
 	if err != nil {
-		if errors.Is(err, &database.NoRowFoundError{}) {
-			return nil, zerrors.ThrowNotFound(err, "INST-QVrUwc", "instance not found")
-		}
 		return nil, err
 	}
 
-	return &connect.Response[instance.GetInstanceResponse]{
-		Msg: &instance.GetInstanceResponse{
-			Instance: convert.DomainInstanceModelToGRPCResponse(instanceGetCmd.Result()),
+	return &connect.Response[instance_v2beta.GetInstanceResponse]{
+		Msg: &instance_v2beta.GetInstanceResponse{
+			Instance: convert.DomainInstanceModelToGRPCBetaResponse(instanceGetCmd.Result()),
 		},
 	}, nil
 }
 
-func UpdateInstance(ctx context.Context, request *connect.Request[instance.UpdateInstanceRequest]) (*connect.Response[instance.UpdateInstanceResponse], error) {
+func UpdateInstanceBeta(ctx context.Context, request *connect.Request[instance_v2beta.UpdateInstanceRequest]) (*connect.Response[instance_v2beta.UpdateInstanceResponse], error) {
 	instanceUpdateCmd := domain.NewUpdateInstanceCommand(request.Msg.GetInstanceId(), request.Msg.GetInstanceName())
 
 	err := domain.Invoke(ctx, instanceUpdateCmd, domain.WithInstanceRepo(repository.InstanceRepository()))
@@ -65,8 +66,8 @@ func UpdateInstance(ctx context.Context, request *connect.Request[instance.Updat
 		return nil, err
 	}
 
-	return &connect.Response[instance.UpdateInstanceResponse]{
-		Msg: &instance.UpdateInstanceResponse{
+	return &connect.Response[instance_v2beta.UpdateInstanceResponse]{
+		Msg: &instance_v2beta.UpdateInstanceResponse{
 			// TODO(IAM-Marco): Change this with the real update date when InstanceRepo.Update()
 			// returns the timestamp
 			ChangeDate: timestamppb.Now(),
@@ -74,7 +75,93 @@ func UpdateInstance(ctx context.Context, request *connect.Request[instance.Updat
 	}, nil
 }
 
-func ListInstances(ctx context.Context, request *connect.Request[instance.ListInstancesRequest]) (*connect.Response[instance.ListInstancesResponse], error) {
+func ListInstancesBeta(ctx context.Context, request *connect.Request[instance_v2beta.ListInstancesRequest]) (*connect.Response[instance_v2beta.ListInstancesResponse], error) {
+	instancesListCmd := domain.NewListInstancesCommand(convert.ListInstancesBetaRequestToV2Request(request.Msg))
+
+	err := domain.Invoke(
+		ctx,
+		instancesListCmd,
+		domain.WithInstanceRepo(repository.InstanceRepository()),
+		domain.WithInstanceDomainRepo(repository.InstanceDomainRepository()),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	instances := instancesListCmd.Result()
+	return &connect.Response[instance_v2beta.ListInstancesResponse]{
+		Msg: &instance_v2beta.ListInstancesResponse{
+			Instances: convert.DomainInstanceListModelToGRPCBetaResponse(instances),
+			Pagination: &filter_v2beta.PaginationResponse{
+				// TODO(IAM-Marco): return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10955
+				TotalResult:  uint64(len(instances)),
+				AppliedLimit: uint64(request.Msg.GetPagination().GetLimit()),
+			},
+		},
+	}, nil
+}
+
+// =================
+// v2 endpoints
+// =================
+
+func DeleteInstance(ctx context.Context, request *connect.Request[instance_v2.DeleteInstanceRequest]) (*connect.Response[instance_v2.DeleteInstanceResponse], error) {
+	instanceDeleteCmd := domain.NewDeleteInstanceCommand(request.Msg.GetInstanceId())
+
+	err := domain.Invoke(ctx, instanceDeleteCmd, domain.WithInstanceRepo(repository.InstanceRepository()))
+
+	if err != nil {
+		return nil, err
+	}
+
+	var deletionDate *timestamppb.Timestamp
+	if instanceDeleteCmd.DeleteTime != nil {
+		deletionDate = timestamppb.New(*instanceDeleteCmd.DeleteTime)
+	}
+	return &connect.Response[instance_v2.DeleteInstanceResponse]{
+		Msg: &instance_v2.DeleteInstanceResponse{
+			// TODO(IAM-Marco): Change this with the real update date when OrganizationRepo.Update()
+			// returns the timestamp
+			DeletionDate: deletionDate,
+		},
+	}, nil
+}
+
+func GetInstance(ctx context.Context, request *connect.Request[instance_v2.GetInstanceRequest]) (*connect.Response[instance_v2.GetInstanceResponse], error) {
+	instanceGetCmd := domain.NewGetInstanceCommand(request.Msg.GetInstanceId())
+
+	err := domain.Invoke(ctx, instanceGetCmd, domain.WithInstanceRepo(repository.InstanceRepository()))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &connect.Response[instance_v2.GetInstanceResponse]{
+		Msg: &instance_v2.GetInstanceResponse{
+			Instance: convert.DomainInstanceModelToGRPCResponse(instanceGetCmd.Result()),
+		},
+	}, nil
+}
+
+func UpdateInstance(ctx context.Context, request *connect.Request[instance_v2.UpdateInstanceRequest]) (*connect.Response[instance_v2.UpdateInstanceResponse], error) {
+	instanceUpdateCmd := domain.NewUpdateInstanceCommand(request.Msg.GetInstanceId(), request.Msg.GetInstanceName())
+
+	err := domain.Invoke(ctx, instanceUpdateCmd, domain.WithInstanceRepo(repository.InstanceRepository()))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &connect.Response[instance_v2.UpdateInstanceResponse]{
+		Msg: &instance_v2.UpdateInstanceResponse{
+			// TODO(IAM-Marco): Change this with the real update date when InstanceRepo.Update()
+			// returns the timestamp
+			ChangeDate: timestamppb.Now(),
+		},
+	}, nil
+}
+
+func ListInstances(ctx context.Context, request *connect.Request[instance_v2.ListInstancesRequest]) (*connect.Response[instance_v2.ListInstancesResponse], error) {
 	instancesListCmd := domain.NewListInstancesCommand(request.Msg)
 
 	err := domain.Invoke(
@@ -88,10 +175,10 @@ func ListInstances(ctx context.Context, request *connect.Request[instance.ListIn
 	}
 
 	instances := instancesListCmd.Result()
-	return &connect.Response[instance.ListInstancesResponse]{
-		Msg: &instance.ListInstancesResponse{
+	return &connect.Response[instance_v2.ListInstancesResponse]{
+		Msg: &instance_v2.ListInstancesResponse{
 			Instances: convert.DomainInstanceListModelToGRPCResponse(instances),
-			Pagination: &filter.PaginationResponse{
+			Pagination: &filter_v2.PaginationResponse{
 				// TODO(IAM-Marco): return correct value. Tracked in https://github.com/zitadel/zitadel/issues/10955
 				TotalResult:  uint64(len(instances)),
 				AppliedLimit: uint64(request.Msg.GetPagination().GetLimit()),