ores.iam.tenant

UUID uniquely identifying this tenant.

The system tenant has the maximum UUID value, ffffffff-ffff-ffff-ffff-ffffffffffff. A tenant row's own identity is this column and never tenant_id: the registry is the system tenant's, so the table's check requires every row, this one included, to carry the system tenant in tenant_id. A predicate that asks tenant_id which tenant a row describes therefore answers "the system tenant" for all of them.

Unique code for stable referencing. Its shape is the deployment's and not a form's: a lowercase letter first, then lowercase letters, digits and underscores, at most fifty characters. check_tenant_code states that to a caller as a sentence, and the table's check holds every other writer to it.

Examples: 'system', 'acme', 'demo'.

// no_generator_suffix: the "-<idx>" the template appends is not a shape this
// code may have, and the index starts again with every run, so a second run
// against the same database would ask for codes the first run's tenants hold.
// The index is joined with an underscore and followed by eight hex digits of
// a uuid, and the noun is lowercased because a faker noun can be an
// abbreviation such as "CD".
[idx]{
    std::string code(faker::word::noun());
    for (auto& character : code)
        if (character >= 'A' && character <= 'Z')
            character = static_cast<char>(character - 'A' + 'a');
    return code + "_tenant_" + std::to_string(idx) + "_" +
           std::string(faker::string::uuidV4()).substr(0, 8);
}()

Human-readable display name for the tenant.

std::string(faker::company::companyName())

Tenant type classification (FK to tenant_types). The synthetic generator emits the canonical automation type: the type/status insert validations reject any value with no active tenant_type row, and the seed data (iam_tenant_types_populate.sql) seeds the four system-tenant types, of which automation is the system-process default.

"automation"

Detailed description of the tenant.

std::string(faker::lorem::sentence())

Unique hostname for tenant routing.

// no_generator_suffix: the "-<idx>" the template appends is a process counter
// that starts again with every run, so a second run against the same database
// would ask for hostnames the first run's tenants hold. The hostname carries
// eight hex digits of a uuid instead.
std::string(faker::word::noun()) + "-" + std::string(faker::string::uuidV4()).substr(0, 8) +
    ".example.com"

Tenant lifecycle status (FK to tenant_statuses).

"active"

Whether self-registrations land in this tenant when the address they arrive at names no tenant. At most one live row may hold it, because two tenants flagged as the default is a question with no answer.

The flag belongs to the super administrator. The write policy on this table admits only the system tenant, and every tenant row carries the system tenant, so only a super administrator may write a tenant row at all. That is also why the default party and the default role are not columns here: a tenant administrator could not set them.

false

The code and the hostname are shapes the deployment states, and the table says so as well as the service that provisions a tenant: check_tenant_code and check_tenant_hostname refuse a request with a sentence a person can read, and these hold every other caller to the same rule. A code whose shape is only checked by one caller is a code the deployment does not really state; a hostname that states a port is a principal the login cannot resolve.