@shipfox/api-workflows 2.0.0

package/dist/db/schema/jobs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/jobs.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {\n  bigint,\n  boolean,\n  index,\n  integer,\n  jsonb,\n  pgEnum,\n  text,\n  timestamp,\n  uuid,\n} from 'drizzle-orm/pg-core';\nimport {\n  JOB_STATUS_REASONS,\n  type Job,\n  type JobListeningTrigger,\n  toJobStatusReason,\n} from '#core/entities/job.js';\nimport type {PersistedEvaluationTraceEntry} from '#core/entities/step.js';\nimport {pgTable} from './common.js';\nimport {workflowRunAttempts} from './workflow-run-attempts.js';\n\nexport const jobStatusEnum = pgEnum('workflows_job_status', [\n  'pending',\n  'running',\n  'succeeded',\n  'failed',\n  'cancelled',\n  'skipped',\n]);\n\nexport const jobStatusReasonEnum = pgEnum('workflows_job_status_reason', JOB_STATUS_REASONS);\n\nexport const jobModeEnum = pgEnum('workflows_job_mode', ['one_shot', 'listening']);\n\nexport const jobCheckoutContentsEnum = pgEnum('workflows_checkout_contents', ['read', 'write']);\n\nexport const jobOnResolveEnum = pgEnum('workflows_job_on_resolve', ['finish', 'cancel']);\n\nexport const listenerStatusEnum = pgEnum('workflows_listener_status', [\n  'inactive',\n  'listening',\n  'resolved',\n]);\n\nexport const resolutionReasonEnum = pgEnum('workflows_resolution_reason', [\n  'until',\n  'timeout',\n  'max_executions',\n  'cancelled',\n]);\n\nexport const jobs = pgTable(\n  'jobs',\n  {\n    id: uuidv7PrimaryKey(),\n    workflowRunAttemptId: uuid('workflow_run_attempt_id')\n      .notNull()\n      .references(() => workflowRunAttempts.id, {onDelete: 'cascade'}),\n    key: text('key').notNull(),\n    mode: jobModeEnum('mode').notNull().default('one_shot'),\n    name: text('name'),\n    status: jobStatusEnum('status').notNull().default('pending'),\n    statusReason: jobStatusReasonEnum('status_reason'),\n    carriedOver: boolean('carried_over').notNull().default(false),\n    checkoutPersistCredentials: boolean('checkout_persist_credentials').notNull(),\n    checkoutPermissionsContents: jobCheckoutContentsEnum('checkout_permissions_contents').notNull(),\n    success: text('success'),\n    evaluationTrace: jsonb('evaluation_trace').$type<readonly PersistedEvaluationTraceEntry[]>(),\n    executionTimeoutMs: integer('execution_timeout_ms'),\n    listeningTimeoutMs: bigint('listening_timeout_ms', {mode: 'number'}),\n    maxExecutions: integer('max_executions'),\n    onResolve: jobOnResolveEnum('on_resolve'),\n    batchDebounceMs: integer('batch_debounce_ms'),\n    batchMaxSize: integer('batch_max_size'),\n    batchMaxWaitMs: integer('batch_max_wait_ms'),\n    listenerStatus: listenerStatusEnum('listener_status').notNull().default('inactive'),\n    resolutionReason: resolutionReasonEnum('resolution_reason'),\n    listeningOn: jsonb('listening_on').$type<JobListeningTrigger[]>(),\n    listeningUntil: jsonb('listening_until').$type<JobListeningTrigger[]>(),\n    outputs: jsonb('outputs').$type<Record<string, unknown> | null>(),\n    dependencies: jsonb('dependencies').notNull().$type<string[]>(),\n    runner: jsonb('runner').$type<string[]>(),\n    position: integer('position').notNull(),\n    version: integer('version').notNull().default(1),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    index('workflows_jobs_workflow_run_attempt_id_idx').on(table.workflowRunAttemptId),\n    index('workflows_jobs_active_listeners_idx')\n      .on(table.listenerStatus)\n      .where(sql`${table.listenerStatus} = 'listening'`),\n  ],\n);\n\nexport type JobDb = typeof jobs.$inferSelect;\nexport type JobCreateDb = typeof jobs.$inferInsert;\n\nexport function toJob(row: JobDb): Job {\n  return {\n    id: row.id,\n    workflowRunAttemptId: row.workflowRunAttemptId,\n    key: row.key,\n    name: row.name,\n    mode: row.mode,\n    status: row.status,\n    statusReason: toJobStatusReason(row.statusReason),\n    carriedOver: row.carriedOver,\n    checkout: {\n      permissions: {contents: row.checkoutPermissionsContents},\n      persistCredentials: row.checkoutPersistCredentials,\n    },\n    success: row.success,\n    evaluationTrace: row.evaluationTrace ?? null,\n    executionTimeoutMs: row.executionTimeoutMs,\n    listeningTimeoutMs: row.listeningTimeoutMs,\n    maxExecutions: row.maxExecutions,\n    onResolve: row.onResolve,\n    batchDebounceMs: row.batchDebounceMs,\n    batchMaxSize: row.batchMaxSize,\n    batchMaxWaitMs: row.batchMaxWaitMs,\n    listenerStatus: row.listenerStatus,\n    resolutionReason: row.resolutionReason,\n    listeningOn: row.listeningOn,\n    listeningUntil: row.listeningUntil,\n    outputs: row.outputs,\n    dependencies: row.dependencies as string[],\n    runner: row.runner as string[] | null,\n    position: row.position,\n    version: row.version,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","bigint","boolean","index","integer","jsonb","pgEnum","text","timestamp","uuid","JOB_STATUS_REASONS","toJobStatusReason","pgTable","workflowRunAttempts","jobStatusEnum","jobStatusReasonEnum","jobModeEnum","jobCheckoutContentsEnum","jobOnResolveEnum","listenerStatusEnum","resolutionReasonEnum","jobs","id","workflowRunAttemptId","notNull","references","onDelete","key","mode","default","name","status","statusReason","carriedOver","checkoutPersistCredentials","checkoutPermissionsContents","success","evaluationTrace","$type","executionTimeoutMs","listeningTimeoutMs","maxExecutions","onResolve","batchDebounceMs","batchMaxSize","batchMaxWaitMs","listenerStatus","resolutionReason","listeningOn","listeningUntil","outputs","dependencies","runner","position","version","createdAt","withTimezone","defaultNow","updatedAt","table","on","where","toJob","row","checkout","permissions","contents","persistCredentials"],"mappings":"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"}

package/dist/db/schema/outbox.d.ts

@@ -0,0 +1,195 @@
+export declare const workflowsOutbox: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "outbox";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_type";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        orderingKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ordering_key";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        dispatchedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dispatched_at";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        dispatchAttempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dispatch_attempts";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        nextDispatchAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_dispatch_at";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        lastDispatchError: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_dispatch_error";
+            tableName: "outbox";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastDispatchFailedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_dispatch_failed_at";
+            tableName: "outbox";
+            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;
+        }, {}, {}>;
+        deadLetteredAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dead_lettered_at";
+            tableName: "outbox";
+            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";
+}>;
+//# sourceMappingURL=outbox.d.ts.map

package/dist/db/schema/outbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.d.ts","sourceRoot":"","sources":["../../../src/db/schema/outbox.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA6B,CAAC"}

package/dist/db/schema/outbox.js

@@ -0,0 +1,5 @@
+import { createOutboxTable } from '@shipfox/node-outbox';
+import { pgTable } from './common.js';
+export const workflowsOutbox = createOutboxTable(pgTable);
+
+//# sourceMappingURL=outbox.js.map

package/dist/db/schema/outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/outbox.ts"],"sourcesContent":["import {createOutboxTable} from '@shipfox/node-outbox';\nimport {pgTable} from './common.js';\n\nexport const workflowsOutbox = createOutboxTable(pgTable);\n"],"names":["createOutboxTable","pgTable","workflowsOutbox"],"mappings":"AAAA,SAAQA,iBAAiB,QAAO,uBAAuB;AACvD,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,kBAAkBF,kBAAkBC,SAAS"}

package/dist/db/schema/step-attempts.d.ts

@@ -0,0 +1,330 @@
+import type { PersistedEvaluationTraceEntry, StepAttempt, StepAttemptLogOutcome } from '#core/entities/step.js';
+export declare const stepAttempts: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "step_attempts";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "step_attempts";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stepId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "step_id";
+            tableName: "step_attempts";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        jobExecutionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "job_execution_id";
+            tableName: "step_attempts";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attempt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempt";
+            tableName: "step_attempts";
+            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;
+        }, {}, {}>;
+        executionOrder: import("drizzle-orm/pg-core").PgColumn<{
+            name: "execution_order";
+            tableName: "step_attempts";
+            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: "step_attempts";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "pending" | "running" | "succeeded" | "failed" | "cancelled" | "skipped";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pending", "running", "succeeded", "failed", "cancelled", "skipped"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        config: import("drizzle-orm/pg-core").PgColumn<{
+            name: "config";
+            tableName: "step_attempts";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        evaluationTrace: import("drizzle-orm/pg-core").PgColumn<{
+            name: "evaluation_trace";
+            tableName: "step_attempts";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: readonly PersistedEvaluationTraceEntry[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: readonly PersistedEvaluationTraceEntry[];
+        }>;
+        output: import("drizzle-orm/pg-core").PgColumn<{
+            name: "output";
+            tableName: "step_attempts";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        response: import("drizzle-orm/pg-core").PgColumn<{
+            name: "response";
+            tableName: "step_attempts";
+            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;
+        }, {}, {}>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: "step_attempts";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        exitCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "exit_code";
+            tableName: "step_attempts";
+            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;
+        }, {}, {}>;
+        logOutcome: import("drizzle-orm/pg-core").PgColumn<{
+            name: "log_outcome";
+            tableName: "step_attempts";
+            dataType: "string";
+            columnType: "PgText";
+            data: StepAttemptLogOutcome;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: StepAttemptLogOutcome;
+        }>;
+        gateResult: import("drizzle-orm/pg-core").PgColumn<{
+            name: "gate_result";
+            tableName: "step_attempts";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        restartFeedback: import("drizzle-orm/pg-core").PgColumn<{
+            name: "restart_feedback";
+            tableName: "step_attempts";
+            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: "step_attempts";
+            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;
+        }, {}, {}>;
+        finishedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "finished_at";
+            tableName: "step_attempts";
+            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: "step_attempts";
+            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 type StepAttemptDb = typeof stepAttempts.$inferSelect;
+export type StepAttemptCreateDb = typeof stepAttempts.$inferInsert;
+export declare function toStepAttempt(row: StepAttemptDb): StepAttempt;
+//# sourceMappingURL=step-attempts.d.ts.map

package/dist/db/schema/step-attempts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-attempts.d.ts","sourceRoot":"","sources":["../../../src/db/schema/step-attempts.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACV,6BAA6B,EAC7B,WAAW,EACX,qBAAqB,EAEtB,MAAM,wBAAwB,CAAC;AAQhC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDxB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,OAAO,YAAY,CAAC,YAAY,CAAC;AAC7D,MAAM,MAAM,mBAAmB,GAAG,OAAO,YAAY,CAAC,YAAY,CAAC;AAEnE,wBAAgB,aAAa,CAAC,GAAG,EAAE,aAAa,GAAG,WAAW,CAoB7D"}

package/dist/db/schema/step-attempts.js

@@ -0,0 +1,80 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { sql } from 'drizzle-orm';
+import { check, foreignKey, integer, jsonb, text, timestamp, unique, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+import { stepStatusEnum, steps } from './steps.js';
+// Append-only execution history. One row per dispatched attempt of a step,
+// inserted `running` at dispatch and finalized terminal at report. `steps` holds
+// the fast current projection; this table is the audit trail and — via the
+// unique (step_id, attempt) constraint — the idempotency anchor.
+export const stepAttempts = pgTable('step_attempts', {
+    id: uuidv7PrimaryKey(),
+    stepId: uuid('step_id').notNull().references(()=>steps.id, {
+        onDelete: 'cascade'
+    }),
+    jobExecutionId: uuid('job_execution_id').notNull(),
+    attempt: integer('attempt').notNull(),
+    executionOrder: integer('execution_order').notNull(),
+    // Reuses the step status enum, but a row is created only once dispatched, so
+    // it is never 'pending'.
+    status: stepStatusEnum('status').notNull(),
+    config: jsonb('config').$type(),
+    evaluationTrace: jsonb('evaluation_trace').$type(),
+    output: jsonb('output').$type(),
+    response: text('response'),
+    error: jsonb('error').$type(),
+    exitCode: integer('exit_code'),
+    logOutcome: text('log_outcome').$type(),
+    gateResult: jsonb('gate_result').$type(),
+    restartFeedback: text('restart_feedback'),
+    startedAt: timestamp('started_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    finishedAt: timestamp('finished_at', {
+        withTimezone: true
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        unique('workflows_step_attempts_step_id_attempt_uq').on(table.stepId, table.attempt),
+        unique('workflows_step_attempts_job_execution_id_execution_order_uq').on(table.jobExecutionId, table.executionOrder),
+        foreignKey({
+            name: 'workflows_step_attempts_step_id_job_execution_id_workflows_steps_fk',
+            columns: [
+                table.stepId,
+                table.jobExecutionId
+            ],
+            foreignColumns: [
+                steps.id,
+                steps.jobExecutionId
+            ]
+        }).onDelete('cascade'),
+        check('workflows_step_attempts_attempt_positive_ck', sql`${table.attempt} > 0`),
+        check('workflows_step_attempts_execution_order_positive_ck', sql`${table.executionOrder} > 0`),
+        check('workflows_step_attempts_status_dispatched_ck', sql`${table.status} NOT IN ('pending', 'skipped')`),
+        check('workflows_step_attempts_log_outcome_ck', sql`${table.logOutcome} IS NULL OR ${table.logOutcome} IN ('drained', 'abandoned')`)
+    ]);
+export function toStepAttempt(row) {
+    return {
+        id: row.id,
+        stepId: row.stepId,
+        attempt: row.attempt,
+        executionOrder: row.executionOrder,
+        status: row.status,
+        config: row.config ?? null,
+        evaluationTrace: row.evaluationTrace ?? null,
+        output: row.output ?? null,
+        response: row.response ?? null,
+        error: row.error ?? null,
+        exitCode: row.exitCode ?? null,
+        logOutcome: row.logOutcome ?? null,
+        gateResult: row.gateResult ?? null,
+        restartFeedback: row.restartFeedback ?? null,
+        startedAt: row.startedAt,
+        finishedAt: row.finishedAt ?? null,
+        createdAt: row.createdAt
+    };
+}
+
+//# sourceMappingURL=step-attempts.js.map

package/dist/db/schema/step-attempts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/step-attempts.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {\n  check,\n  foreignKey,\n  integer,\n  jsonb,\n  text,\n  timestamp,\n  unique,\n  uuid,\n} from 'drizzle-orm/pg-core';\nimport type {\n  PersistedEvaluationTraceEntry,\n  StepAttempt,\n  StepAttemptLogOutcome,\n  StepAttemptStatus,\n} from '#core/entities/step.js';\nimport {pgTable} from './common.js';\nimport {stepStatusEnum, steps} from './steps.js';\n\n// Append-only execution history. One row per dispatched attempt of a step,\n// inserted `running` at dispatch and finalized terminal at report. `steps` holds\n// the fast current projection; this table is the audit trail and — via the\n// unique (step_id, attempt) constraint — the idempotency anchor.\nexport const stepAttempts = pgTable(\n  'step_attempts',\n  {\n    id: uuidv7PrimaryKey(),\n    stepId: uuid('step_id')\n      .notNull()\n      .references(() => steps.id, {onDelete: 'cascade'}),\n    jobExecutionId: uuid('job_execution_id').notNull(),\n    attempt: integer('attempt').notNull(),\n    executionOrder: integer('execution_order').notNull(),\n    // Reuses the step status enum, but a row is created only once dispatched, so\n    // it is never 'pending'.\n    status: stepStatusEnum('status').notNull(),\n    config: jsonb('config').$type<Record<string, unknown>>(),\n    evaluationTrace: jsonb('evaluation_trace').$type<readonly PersistedEvaluationTraceEntry[]>(),\n    output: jsonb('output').$type<Record<string, unknown>>(),\n    response: text('response'),\n    error: jsonb('error').$type<Record<string, unknown>>(),\n    exitCode: integer('exit_code'),\n    logOutcome: text('log_outcome').$type<StepAttemptLogOutcome>(),\n    gateResult: jsonb('gate_result').$type<Record<string, unknown>>(),\n    restartFeedback: text('restart_feedback'),\n    startedAt: timestamp('started_at', {withTimezone: true}).notNull().defaultNow(),\n    finishedAt: timestamp('finished_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    unique('workflows_step_attempts_step_id_attempt_uq').on(table.stepId, table.attempt),\n    unique('workflows_step_attempts_job_execution_id_execution_order_uq').on(\n      table.jobExecutionId,\n      table.executionOrder,\n    ),\n    foreignKey({\n      name: 'workflows_step_attempts_step_id_job_execution_id_workflows_steps_fk',\n      columns: [table.stepId, table.jobExecutionId],\n      foreignColumns: [steps.id, steps.jobExecutionId],\n    }).onDelete('cascade'),\n    check('workflows_step_attempts_attempt_positive_ck', sql`${table.attempt} > 0`),\n    check('workflows_step_attempts_execution_order_positive_ck', sql`${table.executionOrder} > 0`),\n    check(\n      'workflows_step_attempts_status_dispatched_ck',\n      sql`${table.status} NOT IN ('pending', 'skipped')`,\n    ),\n    check(\n      'workflows_step_attempts_log_outcome_ck',\n      sql`${table.logOutcome} IS NULL OR ${table.logOutcome} IN ('drained', 'abandoned')`,\n    ),\n  ],\n);\n\nexport type StepAttemptDb = typeof stepAttempts.$inferSelect;\nexport type StepAttemptCreateDb = typeof stepAttempts.$inferInsert;\n\nexport function toStepAttempt(row: StepAttemptDb): StepAttempt {\n  return {\n    id: row.id,\n    stepId: row.stepId,\n    attempt: row.attempt,\n    executionOrder: row.executionOrder,\n    status: row.status as StepAttemptStatus,\n    config: (row.config as Record<string, unknown>) ?? null,\n    evaluationTrace: row.evaluationTrace ?? null,\n    output: (row.output as Record<string, unknown>) ?? null,\n    response: row.response ?? null,\n    error: (row.error as Record<string, unknown>) ?? null,\n    exitCode: row.exitCode ?? null,\n    logOutcome: row.logOutcome ?? null,\n    gateResult: (row.gateResult as Record<string, unknown>) ?? null,\n    restartFeedback: row.restartFeedback ?? null,\n    startedAt: row.startedAt,\n    finishedAt: row.finishedAt ?? null,\n    createdAt: row.createdAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","check","foreignKey","integer","jsonb","text","timestamp","unique","uuid","pgTable","stepStatusEnum","steps","stepAttempts","id","stepId","notNull","references","onDelete","jobExecutionId","attempt","executionOrder","status","config","$type","evaluationTrace","output","response","error","exitCode","logOutcome","gateResult","restartFeedback","startedAt","withTimezone","defaultNow","finishedAt","createdAt","table","on","name","columns","foreignColumns","toStepAttempt","row"],"mappings":"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"}