@intx/db 0.3.0 → 0.4.0

package/dist/schema/principal-keys.d.ts

@@ -0,0 +1,126 @@
+export declare const principalKey: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "principal_key";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "principal_key";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        principalId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "principal_id";
+            tableName: "principal_key";
+            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;
+        }, {}, {}>;
+        publicKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "public_key";
+            tableName: "principal_key";
+            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;
+        }, {}, {}>;
+        privateKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "private_key";
+            tableName: "principal_key";
+            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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "principal_key";
+            dataType: "string";
+            columnType: "PgText";
+            data: "active" | "retired";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["active", "retired"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "principal_key";
+            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: "principal_key";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/schema/principal-keys.js

@@ -0,0 +1,28 @@
+import { sql } from "drizzle-orm";
+import { pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+import { principal } from "./principals.js";
+// A principal's Ed25519 signing key. `public_key` is the hex-encoded 32-byte
+// public point; `private_key` holds the hex-encoded 32-byte seed sealed by the
+// credential cipher (`enc:aead:...` ciphertext), so the seed is never at rest in
+// plaintext under a configured key. The hub custodies the private key: a
+// signature attributes an action to the principal, but is not non-repudiable
+// against the hub operator. See docs/AUTH.md.
+//
+// The `status` axis expresses the one-active-key-per-principal invariant, which
+// the partial unique index below enforces at the database. No path retires a
+// key; every key a principal holds today is "active".
+export const principalKey = pgTable("principal_key", {
+    id: text("id").primaryKey(),
+    principalId: text("principal_id")
+        .notNull()
+        .references(() => principal.id, { onDelete: "cascade" }),
+    publicKey: text("public_key").notNull().unique(),
+    privateKey: text("private_key").notNull(),
+    status: text("status", { enum: ["active", "retired"] }).notNull(),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    updatedAt: timestamp("updated_at").notNull().defaultNow(),
+}, (t) => [
+    uniqueIndex("principal_key_one_active")
+        .on(t.principalId)
+        .where(sql `${t.status} = 'active'`),
+]);

package/dist/schema/sidecar-allocation.d.ts

@@ -123,50 +123,12 @@ export declare const sidecarAllocation: import("drizzle-orm/pg-core").PgTableWit
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        placementSharing: import("drizzle-orm/pg-core").PgColumn<{
-            name: "placement_sharing";
-            tableName: "sidecar_allocation";
-            dataType: "string";
-            columnType: "PgText";
-            data: "exclusive";
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            $type: "exclusive";
-        }>;
-        sidecarReuse: import("drizzle-orm/pg-core").PgColumn<{
-            name: "sidecar_reuse";
-            tableName: "sidecar_allocation";
-            dataType: "string";
-            columnType: "PgText";
-            data: "never" | "same-deployment";
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            $type: "never" | "same-deployment";
-        }>;
         status: import("drizzle-orm/pg-core").PgColumn<{
             name: "status";
             tableName: "sidecar_allocation";
             dataType: "string";
             columnType: "PgText";
-            data: "failed" | "allocated" | "pending" | "provisioning" | "replacing" | "releasing" | "released";
+            data: "failed" | "pending" | "releasing" | "released" | "destroy_failed" | "provisioning" | "allocated" | "replacing";
             driverParam: string;
             notNull: true;
             hasDefault: true;
@@ -178,7 +140,7 @@ export declare const sidecarAllocation: import("drizzle-orm/pg-core").PgTableWit
             identity: undefined;
             generated: undefined;
         }, {}, {
-            $type: "failed" | "allocated" | "pending" | "provisioning" | "replacing" | "releasing" | "released";
+            $type: "failed" | "pending" | "releasing" | "released" | "destroy_failed" | "provisioning" | "allocated" | "replacing";
         }>;
         generation: import("drizzle-orm/pg-core").PgColumn<{
             name: "generation";
@@ -282,6 +244,23 @@ export declare const sidecarAllocation: import("drizzle-orm/pg-core").PgTableWit
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        initializationLeaseId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "initialization_lease_id";
+            tableName: "sidecar_allocation";
+            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;
+        }, {}, {}>;
         ensureAttempts: import("drizzle-orm/pg-core").PgColumn<{
             name: "ensure_attempts";
             tableName: "sidecar_allocation";

package/dist/schema/sidecar-allocation.js

@@ -19,11 +19,6 @@ export const sidecarAllocation = pgTable("sidecar_allocation", {
     sidecarId: text("sidecar_id").references(() => sidecar.id, {
         onDelete: "restrict",
     }),
-    placementSharing: text("placement_sharing").$type().notNull(),
-    sidecarReuse: text("sidecar_reuse")
-        .$type()
-        .notNull()
-        .default("never"),
     status: text("status")
         .$type()
         .notNull()
@@ -34,6 +29,7 @@ export const sidecarAllocation = pgTable("sidecar_allocation", {
     nextAttemptAt: timestamp("next_attempt_at"),
     reconciliationLeaseId: text("reconciliation_lease_id"),
     reconciliationLeaseExpiresAt: timestamp("reconciliation_lease_expires_at"),
+    initializationLeaseId: text("initialization_lease_id"),
     ensureAttempts: integer("ensure_attempts").notNull().default(0),
     destroyAttempts: integer("destroy_attempts").notNull().default(0),
     connectDeadline: timestamp("connect_deadline"),
@@ -45,13 +41,13 @@ export const sidecarAllocation = pgTable("sidecar_allocation", {
     uniqueIndex("sidecar_allocation_anchor_run_idx").on(t.anchorRunId),
     uniqueIndex("sidecar_allocation_active_sidecar_idx")
         .on(t.sidecarId)
-        .where(sql `${t.status} in ('provisioning', 'allocated', 'replacing', 'releasing')`),
+        .where(sql `${t.status} in ('provisioning', 'allocated', 'replacing', 'releasing', 'destroy_failed')`),
     index("sidecar_allocation_sidecar_idx").on(t.sidecarId),
     index("sidecar_allocation_reconciliation_idx")
         .on(t.nextAttemptAt, t.createdAt)
         .where(sql `${t.status} in ('pending', 'provisioning', 'allocated', 'replacing', 'releasing') and ${t.nextAttemptAt} is not null`),
-    check("sidecar_allocation_status_check", sql `${t.status} in ('pending', 'provisioning', 'allocated', 'replacing', 'releasing', 'released', 'failed')`),
-    check("sidecar_allocation_placement_check", sql `${t.placementSharing} = 'exclusive'`),
+    check("sidecar_allocation_status_check", sql `${t.status} in ('pending', 'provisioning', 'allocated', 'replacing', 'releasing', 'destroy_failed', 'released', 'failed')`),
     check("sidecar_allocation_generation_check", sql `${t.generation} >= 0`),
     check("sidecar_allocation_accepted_generation_check", sql `${t.ensureAcceptedGeneration} is null or ${t.ensureAcceptedGeneration} <= ${t.generation}`),
+    check("sidecar_allocation_initialization_check", sql `${t.initializationLeaseId} is null or (${t.status} = 'allocated' and ${t.ensureAcceptedGeneration} is not null and ${t.ensureAcceptedGeneration} = ${t.generation})`),
 ]);

package/dist/schema/sidecar.d.ts

@@ -55,23 +55,6 @@ export declare const sidecar: import("drizzle-orm/pg-core").PgTableWithColumns<{
         }, {}, {
             pgColumnBuilderBrand: "PgCustomColumnBuilderBrand";
         }>;
-        credentialScope: import("drizzle-orm/pg-core").PgColumn<{
-            name: "credential_scope";
-            tableName: "sidecar";
-            dataType: "string";
-            columnType: "PgText";
-            data: "shared" | "allocated";
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: ["shared", "allocated"];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
         status: import("drizzle-orm/pg-core").PgColumn<{
             name: "status";
             tableName: "sidecar";

package/dist/schema/sidecar.js

@@ -1,20 +1,14 @@
-import { sql } from "drizzle-orm";
-import { check, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
 import { bytea } from "./column-types.js";
 export const sidecar = pgTable("sidecar", {
     id: text("id").primaryKey(),
-    // Allocated identities exist before their infrastructure connects, so they
-    // do not have an endpoint until registration completes.
+    // Provisioned probe/allocation identities exist before their infrastructure
+    // connects, so they do not have an endpoint until registration completes.
     url: text("url"),
     // SHA-256 digest of the sidecar's bearer token, presented on the
     // WebSocket handshake and matched against this column. Only the digest
     // is stored; the raw token is never persisted.
     tokenHashSha256: bytea("token_hash_sha256").notNull().unique(),
-    credentialScope: text("credential_scope", {
-        enum: ["shared", "allocated"],
-    })
-        .notNull()
-        .default("shared"),
     status: text("status", {
         enum: ["online", "offline", "error"],
     })
@@ -23,6 +17,4 @@ export const sidecar = pgTable("sidecar", {
     lastHeartbeat: timestamp("last_heartbeat"),
     createdAt: timestamp("created_at").notNull().defaultNow(),
     updatedAt: timestamp("updated_at").notNull().defaultNow(),
-}, (t) => [
-    check("sidecar_credential_scope_check", sql `${t.credentialScope} in ('shared', 'allocated')`),
-]);
+});

package/dist/schema/tenants.js

@@ -1,14 +1,24 @@
-import { foreignKey, jsonb, pgTable, text, timestamp, unique, } from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+import { foreignKey, jsonb, pgTable, text, timestamp, unique, uniqueIndex, } from "drizzle-orm/pg-core";
 export const tenant = pgTable("tenant", {
     id: text("id").primaryKey(),
     name: text("name").notNull(),
     slug: text("slug").notNull().unique(),
-    domain: text("domain").notNull().unique(),
+    // Unique on `lower(domain)`, not the raw column: an inbound mail `From` is
+    // lowercased when parsed, so a sender address must map to exactly one
+    // tenant. A case-sensitive unique would let case-variant domains coexist and
+    // let a case-variant registration shadow another tenant's senders. The
+    // creation boundary lowercases the domain; this index enforces it for every
+    // write path.
+    domain: text("domain").notNull(),
     parentId: text("parent_id"),
     config: jsonb("config"),
     createdAt: timestamp("created_at").notNull().defaultNow(),
     updatedAt: timestamp("updated_at").notNull().defaultNow(),
-}, (t) => [foreignKey({ columns: [t.parentId], foreignColumns: [t.id] })]);
+}, (t) => [
+    foreignKey({ columns: [t.parentId], foreignColumns: [t.id] }),
+    uniqueIndex("tenant_domain_lower_idx").on(sql `lower(${t.domain})`),
+]);
 export const federationTrust = pgTable("federation_trust", {
     id: text("id").primaryKey(),
     tenantId: text("tenant_id")