@intx/db 0.2.2 → 0.4.0

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

@@ -0,0 +1,385 @@
+export declare const sidecarAllocation: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "sidecar_allocation";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "sidecar_allocation";
+            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;
+        }, {}, {}>;
+        anchorRunId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "anchor_run_id";
+            tableName: "sidecar_allocation";
+            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;
+        }, {}, {}>;
+        tenantId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tenant_id";
+            tableName: "sidecar_allocation";
+            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;
+        }, {}, {}>;
+        provisionerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provisioner_id";
+            tableName: "sidecar_allocation";
+            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;
+        }, {}, {}>;
+        provisionerApiVersion: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provisioner_api_version";
+            tableName: "sidecar_allocation";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: 1;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: 1;
+        }>;
+        provisionerBindingFingerprint: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provisioner_binding_fingerprint";
+            tableName: "sidecar_allocation";
+            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;
+        }, {}, {}>;
+        sidecarId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sidecar_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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "sidecar_allocation";
+            dataType: "string";
+            columnType: "PgText";
+            data: "failed" | "pending" | "releasing" | "released" | "destroy_failed" | "provisioning" | "allocated" | "replacing";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "failed" | "pending" | "releasing" | "released" | "destroy_failed" | "provisioning" | "allocated" | "replacing";
+        }>;
+        generation: import("drizzle-orm/pg-core").PgColumn<{
+            name: "generation";
+            tableName: "sidecar_allocation";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ensureAcceptedGeneration: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ensure_accepted_generation";
+            tableName: "sidecar_allocation";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        externalRef: import("drizzle-orm/pg-core").PgColumn<{
+            name: "external_ref";
+            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;
+        }, {}, {}>;
+        nextAttemptAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_attempt_at";
+            tableName: "sidecar_allocation";
+            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;
+        }, {}, {}>;
+        reconciliationLeaseId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "reconciliation_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;
+        }, {}, {}>;
+        reconciliationLeaseExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "reconciliation_lease_expires_at";
+            tableName: "sidecar_allocation";
+            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;
+        }, {}, {}>;
+        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";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        destroyAttempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "destroy_attempts";
+            tableName: "sidecar_allocation";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        connectDeadline: import("drizzle-orm/pg-core").PgColumn<{
+            name: "connect_deadline";
+            tableName: "sidecar_allocation";
+            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;
+        }, {}, {}>;
+        failureCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "failure_code";
+            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;
+        }, {}, {}>;
+        failureMessage: import("drizzle-orm/pg-core").PgColumn<{
+            name: "failure_message";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "sidecar_allocation";
+            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: "sidecar_allocation";
+            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/sidecar-allocation.js

@@ -0,0 +1,53 @@
+import { sql } from "drizzle-orm";
+import { check, index, integer, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+import { sidecar } from "./sidecar.js";
+import { tenant } from "./tenants.js";
+import { workflowRun } from "./workflow-run.js";
+export const sidecarAllocation = pgTable("sidecar_allocation", {
+    id: text("id").primaryKey(),
+    anchorRunId: text("anchor_run_id")
+        .notNull()
+        .references(() => workflowRun.id, { onDelete: "cascade" }),
+    tenantId: text("tenant_id")
+        .notNull()
+        .references(() => tenant.id, { onDelete: "restrict" }),
+    provisionerId: text("provisioner_id").notNull(),
+    provisionerApiVersion: integer("provisioner_api_version")
+        .$type()
+        .notNull(),
+    provisionerBindingFingerprint: text("provisioner_binding_fingerprint").notNull(),
+    sidecarId: text("sidecar_id").references(() => sidecar.id, {
+        onDelete: "restrict",
+    }),
+    status: text("status")
+        .$type()
+        .notNull()
+        .default("pending"),
+    generation: integer("generation").notNull().default(0),
+    ensureAcceptedGeneration: integer("ensure_accepted_generation"),
+    externalRef: text("external_ref"),
+    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"),
+    failureCode: text("failure_code"),
+    failureMessage: text("failure_message"),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    updatedAt: timestamp("updated_at").notNull().defaultNow(),
+}, (t) => [
+    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', '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', '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

@@ -26,7 +26,7 @@ export declare const sidecar: import("drizzle-orm/pg-core").PgTableWithColumns<{
             columnType: "PgText";
             data: string;
             driverParam: string;
-            notNull: true;
+            notNull: false;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
@@ -60,7 +60,7 @@ export declare const sidecar: import("drizzle-orm/pg-core").PgTableWithColumns<{
             tableName: "sidecar";
             dataType: "string";
             columnType: "PgText";
-            data: "error" | "online" | "offline";
+            data: "online" | "offline" | "error";
             driverParam: string;
             notNull: true;
             hasDefault: true;

package/dist/schema/sidecar.js

@@ -2,7 +2,9 @@ import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
 import { bytea } from "./column-types.js";
 export const sidecar = pgTable("sidecar", {
     id: text("id").primaryKey(),
-    url: text("url").notNull(),
+    // 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.

package/dist/schema/signal-correlations.d.ts

@@ -0,0 +1,177 @@
+export declare const signalCorrelation: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "signal_correlation";
+    schema: undefined;
+    columns: {
+        correlationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "correlation_id";
+            tableName: "signal_correlation";
+            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;
+        }, {}, {}>;
+        tenantId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tenant_id";
+            tableName: "signal_correlation";
+            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;
+        }, {}, {}>;
+        anchorRunId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "anchor_run_id";
+            tableName: "signal_correlation";
+            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;
+        }, {}, {}>;
+        agentAddress: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_address";
+            tableName: "signal_correlation";
+            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;
+        }, {}, {}>;
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "run_id";
+            tableName: "signal_correlation";
+            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;
+        }, {}, {}>;
+        signalName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "signal_name";
+            tableName: "signal_correlation";
+            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;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "signal_correlation";
+            dataType: "string";
+            columnType: "PgText";
+            data: "approval";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["approval"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        signalId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "signal_id";
+            tableName: "signal_correlation";
+            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;
+        }, {}, {}>;
+        resolvedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "resolved_at";
+            tableName: "signal_correlation";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "signal_correlation";
+            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/signal-correlations.js

@@ -0,0 +1,31 @@
+import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { tenant } from "./tenants.js";
+import { workflowRun } from "./workflow-run.js";
+export const signalCorrelation = pgTable("signal_correlation", {
+    correlationId: text("correlation_id").primaryKey(),
+    tenantId: text("tenant_id")
+        .notNull()
+        .references(() => tenant.id, { onDelete: "cascade" }),
+    // Co-written with an `approval` that references the same anchor run and
+    // already cascades on its delete. A correlation whose anchor run is gone can
+    // never resolve, and its co-written approval has already cascaded away, so
+    // cascading the correlation keeps the pair consistent rather than leaving a
+    // correlation pointing at a vanished anchor run.
+    anchorRunId: text("anchor_run_id")
+        .notNull()
+        .references(() => workflowRun.id, { onDelete: "cascade" }),
+    agentAddress: text("agent_address").notNull(),
+    // References the run this correlation belongs to. Cascades on the run's
+    // delete: a correlation whose run is gone can never resolve, and the
+    // anchor-run cascade above already removes it when the whole deployment
+    // is torn down. The `anchor_run_id` FK stays as the lock and cascade anchor
+    // the co-write orders against.
+    runId: text("run_id")
+        .notNull()
+        .references(() => workflowRun.id, { onDelete: "cascade" }),
+    signalName: text("signal_name").notNull(),
+    kind: text("kind", { enum: ["approval"] }).notNull(),
+    signalId: text("signal_id"),
+    resolvedAt: timestamp("resolved_at"),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+});