feat: multiple domains (#188)

* check uniqueness on create and register user

* change user email, reserve release unique email

* usergrant unique aggregate

* usergrant uniqueness

* validate UserGrant

* fix tests

* domain is set on username in all orgs

* domain in admin

* org domain sql

* zitadel domain org name

* org domains

* org iam policy

* default org iam policy

* SETUP

* load login names

* login by login name

* login name

* fix: merge master

* fix: merge master

* Update internal/user/repository/eventsourcing/user.go

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

* fix: fix unique domains

* fix: rename env variable

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

internal/org/repository/view/model/org.go

@@ -0,0 +1,99 @@
+package model
+
+import (
+	"encoding/json"
+	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
+	"time"
+
+	"github.com/caos/logging"
+	"github.com/caos/zitadel/internal/errors"
+	es_models "github.com/caos/zitadel/internal/eventstore/models"
+	org_model "github.com/caos/zitadel/internal/org/model"
+)
+
+const (
+	OrgKeyOrgDomain     = "domain"
+	OrgKeyOrgID         = "id"
+	OrgKeyOrgName       = "name"
+	OrgKeyResourceOwner = "resource_owner"
+	OrgKeyState         = "org_state"
+)
+
+type OrgView struct {
+	ID            string    `json:"-" gorm:"column:id;primary_key"`
+	CreationDate  time.Time `json:"-" gorm:"column:creation_date"`
+	ChangeDate    time.Time `json:"-" gorm:"column:change_date"`
+	ResourceOwner string    `json:"-" gorm:"column:resource_owner"`
+	State         int32     `json:"-" gorm:"column:org_state"`
+	Sequence      uint64    `json:"-" gorm:"column:sequence"`
+
+	Name   string `json:"name" gorm:"column:name"`
+	Domain string `json:"domain" gorm:"column:domain"`
+}
+
+func OrgFromModel(org *org_model.OrgView) *OrgView {
+	return &OrgView{
+		ChangeDate:    org.ChangeDate,
+		CreationDate:  org.CreationDate,
+		ID:            org.ID,
+		Name:          org.Name,
+		ResourceOwner: org.ResourceOwner,
+		Sequence:      org.Sequence,
+		State:         int32(org.State),
+	}
+}
+
+func OrgToModel(org *OrgView) *org_model.OrgView {
+	return &org_model.OrgView{
+		ChangeDate:    org.ChangeDate,
+		CreationDate:  org.CreationDate,
+		ID:            org.ID,
+		Name:          org.Name,
+		ResourceOwner: org.ResourceOwner,
+		Sequence:      org.Sequence,
+		State:         org_model.OrgState(org.State),
+	}
+}
+
+func OrgsToModel(orgs []*OrgView) []*org_model.OrgView {
+	modelOrgs := make([]*org_model.OrgView, len(orgs))
+
+	for i, org := range orgs {
+		modelOrgs[i] = OrgToModel(org)
+	}
+
+	return modelOrgs
+}
+
+func (o *OrgView) AppendEvent(event *es_models.Event) (err error) {
+	switch event.Type {
+	case model.OrgAdded:
+		o.CreationDate = event.CreationDate
+		o.State = int32(org_model.ORGSTATE_ACTIVE)
+		o.setRootData(event)
+		err = o.SetData(event)
+	case model.OrgChanged:
+		o.setRootData(event)
+		err = o.SetData(event)
+	case model.OrgDeactivated:
+		o.State = int32(org_model.ORGSTATE_INACTIVE)
+	case model.OrgReactivated:
+		o.State = int32(org_model.ORGSTATE_ACTIVE)
+	}
+	return err
+}
+
+func (o *OrgView) setRootData(event *es_models.Event) {
+	o.ChangeDate = event.CreationDate
+	o.Sequence = event.Sequence
+	o.ID = event.AggregateID
+	o.ResourceOwner = event.ResourceOwner
+}
+
+func (o *OrgView) SetData(event *es_models.Event) error {
+	if err := json.Unmarshal(event.Data, o); err != nil {
+		logging.Log("VIEW-5W7Op").WithError(err).Error("could not unmarshal event data")
+		return errors.ThrowInternal(err, "VIEW-HZKME", "Could not unmarshal data")
+	}
+	return nil
+}

internal/org/repository/view/model/org_domain.go

@@ -0,0 +1,87 @@
+package model
+
+import (
+	"encoding/json"
+	"github.com/caos/logging"
+	caos_errs "github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/org/model"
+	es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
+	"time"
+)
+
+const (
+	OrgDomainKeyOrgID    = "org_id"
+	OrgDomainKeyDomain   = "domain"
+	OrgDomainKeyVerified = "verified"
+	OrgDomainKeyPrimary  = "primary_domain"
+)
+
+type OrgDomainView struct {
+	Domain   string `json:"domain" gorm:"column:domain;primary_key"`
+	OrgID    string `json:"-" gorm:"column:org_id;primary_key"`
+	Verified bool   `json:"-" gorm:"column:verified"`
+	Primary  bool   `json:"-" gorm:"column:primary_domain"`
+	Sequence uint64 `json:"-" gorm:"column:sequence"`
+
+	CreationDate time.Time `json:"-" gorm:"column:creation_date"`
+	ChangeDate   time.Time `json:"-" gorm:"column:change_date"`
+}
+
+func OrgDomainViewFromModel(domain *model.OrgDomainView) *OrgDomainView {
+	return &OrgDomainView{
+		OrgID:        domain.OrgID,
+		Domain:       domain.Domain,
+		Primary:      domain.Primary,
+		Verified:     domain.Verified,
+		CreationDate: domain.CreationDate,
+		ChangeDate:   domain.ChangeDate,
+	}
+}
+
+func OrgDomainToModel(domain *OrgDomainView) *model.OrgDomainView {
+	return &model.OrgDomainView{
+		OrgID:        domain.OrgID,
+		Domain:       domain.Domain,
+		Primary:      domain.Primary,
+		Verified:     domain.Verified,
+		CreationDate: domain.CreationDate,
+		ChangeDate:   domain.ChangeDate,
+	}
+}
+
+func OrgDomainsToModel(domain []*OrgDomainView) []*model.OrgDomainView {
+	result := make([]*model.OrgDomainView, len(domain))
+	for i, r := range domain {
+		result[i] = OrgDomainToModel(r)
+	}
+	return result
+}
+
+func (d *OrgDomainView) AppendEvent(event *models.Event) (err error) {
+	d.Sequence = event.Sequence
+	d.ChangeDate = event.CreationDate
+	switch event.Type {
+	case es_model.OrgDomainAdded:
+		d.setRootData(event)
+		d.CreationDate = event.CreationDate
+		err = d.SetData(event)
+	case es_model.OrgDomainVerified:
+		d.Verified = true
+	case es_model.OrgDomainPrimarySet:
+		d.Primary = true
+	}
+	return err
+}
+
+func (r *OrgDomainView) setRootData(event *models.Event) {
+	r.OrgID = event.AggregateID
+}
+
+func (r *OrgDomainView) SetData(event *models.Event) error {
+	if err := json.Unmarshal(event.Data, r); err != nil {
+		logging.Log("EVEN-sj4Sf").WithError(err).Error("could not unmarshal event data")
+		return caos_errs.ThrowInternal(err, "MODEL-lub6s", "Could not unmarshal data")
+	}
+	return nil
+}

internal/org/repository/view/model/org_domain_query.go

@@ -0,0 +1,65 @@
+package model
+
+import (
+	global_model "github.com/caos/zitadel/internal/model"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	"github.com/caos/zitadel/internal/view"
+)
+
+type OrgDomainSearchRequest org_model.OrgDomainSearchRequest
+type OrgDomainSearchQuery org_model.OrgDomainSearchQuery
+type OrgDomainSearchKey org_model.OrgDomainSearchKey
+
+func (req OrgDomainSearchRequest) GetLimit() uint64 {
+	return req.Limit
+}
+
+func (req OrgDomainSearchRequest) GetOffset() uint64 {
+	return req.Offset
+}
+
+func (req OrgDomainSearchRequest) GetSortingColumn() view.ColumnKey {
+	if req.SortingColumn == org_model.ORGDOMAINSEARCHKEY_UNSPECIFIED {
+		return nil
+	}
+	return OrgDomainSearchKey(req.SortingColumn)
+}
+
+func (req OrgDomainSearchRequest) GetAsc() bool {
+	return req.Asc
+}
+
+func (req OrgDomainSearchRequest) GetQueries() []view.SearchQuery {
+	result := make([]view.SearchQuery, len(req.Queries))
+	for i, q := range req.Queries {
+		result[i] = OrgDomainSearchQuery{Key: q.Key, Value: q.Value, Method: q.Method}
+	}
+	return result
+}
+
+func (req OrgDomainSearchQuery) GetKey() view.ColumnKey {
+	return OrgDomainSearchKey(req.Key)
+}
+
+func (req OrgDomainSearchQuery) GetMethod() global_model.SearchMethod {
+	return req.Method
+}
+
+func (req OrgDomainSearchQuery) GetValue() interface{} {
+	return req.Value
+}
+
+func (key OrgDomainSearchKey) ToColumnName() string {
+	switch org_model.OrgDomainSearchKey(key) {
+	case org_model.ORGDOMAINSEARCHKEY_DOMAIN:
+		return OrgDomainKeyDomain
+	case org_model.ORGDOMAINSEARCHKEY_ORG_ID:
+		return OrgDomainKeyOrgID
+	case org_model.ORGDOMAINSEARCHKEY_VERIFIED:
+		return OrgDomainKeyVerified
+	case org_model.ORGDOMAINSEARCHKEY_PRIMARY:
+		return OrgDomainKeyPrimary
+	default:
+		return ""
+	}
+}

internal/org/repository/view/model/org_member.go

@@ -0,0 +1,100 @@
+package model
+
+import (
+	"encoding/json"
+	es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
+	"time"
+
+	"github.com/caos/logging"
+	caos_errs "github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/models"
+	"github.com/caos/zitadel/internal/org/model"
+	"github.com/lib/pq"
+)
+
+const (
+	OrgMemberKeyUserID    = "user_id"
+	OrgMemberKeyOrgID     = "org_id"
+	OrgMemberKeyUserName  = "user_name"
+	OrgMemberKeyEmail     = "email"
+	OrgMemberKeyFirstName = "first_name"
+	OrgMemberKeyLastName  = "last_name"
+)
+
+type OrgMemberView struct {
+	UserID    string         `json:"userId" gorm:"column:user_id;primary_key"`
+	OrgID     string         `json:"-" gorm:"column:org_id;primary_key"`
+	UserName  string         `json:"-" gorm:"column:user_name"`
+	Email     string         `json:"-" gorm:"column:email_address"`
+	FirstName string         `json:"-" gorm:"column:first_name"`
+	LastName  string         `json:"-" gorm:"column:last_name"`
+	Roles     pq.StringArray `json:"roles" gorm:"column:roles"`
+	Sequence  uint64         `json:"-" gorm:"column:sequence"`
+
+	CreationDate time.Time `json:"-" gorm:"column:creation_date"`
+	ChangeDate   time.Time `json:"-" gorm:"column:change_date"`
+}
+
+func OrgMemberViewFromModel(member *model.OrgMemberView) *OrgMemberView {
+	return &OrgMemberView{
+		UserID:       member.UserID,
+		OrgID:        member.OrgID,
+		UserName:     member.UserName,
+		Email:        member.Email,
+		FirstName:    member.FirstName,
+		LastName:     member.LastName,
+		Roles:        member.Roles,
+		Sequence:     member.Sequence,
+		CreationDate: member.CreationDate,
+		ChangeDate:   member.ChangeDate,
+	}
+}
+
+func OrgMemberToModel(member *OrgMemberView) *model.OrgMemberView {
+	return &model.OrgMemberView{
+		UserID:       member.UserID,
+		OrgID:        member.OrgID,
+		UserName:     member.UserName,
+		Email:        member.Email,
+		FirstName:    member.FirstName,
+		LastName:     member.LastName,
+		Roles:        member.Roles,
+		Sequence:     member.Sequence,
+		CreationDate: member.CreationDate,
+		ChangeDate:   member.ChangeDate,
+	}
+}
+
+func OrgMembersToModel(roles []*OrgMemberView) []*model.OrgMemberView {
+	result := make([]*model.OrgMemberView, len(roles))
+	for i, r := range roles {
+		result[i] = OrgMemberToModel(r)
+	}
+	return result
+}
+
+func (r *OrgMemberView) AppendEvent(event *models.Event) (err error) {
+	r.Sequence = event.Sequence
+	r.ChangeDate = event.CreationDate
+	switch event.Type {
+	case es_model.OrgMemberAdded:
+		r.setRootData(event)
+		r.CreationDate = event.CreationDate
+		err = r.SetData(event)
+	case es_model.OrgMemberChanged:
+		err = r.SetData(event)
+	}
+	return err
+}
+
+func (r *OrgMemberView) setRootData(event *models.Event) {
+	r.OrgID = event.AggregateID
+}
+
+func (r *OrgMemberView) SetData(event *models.Event) error {
+	if err := json.Unmarshal(event.Data, r); err != nil {
+		logging.Log("EVEN-slo9s").WithError(err).Error("could not unmarshal event data")
+		return caos_errs.ThrowInternal(err, "MODEL-lub6s", "Could not unmarshal data")
+	}
+	return nil
+}

internal/org/repository/view/model/org_member_query.go

@@ -0,0 +1,69 @@
+package model
+
+import (
+	global_model "github.com/caos/zitadel/internal/model"
+	proj_model "github.com/caos/zitadel/internal/org/model"
+	"github.com/caos/zitadel/internal/view"
+)
+
+type OrgMemberSearchRequest proj_model.OrgMemberSearchRequest
+type OrgMemberSearchQuery proj_model.OrgMemberSearchQuery
+type OrgMemberSearchKey proj_model.OrgMemberSearchKey
+
+func (req OrgMemberSearchRequest) GetLimit() uint64 {
+	return req.Limit
+}
+
+func (req OrgMemberSearchRequest) GetOffset() uint64 {
+	return req.Offset
+}
+
+func (req OrgMemberSearchRequest) GetSortingColumn() view.ColumnKey {
+	if req.SortingColumn == proj_model.ORGMEMBERSEARCHKEY_UNSPECIFIED {
+		return nil
+	}
+	return OrgMemberSearchKey(req.SortingColumn)
+}
+
+func (req OrgMemberSearchRequest) GetAsc() bool {
+	return req.Asc
+}
+
+func (req OrgMemberSearchRequest) GetQueries() []view.SearchQuery {
+	result := make([]view.SearchQuery, len(req.Queries))
+	for i, q := range req.Queries {
+		result[i] = OrgMemberSearchQuery{Key: q.Key, Value: q.Value, Method: q.Method}
+	}
+	return result
+}
+
+func (req OrgMemberSearchQuery) GetKey() view.ColumnKey {
+	return OrgMemberSearchKey(req.Key)
+}
+
+func (req OrgMemberSearchQuery) GetMethod() global_model.SearchMethod {
+	return req.Method
+}
+
+func (req OrgMemberSearchQuery) GetValue() interface{} {
+	return req.Value
+}
+
+func (key OrgMemberSearchKey) ToColumnName() string {
+	switch proj_model.OrgMemberSearchKey(key) {
+	case proj_model.ORGMEMBERSEARCHKEY_EMAIL:
+		return OrgMemberKeyEmail
+	case proj_model.ORGMEMBERSEARCHKEY_FIRST_NAME:
+		return OrgMemberKeyFirstName
+	case proj_model.ORGMEMBERSEARCHKEY_LAST_NAME:
+		return OrgMemberKeyLastName
+	case proj_model.ORGMEMBERSEARCHKEY_USER_NAME:
+		return OrgMemberKeyUserName
+	case proj_model.ORGMEMBERSEARCHKEY_USER_ID:
+		return OrgMemberKeyUserID
+	case proj_model.ORGMEMBERSEARCHKEY_ORG_ID:
+		return OrgMemberKeyOrgID
+	default:
+		return ""
+	}
+}

internal/org/repository/view/model/org_query.go

@@ -0,0 +1,67 @@
+package model
+
+import (
+	global_model "github.com/caos/zitadel/internal/model"
+	usr_model "github.com/caos/zitadel/internal/org/model"
+	"github.com/caos/zitadel/internal/view"
+)
+
+type OrgSearchRequest usr_model.OrgSearchRequest
+type OrgSearchQuery usr_model.OrgSearchQuery
+type OrgSearchKey usr_model.OrgSearchKey
+
+func (req OrgSearchRequest) GetLimit() uint64 {
+	return req.Limit
+}
+
+func (req OrgSearchRequest) GetOffset() uint64 {
+	return req.Offset
+}
+
+func (req OrgSearchRequest) GetSortingColumn() view.ColumnKey {
+	if req.SortingColumn == usr_model.ORGSEARCHKEY_UNSPECIFIED {
+		return nil
+	}
+	return OrgSearchKey(req.SortingColumn)
+}
+
+func (req OrgSearchRequest) GetAsc() bool {
+	return req.Asc
+}
+
+func (req OrgSearchRequest) GetQueries() []view.SearchQuery {
+	result := make([]view.SearchQuery, len(req.Queries))
+	for i, q := range req.Queries {
+		result[i] = OrgSearchQuery{Key: q.Key, Value: q.Value, Method: q.Method}
+	}
+	return result
+}
+
+func (req OrgSearchQuery) GetKey() view.ColumnKey {
+	return OrgSearchKey(req.Key)
+}
+
+func (req OrgSearchQuery) GetMethod() global_model.SearchMethod {
+	return req.Method
+}
+
+func (req OrgSearchQuery) GetValue() interface{} {
+	return req.Value
+}
+
+func (key OrgSearchKey) ToColumnName() string {
+	switch usr_model.OrgSearchKey(key) {
+	case usr_model.ORGSEARCHKEY_ORG_DOMAIN:
+		return OrgKeyOrgDomain
+	case usr_model.ORGSEARCHKEY_ORG_ID:
+		return OrgKeyOrgID
+	case usr_model.ORGSEARCHKEY_ORG_NAME:
+		return OrgKeyOrgName
+	case usr_model.ORGSEARCHKEY_RESOURCEOWNER:
+		return OrgKeyResourceOwner
+	case usr_model.ORGSEARCHKEY_STATE:
+		return OrgKeyState
+	default:
+		return ""
+	}
+}