zitadel/internal/query/org_domain.go
Livio Amstutz 56b916a2b0
feat: projections auto create their tables (#3324)
* begin init checks for projections

* first projection checks

* debug notification providers with query fixes

* more projections and first index

* more projections

* more projections

* finish projections

* fix tests (remove db name)

* create tables in setup

* fix logging / error handling

* add tenant to views

* rename tenant to instance_id

* add instance_id to all projections

* add instance_id to all queries

* correct instance_id on projections

* add instance_id to failed_events

* use separate context for instance

* implement features projection

* implement features projection

* remove unique constraint from setup when migration failed

* add error to failed setup event

* add instance_id to primary keys

* fix IAM projection

* remove old migrations folder

* fix keysFromYAML test
2022-03-23 09:02:39 +01:00

168 lines
4.2 KiB
Go

package query
import (
"context"
"database/sql"
"time"
sq "github.com/Masterminds/squirrel"
"github.com/caos/zitadel/internal/api/authz"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/query/projection"
)
type Domain struct {
CreationDate time.Time
ChangeDate time.Time
Sequence uint64
Domain string
OrgID string
IsVerified bool
IsPrimary bool
ValidationType domain.OrgDomainValidationType
}
type Domains struct {
SearchResponse
Domains []*Domain
}
type OrgDomainSearchQueries struct {
SearchRequest
Queries []SearchQuery
}
func (q *OrgDomainSearchQueries) toQuery(query sq.SelectBuilder) sq.SelectBuilder {
query = q.SearchRequest.toQuery(query)
for _, q := range q.Queries {
query = q.toQuery(query)
}
return query
}
func NewOrgDomainDomainSearchQuery(method TextComparison, value string) (SearchQuery, error) {
return NewTextQuery(OrgDomainDomainCol, value, method)
}
func NewOrgDomainOrgIDSearchQuery(value string) (SearchQuery, error) {
return NewTextQuery(OrgDomainOrgIDCol, value, TextEquals)
}
func NewOrgDomainVerifiedSearchQuery(verified bool) (SearchQuery, error) {
return NewBoolQuery(OrgDomainIsVerifiedCol, verified)
}
func (q *Queries) SearchOrgDomains(ctx context.Context, queries *OrgDomainSearchQueries) (domains *Domains, err error) {
query, scan := prepareDomainsQuery()
stmt, args, err := queries.toQuery(query).
Where(sq.Eq{
OrgDomainInstanceIDCol.identifier(): authz.GetInstance(ctx).ID,
}).ToSql()
if err != nil {
return nil, errors.ThrowInvalidArgument(err, "QUERY-ZRfj1", "Errors.Query.SQLStatement")
}
rows, err := q.client.QueryContext(ctx, stmt, args...)
if err != nil {
return nil, errors.ThrowInternal(err, "QUERY-M6mYN", "Errors.Internal")
}
domains, err = scan(rows)
if err != nil {
return nil, err
}
domains.LatestSequence, err = q.latestSequence(ctx, orgDomainsTable)
return domains, err
}
func prepareDomainsQuery() (sq.SelectBuilder, func(*sql.Rows) (*Domains, error)) {
return sq.Select(
OrgDomainCreationDateCol.identifier(),
OrgDomainChangeDateCol.identifier(),
OrgDomainSequenceCol.identifier(),
OrgDomainDomainCol.identifier(),
OrgDomainOrgIDCol.identifier(),
OrgDomainIsVerifiedCol.identifier(),
OrgDomainIsPrimaryCol.identifier(),
OrgDomainValidationTypeCol.identifier(),
countColumn.identifier(),
).From(orgDomainsTable.identifier()).PlaceholderFormat(sq.Dollar),
func(rows *sql.Rows) (*Domains, error) {
domains := make([]*Domain, 0)
var count uint64
for rows.Next() {
domain := new(Domain)
err := rows.Scan(
&domain.CreationDate,
&domain.ChangeDate,
&domain.Sequence,
&domain.Domain,
&domain.OrgID,
&domain.IsVerified,
&domain.IsPrimary,
&domain.ValidationType,
&count,
)
if err != nil {
return nil, err
}
domains = append(domains, domain)
}
if err := rows.Close(); err != nil {
return nil, errors.ThrowInternal(err, "QUERY-rKd6k", "Errors.Query.CloseRows")
}
return &Domains{
Domains: domains,
SearchResponse: SearchResponse{
Count: count,
},
}, nil
}
}
var (
orgDomainsTable = table{
name: projection.OrgDomainTable,
}
OrgDomainCreationDateCol = Column{
name: projection.OrgDomainCreationDateCol,
table: orgDomainsTable,
}
OrgDomainChangeDateCol = Column{
name: projection.OrgDomainChangeDateCol,
table: orgDomainsTable,
}
OrgDomainSequenceCol = Column{
name: projection.OrgDomainSequenceCol,
table: orgDomainsTable,
}
OrgDomainDomainCol = Column{
name: projection.OrgDomainDomainCol,
table: orgDomainsTable,
}
OrgDomainOrgIDCol = Column{
name: projection.OrgDomainOrgIDCol,
table: orgDomainsTable,
}
OrgDomainInstanceIDCol = Column{
name: projection.OrgDomainInstanceIDCol,
table: orgDomainsTable,
}
OrgDomainIsVerifiedCol = Column{
name: projection.OrgDomainIsVerifiedCol,
table: orgDomainsTable,
}
OrgDomainIsPrimaryCol = Column{
name: projection.OrgDomainIsPrimaryCol,
table: orgDomainsTable,
}
OrgDomainValidationTypeCol = Column{
name: projection.OrgDomainValidationTypeCol,
table: orgDomainsTable,
}
)