@intx/db 0.2.2 → 0.4.0

package/dist/schema/workflow-run-dispatch.d.ts

@@ -0,0 +1,345 @@
+export declare const workflowRunDispatchStatuses: readonly ["pending", "acknowledged", "settled", "failed"];
+export type WorkflowRunDispatchStatus = (typeof workflowRunDispatchStatuses)[number];
+export declare const workflowRunDispatchKinds: readonly ["mail", "signal"];
+export type WorkflowRunDispatchKind = (typeof workflowRunDispatchKinds)[number];
+/**
+ * Hub-owned delivery state for one inbound workflow message. The raw payload
+ * remains durable until the workflow-run Git claim-check reaches `consumed`;
+ * a sidecar-local enqueue acknowledgement alone does not settle the row.
+ */
+export declare const workflowRunDispatch: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_run_dispatch";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "workflow_run_dispatch";
+            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: "workflow_run_dispatch";
+            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;
+        }, {}, {}>;
+        messageId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "message_id";
+            tableName: "workflow_run_dispatch";
+            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: "workflow_run_dispatch";
+            dataType: "string";
+            columnType: "PgText";
+            data: "signal" | "mail";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "signal" | "mail";
+        }>;
+        senderAddress: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sender_address";
+            tableName: "workflow_run_dispatch";
+            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;
+        }, {}, {}>;
+        rawMessage: import("drizzle-orm/pg-core").PgColumn<{
+            name: "raw_message";
+            tableName: "workflow_run_dispatch";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: Uint8Array<ArrayBufferLike>;
+            driverParam: Uint8Array<ArrayBufferLike>;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: "PgCustomColumnBuilderBrand";
+        }>;
+        stepGrants: import("drizzle-orm/pg-core").PgColumn<{
+            name: "step_grants";
+            tableName: "workflow_run_dispatch";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "workflow_run_dispatch";
+            dataType: "string";
+            columnType: "PgText";
+            data: "failed" | "pending" | "acknowledged" | "settled";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "failed" | "pending" | "acknowledged" | "settled";
+        }>;
+        acknowledgedGeneration: import("drizzle-orm/pg-core").PgColumn<{
+            name: "acknowledged_generation";
+            tableName: "workflow_run_dispatch";
+            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;
+        }, {}, {}>;
+        attemptCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempt_count";
+            tableName: "workflow_run_dispatch";
+            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;
+        }, {}, {}>;
+        nextAttemptAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_attempt_at";
+            tableName: "workflow_run_dispatch";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deliveryLeaseId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "delivery_lease_id";
+            tableName: "workflow_run_dispatch";
+            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;
+        }, {}, {}>;
+        deliveryLeaseExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "delivery_lease_expires_at";
+            tableName: "workflow_run_dispatch";
+            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: "workflow_run_dispatch";
+            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: "workflow_run_dispatch";
+            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: "workflow_run_dispatch";
+            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: "workflow_run_dispatch";
+            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;
+        }, {}, {}>;
+        acknowledgedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "acknowledged_at";
+            tableName: "workflow_run_dispatch";
+            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;
+        }, {}, {}>;
+        settledAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "settled_at";
+            tableName: "workflow_run_dispatch";
+            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/schema/workflow-run-dispatch.js

@@ -0,0 +1,63 @@
+import { sql } from "drizzle-orm";
+import { check, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+import { bytea } from "./column-types.js";
+import { workflowRun } from "./workflow-run.js";
+export const workflowRunDispatchStatuses = [
+    "pending",
+    "acknowledged",
+    "settled",
+    "failed",
+];
+export const workflowRunDispatchKinds = ["mail", "signal"];
+/**
+ * Hub-owned delivery state for one inbound workflow message. The raw payload
+ * remains durable until the workflow-run Git claim-check reaches `consumed`;
+ * a sidecar-local enqueue acknowledgement alone does not settle the row.
+ */
+export const workflowRunDispatch = pgTable("workflow_run_dispatch", {
+    id: text("id").primaryKey(),
+    anchorRunId: text("anchor_run_id")
+        .notNull()
+        .references(() => workflowRun.id, { onDelete: "cascade" }),
+    messageId: text("message_id").notNull(),
+    kind: text("kind")
+        .$type()
+        .notNull()
+        .default("mail"),
+    senderAddress: text("sender_address"),
+    rawMessage: bytea("raw_message").notNull(),
+    stepGrants: jsonb("step_grants").notNull(),
+    status: text("status")
+        .$type()
+        .notNull()
+        .default("pending"),
+    acknowledgedGeneration: integer("acknowledged_generation"),
+    attemptCount: integer("attempt_count").notNull().default(0),
+    nextAttemptAt: timestamp("next_attempt_at").defaultNow(),
+    deliveryLeaseId: text("delivery_lease_id"),
+    deliveryLeaseExpiresAt: timestamp("delivery_lease_expires_at"),
+    failureCode: text("failure_code"),
+    failureMessage: text("failure_message"),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    updatedAt: timestamp("updated_at").notNull().defaultNow(),
+    acknowledgedAt: timestamp("acknowledged_at"),
+    settledAt: timestamp("settled_at"),
+}, (t) => [
+    uniqueIndex("workflow_run_dispatch_anchor_message_idx").on(t.anchorRunId, t.messageId),
+    index("workflow_run_dispatch_delivery_idx")
+        .on(t.nextAttemptAt, t.createdAt)
+        .where(sql `${t.status} = 'pending'`),
+    index("workflow_run_dispatch_anchor_status_idx").on(t.anchorRunId, t.status),
+    check("workflow_run_dispatch_status_check", sql `${t.status} in ('pending', 'acknowledged', 'settled', 'failed')`),
+    check("workflow_run_dispatch_kind_check", sql `${t.kind} in ('mail', 'signal')`),
+    check("workflow_run_dispatch_attempt_count_check", sql `${t.attemptCount} >= 0`),
+    check("workflow_run_dispatch_acknowledged_generation_check", sql `${t.acknowledgedGeneration} is null or ${t.acknowledgedGeneration} >= 0`),
+    check("workflow_run_dispatch_acknowledged_state_check", sql `${t.status} <> 'acknowledged' or ${t.acknowledgedGeneration} is not null`),
+    check("workflow_run_dispatch_pending_schedule_check", sql `${t.status} <> 'pending' or ${t.nextAttemptAt} is not null`),
+    // A deliverable mail dispatch must carry the hub-verified sender that
+    // its inbound frame is stamped with; signals have no sender. Terminal
+    // (settled/failed) mail rows are exempt because they are never
+    // re-dispatched and so never reconstruct a frame -- this is what lets a
+    // migration fail legacy in-flight mail in place rather than delete it.
+    check("workflow_run_dispatch_mail_sender_check", sql `${t.kind} <> 'mail' or ${t.status} in ('settled', 'failed') or ${t.senderAddress} is not null`),
+]);

package/dist/schema/{agent-assets.d.ts → workflow-run-execution.d.ts}

@@ -1,10 +1,10 @@
-export declare const agentAsset: import("drizzle-orm/pg-core").PgTableWithColumns<{
-    name: "agent_asset";
+export declare const workflowRunExecution: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_run_execution";
     schema: undefined;
     columns: {
         id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";
-            tableName: "agent_asset";
+            tableName: "workflow_run_execution";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -19,9 +19,9 @@ export declare const agentAsset: import("drizzle-orm/pg-core").PgTableWithColumn
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        agentId: import("drizzle-orm/pg-core").PgColumn<{
-            name: "agent_id";
-            tableName: "agent_asset";
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "run_id";
+            tableName: "workflow_run_execution";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -36,9 +36,9 @@ export declare const agentAsset: import("drizzle-orm/pg-core").PgTableWithColumn
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        assetId: import("drizzle-orm/pg-core").PgColumn<{
-            name: "asset_id";
-            tableName: "agent_asset";
+        messageId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "message_id";
+            tableName: "workflow_run_execution";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -53,49 +53,49 @@ export declare const agentAsset: import("drizzle-orm/pg-core").PgTableWithColumn
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        ref: import("drizzle-orm/pg-core").PgColumn<{
-            name: "ref";
-            tableName: "agent_asset";
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "workflow_run_execution";
             dataType: "string";
             columnType: "PgText";
-            data: string;
+            data: "failed" | "running" | "completed";
             driverParam: string;
             notNull: true;
-            hasDefault: false;
+            hasDefault: true;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
+            enumValues: ["running", "completed", "failed"];
             baseColumn: never;
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        accessMode: import("drizzle-orm/pg-core").PgColumn<{
-            name: "access_mode";
-            tableName: "agent_asset";
-            dataType: "string";
-            columnType: "PgText";
-            data: string;
+        startedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "started_at";
+            tableName: "workflow_run_execution";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
             driverParam: string;
             notNull: true;
             hasDefault: true;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
+            enumValues: undefined;
             baseColumn: never;
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        createdAt: import("drizzle-orm/pg-core").PgColumn<{
-            name: "created_at";
-            tableName: "agent_asset";
+        endedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ended_at";
+            tableName: "workflow_run_execution";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
             driverParam: string;
-            notNull: true;
-            hasDefault: true;
+            notNull: false;
+            hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
@@ -104,6 +104,23 @@ export declare const agentAsset: import("drizzle-orm/pg-core").PgTableWithColumn
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        failureReason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "failure_reason";
+            tableName: "workflow_run_execution";
+            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";
 }>;

package/dist/schema/workflow-run-execution.js

@@ -0,0 +1,48 @@
+import { index, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+import { workflowRun } from "./workflow-run.js";
+// workflow_run_execution is the per-TURN record of a run. A long-lived run
+// (`workflow_run`, the run aggregate) resumes in place across many messages;
+// each inbound message drives exactly one execution -- one turn. The
+// single-shot running->terminal guard is per turn and belongs here, not on the
+// run aggregate: a redelivered terminal re-settles the SAME execution rather
+// than re-terminating the whole run, and a new message opens a NEW execution
+// against the same run.
+//
+// `id` is the executionId, derived deterministically from the driving message
+// (see `deriveExecutionId`), so a redelivery of the same bytes resolves to the
+// same execution rather than a fresh one. The table is the hub-side projection
+// of the run's turn-boundary events (`TurnStarted`/`TurnCompleted`/`TurnFailed`)
+// that the read surface exposes so per-turn outcomes are visible.
+export const workflowRunExecution = pgTable("workflow_run_execution", {
+    id: text("id").primaryKey(),
+    // The run this execution is a turn of. `cascade` matches `workflow_run`'s
+    // own deletes so a removed run takes its executions with it.
+    runId: text("run_id")
+        .notNull()
+        .references(() => workflowRun.id, { onDelete: "cascade" }),
+    // The inbound message that drove this turn; the executionId is derived from
+    // it, but the raw messageId is retained for correlation and read-surface
+    // display.
+    messageId: text("message_id").notNull(),
+    // A turn is born "running" and settles to "completed" or "failed" when its
+    // terminal turn event lands. Unlike the run aggregate, a turn is never
+    // "cancelled" on its own -- cancellation is a run-level disposition.
+    status: text("status", {
+        enum: ["running", "completed", "failed"],
+    })
+        .notNull()
+        .default("running"),
+    startedAt: timestamp("started_at").notNull().defaultNow(),
+    // Nullable: a turn has no end time until it reaches a terminal state.
+    endedAt: timestamp("ended_at"),
+    // Populated only on a `failed` turn (e.g. a malformed inbound mail that
+    // could not resume the run); null otherwise.
+    failureReason: text("failure_reason"),
+}, (t) => [
+    // The read surface lists a run's executions in turn order; the leftmost
+    // `runId` column serves that lookup. Unique on `(runId, id)` as the
+    // race backstop the design mandates against a concurrent double-insert of
+    // the same turn.
+    uniqueIndex("workflow_run_execution_run_id_id_idx").on(t.runId, t.id),
+    index("workflow_run_execution_status_idx").on(t.status),
+]);