@sealkeeper/schema 0.4.4 → 0.4.6

package/dist/db/operator-identities.d.ts

@@ -0,0 +1,211 @@
+export declare const operatorIdentities: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "operator_identities";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "operator_identities";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "operator_identities";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "operator_identities";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        operatorId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "operator_id";
+            tableName: "operator_identities";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "operator_identities";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        provider: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider";
+            tableName: "operator_identities";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        subject: import("drizzle-orm/pg-core").PgColumn<{
+            name: "subject";
+            tableName: "operator_identities";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        subjectHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "subject_hash";
+            tableName: "operator_identities";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        token: import("drizzle-orm/pg-core").PgColumn<{
+            name: "token";
+            tableName: "operator_identities";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        verifiedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "verified_at";
+            tableName: "operator_identities";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastCheckedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_checked_at";
+            tableName: "operator_identities";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lapsedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "lapsed_at";
+            tableName: "operator_identities";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/db/operator-identities.js

@@ -0,0 +1,49 @@
+import { sql } from 'drizzle-orm';
+import { check, index, pgTable, text, timestamp, unique, uniqueIndex, uuid, } from 'drizzle-orm/pg-core';
+import { operators } from './operators.js';
+import { timestamps } from './timestamps.js';
+/*
+ * Operator identities (VOU-185). One row per identity an operator links,
+ * today only kind 'dns', a domain proven by a TXT record at
+ * _sealkeeper.<domain> (apps/api/src/operator-domains.ts). VOU-149 adds
+ * kind 'oidc' rows to the same table.
+ *
+ * subject is the domain, lower case, and subject_hash its SHA-256,
+ * base64url, the hash a SEAL carries. token is the value the TXT record
+ * must hold. It proves control of the domain and nothing else, but it is
+ * never logged. provider is the attester's URL, SealKeeper itself for dns.
+ *
+ * verified_at is the last check that found the record, null until the
+ * first. last_checked_at is the last check of any result. lapsed_at is the
+ * first check that missed the record after it was verified, cleared when a
+ * check finds it again. The identity counts as verified from verified_at
+ * until lapsed_at plus the grace period (OPERATOR_VERIFICATION). An operator
+ * adds a domain once, and one domain is verified for one operator at a
+ * time.
+ */
+export const operatorIdentities = pgTable('operator_identities', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    operatorId: uuid('operator_id')
+        .notNull()
+        .references(() => operators.id),
+    kind: text('kind').notNull(),
+    provider: text('provider').notNull(),
+    subject: text('subject').notNull(),
+    subjectHash: text('subject_hash').notNull(),
+    token: text('token'),
+    verifiedAt: timestamp('verified_at', { withTimezone: true }),
+    lastCheckedAt: timestamp('last_checked_at', { withTimezone: true }),
+    lapsedAt: timestamp('lapsed_at', { withTimezone: true }),
+    ...timestamps,
+}, (t) => [
+    unique('operator_identities_operator_kind_subject_unique').on(t.operatorId, t.kind, t.subject),
+    // One operator at a time holds a verified subject.
+    uniqueIndex('operator_identities_verified_subject_idx')
+        .on(t.kind, t.subject)
+        .where(sql `${t.verifiedAt} is not null`),
+    // The daily recheck's pick, verified rows by their last check.
+    index('operator_identities_recheck_idx')
+        .on(t.lastCheckedAt)
+        .where(sql `${t.verifiedAt} is not null`),
+    check('operator_identities_kind', sql `${t.kind} in ('dns')`),
+]);

package/dist/db/operator-level-grants.d.ts

@@ -0,0 +1,109 @@
+export declare const operatorLevelGrants: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "operator_level_grants";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "operator_level_grants";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "operator_level_grants";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        operatorId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "operator_id";
+            tableName: "operator_level_grants";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        agentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_id";
+            tableName: "operator_level_grants";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        level: import("drizzle-orm/pg-core").PgColumn<{
+            name: "level";
+            tableName: "operator_level_grants";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        grantedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "granted_at";
+            tableName: "operator_level_grants";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/db/operator-level-grants.js

@@ -0,0 +1,30 @@
+import { sql } from 'drizzle-orm';
+import { check, index, pgTable, primaryKey, text, timestamp, uuid, } from 'drizzle-orm/pg-core';
+import { timestamps } from './timestamps.js';
+/*
+ * The operator silver cap (VOU-182). One row per agent that took one of its
+ * operator's slots at a level, today only silver. The scoring run writes a
+ * row the first time an agent earns the level, when the operator has fewer
+ * than OPERATOR_SILVER_CAP.agents rows with granted_at in the last
+ * OPERATOR_SILVER_CAP.days days, and holds the agent at bronze otherwise
+ * (apps/api/src/silver-cap.ts). An agent keeps its row through dormancy and
+ * version changes.
+ *
+ * No foreign key to agents or operators. The row outlives the agent, so
+ * deleting an agent and registering it again does not free a slot. After
+ * the operator deletes its account the rows stay until the scoring run
+ * purges them with the deleted_operators hold. granted_at is the run's
+ * clock, the one the cap counts on.
+ */
+export const operatorLevelGrants = pgTable('operator_level_grants', {
+    operatorId: uuid('operator_id').notNull(),
+    agentId: text('agent_id').notNull(),
+    level: text('level').notNull(),
+    grantedAt: timestamp('granted_at', { withTimezone: true }).notNull(),
+    ...timestamps,
+}, (t) => [
+    primaryKey({ columns: [t.operatorId, t.agentId, t.level] }),
+    // The cap's count, an operator's grants of one level by date.
+    index('operator_level_grants_operator_level_granted_at_idx').on(t.operatorId, t.level, t.grantedAt),
+    check('operator_level_grants_level', sql `${t.level} in ('silver')`),
+]);

package/dist/db/operator-slugs.d.ts

@@ -0,0 +1,92 @@
+export declare const operatorSlugs: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "operator_slugs";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "operator_slugs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "operator_slugs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "operator_slugs";
+            dataType: "number";
+            columnType: "PgBigSerial53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        operatorId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "operator_id";
+            tableName: "operator_slugs";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        oldSlug: import("drizzle-orm/pg-core").PgColumn<{
+            name: "old_slug";
+            tableName: "operator_slugs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/db/operator-slugs.js

@@ -0,0 +1,25 @@
+import { bigserial, index, pgTable, text, uuid } from 'drizzle-orm/pg-core';
+import { operators } from './operators.js';
+import { timestamps } from './timestamps.js';
+// One row per operator slug change, holding the slug given up. For
+// SLUG_REDIRECT_DAYS after created_at a handle with the old slug answers
+// 404 renamed with the new handle, and no other operator can take the old
+// slug. The operator itself can take it back.
+//
+// operator_id is null once the operator is deleted. deleteOperator adds a
+// row for its current slug then and clears operator_id on the rows still
+// inside their hold, so those slugs stay held for everyone for the rest of
+// SLUG_REDIRECT_DAYS. With no operator to follow, a handle with one of them
+// answers 404 not_found. The row keeps only the slug string and its dates.
+//
+// The scoring run deletes every row once SLUG_REDIRECT_DAYS are up, with
+// an operator or without, since past that it redirects and holds nothing.
+export const operatorSlugs = pgTable('operator_slugs', {
+    id: bigserial('id', { mode: 'number' }).primaryKey(),
+    operatorId: uuid('operator_id').references(() => operators.id),
+    oldSlug: text('old_slug').notNull(),
+    ...timestamps,
+}, (t) => [
+    index('operator_slugs_old_slug_created_idx').on(t.oldSlug, t.createdAt),
+    index('operator_slugs_operator_idx').on(t.operatorId),
+]);

package/dist/db/operators.d.ts

@@ -87,6 +87,91 @@ export declare const operators: import("drizzle-orm/pg-core").PgTableWithColumns
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        slug: import("drizzle-orm/pg-core").PgColumn<{
+            name: "slug";
+            tableName: "operators";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        displayName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "display_name";
+            tableName: "operators";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        displayNameKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "display_name_key";
+            tableName: "operators";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        slugChangedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "slug_changed_at";
+            tableName: "operators";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        slugNoticeDismissedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "slug_notice_dismissed_at";
+            tableName: "operators";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         accountCreatedAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "account_created_at";
             tableName: "operators";
@@ -104,6 +189,40 @@ export declare const operators: import("drizzle-orm/pg-core").PgTableWithColumns
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        termsVersion: import("drizzle-orm/pg-core").PgColumn<{
+            name: "terms_version";
+            tableName: "operators";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        privacyVersion: import("drizzle-orm/pg-core").PgColumn<{
+            name: "privacy_version";
+            tableName: "operators";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: 'pg';
 }>;