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]>
This commit is contained in:
Marco A.
2025-12-17 12:01:09 +01:00
committed by GitHub
co-authored by Elio Bischof Lebogang Phoshoko Wim Van Laer Max Peintner Gayathri Vijayan
parent d79bfe6eba
commit b339a3e696
49 changed files with 5670 additions and 1466 deletions
@@ -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
}
@@ -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)
})
}
}
+92 -24
View File
@@ -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
}
}
@@ -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)
})
}
}