@voyantjs/workflow-runs 0.21.0

package/dist/runner.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Workflow runner registry — the missing piece that makes "click to
+ * rerun" work in the dashboard. Saga workflows defined in
+ * `@voyantjs/core/workflows` are pure logic; running one needs
+ * closures over `db`, `eventBus`, and per-bundle services. The
+ * recorded `workflow_runs.input` row only captures the workflow
+ * payload, not those closures.
+ *
+ * Bundles that own a workflow register a `WorkflowRunner` on
+ * bootstrap. The rerun/resume routes look the runner up by name and
+ * call `rerun(input, ctx)` / `resume(input, ctx)`.
+ *
+ * Idempotency declaration:
+ *   - "safe"        — workflow is idempotent on the same input.
+ *                     Fresh rerun runs without confirmation.
+ *   - "unsafe"      — workflow has side effects that re-fire on rerun
+ *                     (writes a new invoice, charges again, etc.).
+ *                     The dashboard requires `confirm: true` in the
+ *                     request body and a confirm dialog in the UI.
+ *   - "resume-only" — fresh rerun is rejected; only the resume path
+ *                     (skip past completed steps) is allowed.
+ */
+export type WorkflowIdempotency = "safe" | "unsafe" | "resume-only";
+export interface WorkflowRerunContext {
+    /** The original run's id — written to the new run's `parentRunId`. */
+    parentRunId: string;
+    /** User who clicked "Rerun" / "Resume" in the dashboard. */
+    triggeredByUserId: string | null;
+    /** The original run's correlationId — copied to the rerun. */
+    correlationId: string | null;
+    /** The original run's tags — copied (rerun routes augment with `rerun:true` etc.). */
+    tags: ReadonlyArray<string>;
+}
+export interface WorkflowResumeContext extends WorkflowRerunContext {
+    /**
+     * Step name from which to resume. Outputs of all earlier completed
+     * steps are passed in `seedResults`; the executor must skip those
+     * steps and start at this one.
+     */
+    resumeFromStep: string;
+    /**
+     * Outputs of completed steps from the parent run, keyed by step
+     * name. The runner is expected to feed these into the workflow's
+     * ctx.results so subsequent steps see prior outputs unchanged.
+     */
+    seedResults: Record<string, unknown>;
+}
+export interface WorkflowRunner {
+    /** Workflow name — must match `workflow_runs.workflow_name`. */
+    name: string;
+    /**
+     * Idempotency declaration. Drives the dashboard's confirmation
+     * behavior and the rerun route's `confirm: true` requirement.
+     */
+    idempotency: WorkflowIdempotency;
+    /** Human-friendly label shown in the rerun confirm dialog. */
+    description?: string;
+    /**
+     * Run the workflow fresh with the recorded input. Returns the new
+     * run's id (the recorder's `runId`).
+     *
+     * Throws if `idempotency === "resume-only"`.
+     */
+    rerun(input: unknown, ctx: WorkflowRerunContext): Promise<{
+        runId: string;
+    }>;
+    /**
+     * Resume from `ctx.resumeFromStep`. Steps before that name are
+     * skipped (with their outputs hydrated from `ctx.seedResults`); the
+     * resume step and everything after it run normally.
+     *
+     * Returns the new run's id.
+     */
+    resume(input: unknown, ctx: WorkflowResumeContext): Promise<{
+        runId: string;
+    }>;
+    /**
+     * Optional per-input safety predicate. When supplied, the rerun
+     * route calls it with the recorded input and the previous run; a
+     * `false` result blocks the rerun (e.g. "don't re-issue an invoice
+     * if one already exists for this booking"). Implementations
+     * typically return a reason string for the user.
+     */
+    canRerun?: (input: unknown) => Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
+    }>;
+}
+/**
+ * Process-wide registry. Templates instantiate one and pass it to
+ * `mountWorkflowRunsAdminRoutes(hono, { runners })`. Bundles register
+ * their runners on bootstrap.
+ */
+export declare class WorkflowRunnerRegistry {
+    private readonly runners;
+    register(runner: WorkflowRunner): void;
+    get(name: string): WorkflowRunner | null;
+    has(name: string): boolean;
+    list(): ReadonlyArray<WorkflowRunner>;
+}
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,QAAQ,GAAG,aAAa,CAAA;AAEnE,MAAM,WAAW,oBAAoB;IACnC,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAA;IACnB,4DAA4D;IAC5D,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,8DAA8D;IAC9D,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,sFAAsF;IACtF,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAC5B;AAED,MAAM,WAAW,qBAAsB,SAAQ,oBAAoB;IACjE;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACrC;AAED,MAAM,WAAW,cAAc;IAC7B,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,WAAW,EAAE,mBAAmB,CAAA;IAChC,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,oBAAoB,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC5E;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC9E;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,IAAI,CAAA;KAAE,GAAG;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACrF;AAED;;;;GAIG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAE5D,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAOtC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAIxC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,IAAI,IAAI,aAAa,CAAC,cAAc,CAAC;CAGtC"}

package/dist/runner.js

@@ -0,0 +1,45 @@
+/**
+ * Workflow runner registry — the missing piece that makes "click to
+ * rerun" work in the dashboard. Saga workflows defined in
+ * `@voyantjs/core/workflows` are pure logic; running one needs
+ * closures over `db`, `eventBus`, and per-bundle services. The
+ * recorded `workflow_runs.input` row only captures the workflow
+ * payload, not those closures.
+ *
+ * Bundles that own a workflow register a `WorkflowRunner` on
+ * bootstrap. The rerun/resume routes look the runner up by name and
+ * call `rerun(input, ctx)` / `resume(input, ctx)`.
+ *
+ * Idempotency declaration:
+ *   - "safe"        — workflow is idempotent on the same input.
+ *                     Fresh rerun runs without confirmation.
+ *   - "unsafe"      — workflow has side effects that re-fire on rerun
+ *                     (writes a new invoice, charges again, etc.).
+ *                     The dashboard requires `confirm: true` in the
+ *                     request body and a confirm dialog in the UI.
+ *   - "resume-only" — fresh rerun is rejected; only the resume path
+ *                     (skip past completed steps) is allowed.
+ */
+/**
+ * Process-wide registry. Templates instantiate one and pass it to
+ * `mountWorkflowRunsAdminRoutes(hono, { runners })`. Bundles register
+ * their runners on bootstrap.
+ */
+export class WorkflowRunnerRegistry {
+    runners = new Map();
+    register(runner) {
+        if (this.runners.has(runner.name)) {
+            throw new Error(`WorkflowRunnerRegistry: runner "${runner.name}" already registered`);
+        }
+        this.runners.set(runner.name, runner);
+    }
+    get(name) {
+        return this.runners.get(name) ?? null;
+    }
+    has(name) {
+        return this.runners.has(name);
+    }
+    list() {
+        return Array.from(this.runners.values());
+    }
+}

package/dist/schema.d.ts

@@ -0,0 +1,515 @@
+/**
+ * `@voyantjs/workflow-runs` — schema for the lightweight observability
+ * surface that records in-process workflow lifecycles (saga steps the
+ * `@voyantjs/core/workflows` primitive runs, plus any other "I'm a
+ * workflow" code path that opts in via `recordWorkflowRun`).
+ *
+ * Distinct from the durable `@voyantjs/workflows` SDK's
+ * `voyant_snapshot_runs` schema — that one needs an orchestrator
+ * process to drive it, which doesn't fit the Cloudflare Workers
+ * deployment shape. This schema is edge-compatible (postgres-js or
+ * neon-http) so templates can register the routes inside their
+ * existing API surface.
+ *
+ * Tags as JSONB array — lets callers query "all runs for booking X"
+ * without hard-coding domain joins. The recorder's convention is to
+ * tag with `bookingId:<id>`, `paymentSessionId:<id>`, etc.
+ */
+export declare const workflowRunStatusEnum: import("drizzle-orm/pg-core").PgEnum<["running", "succeeded", "failed", "cancelled"]>;
+export declare const workflowRunStepStatusEnum: import("drizzle-orm/pg-core").PgEnum<["running", "succeeded", "failed", "skipped", "compensated"]>;
+export declare const workflowRuns: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_runs";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "workflow_runs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workflowName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workflow_name";
+            tableName: "workflow_runs";
+            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;
+        }, {}, {}>;
+        trigger: import("drizzle-orm/pg-core").PgColumn<{
+            name: "trigger";
+            tableName: "workflow_runs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        correlationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "correlation_id";
+            tableName: "workflow_runs";
+            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;
+        }, {}, {}>;
+        tags: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tags";
+            tableName: "workflow_runs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "workflow_runs";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "running" | "succeeded" | "failed" | "cancelled";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["running", "succeeded", "failed", "cancelled"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        input: import("drizzle-orm/pg-core").PgColumn<{
+            name: "input";
+            tableName: "workflow_runs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown> | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown> | null;
+        }>;
+        result: import("drizzle-orm/pg-core").PgColumn<{
+            name: "result";
+            tableName: "workflow_runs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown> | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown> | null;
+        }>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: "workflow_runs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: WorkflowRunErrorPayload | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: WorkflowRunErrorPayload | null;
+        }>;
+        parentRunId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "parent_run_id";
+            tableName: "workflow_runs";
+            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;
+        }, {}, {}>;
+        triggeredByUserId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "triggered_by_user_id";
+            tableName: "workflow_runs";
+            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;
+        }, {}, {}>;
+        resumeFromStep: import("drizzle-orm/pg-core").PgColumn<{
+            name: "resume_from_step";
+            tableName: "workflow_runs";
+            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;
+        }, {}, {}>;
+        startedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "started_at";
+            tableName: "workflow_runs";
+            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;
+        }, {}, {}>;
+        completedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "completed_at";
+            tableName: "workflow_runs";
+            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;
+        }, {}, {}>;
+        durationMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "duration_ms";
+            tableName: "workflow_runs";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "workflow_runs";
+            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_runs";
+            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";
+}>;
+export declare const workflowRunSteps: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_run_steps";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "workflow_run_steps";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "workflow_run_steps";
+            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;
+        }, {}, {}>;
+        stepName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "step_name";
+            tableName: "workflow_run_steps";
+            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;
+        }, {}, {}>;
+        sequence: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sequence";
+            tableName: "workflow_run_steps";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            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_steps";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "running" | "succeeded" | "failed" | "skipped" | "compensated";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["running", "succeeded", "failed", "skipped", "compensated"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        output: import("drizzle-orm/pg-core").PgColumn<{
+            name: "output";
+            tableName: "workflow_run_steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown> | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown> | null;
+        }>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: "workflow_run_steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: WorkflowRunErrorPayload | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: WorkflowRunErrorPayload | null;
+        }>;
+        startedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "started_at";
+            tableName: "workflow_run_steps";
+            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;
+        }, {}, {}>;
+        completedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "completed_at";
+            tableName: "workflow_run_steps";
+            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;
+        }, {}, {}>;
+        durationMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "duration_ms";
+            tableName: "workflow_run_steps";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export interface WorkflowRunErrorPayload {
+    message: string;
+    code?: string;
+    stepName?: string;
+    stack?: string;
+}
+export type WorkflowRun = typeof workflowRuns.$inferSelect;
+export type NewWorkflowRun = typeof workflowRuns.$inferInsert;
+export type WorkflowRunStep = typeof workflowRunSteps.$inferSelect;
+export type NewWorkflowRunStep = typeof workflowRunSteps.$inferInsert;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,eAAO,MAAM,qBAAqB,uFAKhC,CAAA;AAEF,eAAO,MAAM,yBAAyB,oGAMpC,CAAA;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDxB,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqB5B,CAAA;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,MAAM,WAAW,GAAG,OAAO,YAAY,CAAC,YAAY,CAAA;AAC1D,MAAM,MAAM,cAAc,GAAG,OAAO,YAAY,CAAC,YAAY,CAAA;AAC7D,MAAM,MAAM,eAAe,GAAG,OAAO,gBAAgB,CAAC,YAAY,CAAA;AAClE,MAAM,MAAM,kBAAkB,GAAG,OAAO,gBAAgB,CAAC,YAAY,CAAA"}