@shipfox/api-workflows 2.0.0

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

@@ -0,0 +1,352 @@
+import type { WorkflowExpression } from '@shipfox/expression';
+import { type PersistedEvaluationTraceEntry, type Step, type StepConfigDispatchPlan } from '#core/entities/step.js';
+export declare const stepStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "running", "succeeded", "failed", "cancelled", "skipped"]>;
+export declare const stepStatusReasonEnum: import("drizzle-orm/pg-core").PgEnum<["default_gate_rejected", "condition_rejected", "condition_errored"]>;
+export declare const steps: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "steps";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "steps";
+            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;
+        }, {}, {}>;
+        jobExecutionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "job_execution_id";
+            tableName: "steps";
+            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;
+        }, {}, {}>;
+        key: import("drizzle-orm/pg-core").PgColumn<{
+            name: "key";
+            tableName: "steps";
+            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;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "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;
+        }, {}, {}>;
+        sourceLocation: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_location";
+            tableName: "steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: import("#core/entities/step.js").StepSourceLocation | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: import("#core/entities/step.js").StepSourceLocation | null;
+        }>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "steps";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "pending" | "running" | "succeeded" | "failed" | "cancelled" | "skipped";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pending", "running", "succeeded", "failed", "cancelled", "skipped"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        statusReason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status_reason";
+            tableName: "steps";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "default_gate_rejected" | "condition_rejected" | "condition_errored";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["default_gate_rejected", "condition_rejected", "condition_errored"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        evaluationTrace: import("drizzle-orm/pg-core").PgColumn<{
+            name: "evaluation_trace";
+            tableName: "steps";
+            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[];
+        }>;
+        type: import("drizzle-orm/pg-core").PgColumn<{
+            name: "type";
+            tableName: "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;
+        }, {}, {}>;
+        config: import("drizzle-orm/pg-core").PgColumn<{
+            name: "config";
+            tableName: "steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        condition: import("drizzle-orm/pg-core").PgColumn<{
+            name: "condition";
+            tableName: "steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: WorkflowExpression;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: WorkflowExpression;
+        }>;
+        configPlan: import("drizzle-orm/pg-core").PgColumn<{
+            name: "config_plan";
+            tableName: "steps";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: StepConfigDispatchPlan;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: StepConfigDispatchPlan;
+        }>;
+        authoredConfig: import("drizzle-orm/pg-core").PgColumn<{
+            name: "authored_config";
+            tableName: "steps";
+            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>;
+        }>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: "steps";
+            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>;
+        }>;
+        position: import("drizzle-orm/pg-core").PgColumn<{
+            name: "position";
+            tableName: "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;
+        }, {}, {}>;
+        version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version";
+            tableName: "steps";
+            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;
+        }, {}, {}>;
+        currentAttempt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "current_attempt";
+            tableName: "steps";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type StepDb = typeof steps.$inferSelect;
+export type StepCreateDb = typeof steps.$inferInsert;
+export declare function toStep(row: StepDb): Step;
+//# sourceMappingURL=steps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"steps.d.ts","sourceRoot":"","sources":["../../../src/db/schema/steps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,qBAAqB,CAAC;AAe5D,OAAO,EACL,KAAK,6BAA6B,EAElC,KAAK,IAAI,EACT,KAAK,sBAAsB,EAE5B,MAAM,wBAAwB,CAAC;AAIhC,eAAO,MAAM,cAAc,6GAOzB,CAAC;AAEH,eAAO,MAAM,oBAAoB,4GAA8D,CAAC;AAEhG,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCjB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC;AAC/C,MAAM,MAAM,YAAY,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC;AAErD,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAsBxC"}

package/dist/db/schema/steps.js

@@ -0,0 +1,80 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { sql } from 'drizzle-orm';
+import { check, foreignKey, index, integer, jsonb, pgEnum, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { STEP_STATUS_REASONS, toStepStatusReason } from '#core/entities/step.js';
+import { pgTable } from './common.js';
+import { jobExecutions } from './job-executions.js';
+export const stepStatusEnum = pgEnum('workflows_step_status', [
+    'pending',
+    'running',
+    'succeeded',
+    'failed',
+    'cancelled',
+    'skipped'
+]);
+export const stepStatusReasonEnum = pgEnum('workflows_step_status_reason', STEP_STATUS_REASONS);
+export const steps = pgTable('steps', {
+    id: uuidv7PrimaryKey(),
+    jobExecutionId: uuid('job_execution_id').notNull(),
+    key: text('key'),
+    name: text('name').notNull(),
+    sourceLocation: jsonb('source_location').$type(),
+    status: stepStatusEnum('status').notNull().default('pending'),
+    statusReason: stepStatusReasonEnum('status_reason'),
+    evaluationTrace: jsonb('evaluation_trace').$type(),
+    type: text('type').notNull(),
+    config: jsonb('config').notNull().$type(),
+    condition: jsonb('condition').$type(),
+    configPlan: jsonb('config_plan').$type(),
+    authoredConfig: jsonb('authored_config').$type(),
+    error: jsonb('error').$type(),
+    position: integer('position').notNull(),
+    version: integer('version').notNull().default(1),
+    // Execution-attempt identity, distinct from the optimistic `version` counter.
+    // Starts at 1 and is bumped only on durable rewind.
+    currentAttempt: integer('current_attempt').notNull().default(1),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        index('workflows_steps_job_execution_id_idx').on(table.jobExecutionId),
+        uniqueIndex('workflows_steps_id_job_execution_id_uq').on(table.id, table.jobExecutionId),
+        check('workflows_steps_current_attempt_positive_ck', sql`${table.currentAttempt} > 0`),
+        foreignKey({
+            name: 'workflows_steps_job_execution_id_workflows_job_executions_id_fk',
+            columns: [
+                table.jobExecutionId
+            ],
+            foreignColumns: [
+                jobExecutions.id
+            ]
+        }).onDelete('cascade')
+    ]);
+export function toStep(row) {
+    return {
+        id: row.id,
+        jobExecutionId: row.jobExecutionId,
+        key: row.key,
+        name: row.name,
+        sourceLocation: row.sourceLocation ?? null,
+        status: row.status,
+        statusReason: toStepStatusReason(row.statusReason),
+        evaluationTrace: row.evaluationTrace ?? null,
+        type: row.type,
+        config: row.config,
+        condition: row.condition ?? null,
+        configPlan: row.configPlan ?? null,
+        authoredConfig: row.authoredConfig ?? null,
+        error: row.error ?? null,
+        position: row.position,
+        version: row.version,
+        currentAttempt: row.currentAttempt,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+    };
+}
+
+//# sourceMappingURL=steps.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/steps.ts"],"sourcesContent":["import type {WorkflowExpression} from '@shipfox/expression';\nimport {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {\n  check,\n  foreignKey,\n  index,\n  integer,\n  jsonb,\n  pgEnum,\n  text,\n  timestamp,\n  uniqueIndex,\n  uuid,\n} from 'drizzle-orm/pg-core';\nimport {\n  type PersistedEvaluationTraceEntry,\n  STEP_STATUS_REASONS,\n  type Step,\n  type StepConfigDispatchPlan,\n  toStepStatusReason,\n} from '#core/entities/step.js';\nimport {pgTable} from './common.js';\nimport {jobExecutions} from './job-executions.js';\n\nexport const stepStatusEnum = pgEnum('workflows_step_status', [\n  'pending',\n  'running',\n  'succeeded',\n  'failed',\n  'cancelled',\n  'skipped',\n]);\n\nexport const stepStatusReasonEnum = pgEnum('workflows_step_status_reason', STEP_STATUS_REASONS);\n\nexport const steps = pgTable(\n  'steps',\n  {\n    id: uuidv7PrimaryKey(),\n    jobExecutionId: uuid('job_execution_id').notNull(),\n    key: text('key'),\n    name: text('name').notNull(),\n    sourceLocation: jsonb('source_location').$type<Step['sourceLocation']>(),\n    status: stepStatusEnum('status').notNull().default('pending'),\n    statusReason: stepStatusReasonEnum('status_reason'),\n    evaluationTrace: jsonb('evaluation_trace').$type<readonly PersistedEvaluationTraceEntry[]>(),\n    type: text('type').notNull(),\n    config: jsonb('config').notNull().$type<Record<string, unknown>>(),\n    condition: jsonb('condition').$type<WorkflowExpression>(),\n    configPlan: jsonb('config_plan').$type<StepConfigDispatchPlan>(),\n    authoredConfig: jsonb('authored_config').$type<Record<string, unknown>>(),\n    error: jsonb('error').$type<Record<string, unknown>>(),\n    position: integer('position').notNull(),\n    version: integer('version').notNull().default(1),\n    // Execution-attempt identity, distinct from the optimistic `version` counter.\n    // Starts at 1 and is bumped only on durable rewind.\n    currentAttempt: integer('current_attempt').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_steps_job_execution_id_idx').on(table.jobExecutionId),\n    uniqueIndex('workflows_steps_id_job_execution_id_uq').on(table.id, table.jobExecutionId),\n    check('workflows_steps_current_attempt_positive_ck', sql`${table.currentAttempt} > 0`),\n    foreignKey({\n      name: 'workflows_steps_job_execution_id_workflows_job_executions_id_fk',\n      columns: [table.jobExecutionId],\n      foreignColumns: [jobExecutions.id],\n    }).onDelete('cascade'),\n  ],\n);\n\nexport type StepDb = typeof steps.$inferSelect;\nexport type StepCreateDb = typeof steps.$inferInsert;\n\nexport function toStep(row: StepDb): Step {\n  return {\n    id: row.id,\n    jobExecutionId: row.jobExecutionId,\n    key: row.key,\n    name: row.name,\n    sourceLocation: row.sourceLocation ?? null,\n    status: row.status,\n    statusReason: toStepStatusReason(row.statusReason),\n    evaluationTrace: row.evaluationTrace ?? null,\n    type: row.type,\n    config: row.config as Record<string, unknown>,\n    condition: (row.condition as WorkflowExpression) ?? null,\n    configPlan: row.configPlan ?? null,\n    authoredConfig: (row.authoredConfig as Record<string, unknown>) ?? null,\n    error: (row.error as Record<string, unknown>) ?? null,\n    position: row.position,\n    version: row.version,\n    currentAttempt: row.currentAttempt,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","check","foreignKey","index","integer","jsonb","pgEnum","text","timestamp","uniqueIndex","uuid","STEP_STATUS_REASONS","toStepStatusReason","pgTable","jobExecutions","stepStatusEnum","stepStatusReasonEnum","steps","id","jobExecutionId","notNull","key","name","sourceLocation","$type","status","default","statusReason","evaluationTrace","type","config","condition","configPlan","authoredConfig","error","position","version","currentAttempt","createdAt","withTimezone","defaultNow","updatedAt","table","on","columns","foreignColumns","onDelete","toStep","row"],"mappings":"AACA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,GAAG,QAAO,cAAc;AAChC,SACEC,KAAK,EACLC,UAAU,EACVC,KAAK,EACLC,OAAO,EACPC,KAAK,EACLC,MAAM,EACNC,IAAI,EACJC,SAAS,EACTC,WAAW,EACXC,IAAI,QACC,sBAAsB;AAC7B,SAEEC,mBAAmB,EAGnBC,kBAAkB,QACb,yBAAyB;AAChC,SAAQC,OAAO,QAAO,cAAc;AACpC,SAAQC,aAAa,QAAO,sBAAsB;AAElD,OAAO,MAAMC,iBAAiBT,OAAO,yBAAyB;IAC5D;IACA;IACA;IACA;IACA;IACA;CACD,EAAE;AAEH,OAAO,MAAMU,uBAAuBV,OAAO,gCAAgCK,qBAAqB;AAEhG,OAAO,MAAMM,QAAQJ,QACnB,SACA;IACEK,IAAInB;IACJoB,gBAAgBT,KAAK,oBAAoBU,OAAO;IAChDC,KAAKd,KAAK;IACVe,MAAMf,KAAK,QAAQa,OAAO;IAC1BG,gBAAgBlB,MAAM,mBAAmBmB,KAAK;IAC9CC,QAAQV,eAAe,UAAUK,OAAO,GAAGM,OAAO,CAAC;IACnDC,cAAcX,qBAAqB;IACnCY,iBAAiBvB,MAAM,oBAAoBmB,KAAK;IAChDK,MAAMtB,KAAK,QAAQa,OAAO;IAC1BU,QAAQzB,MAAM,UAAUe,OAAO,GAAGI,KAAK;IACvCO,WAAW1B,MAAM,aAAamB,KAAK;IACnCQ,YAAY3B,MAAM,eAAemB,KAAK;IACtCS,gBAAgB5B,MAAM,mBAAmBmB,KAAK;IAC9CU,OAAO7B,MAAM,SAASmB,KAAK;IAC3BW,UAAU/B,QAAQ,YAAYgB,OAAO;IACrCgB,SAAShC,QAAQ,WAAWgB,OAAO,GAAGM,OAAO,CAAC;IAC9C,8EAA8E;IAC9E,oDAAoD;IACpDW,gBAAgBjC,QAAQ,mBAAmBgB,OAAO,GAAGM,OAAO,CAAC;IAC7DY,WAAW9B,UAAU,cAAc;QAAC+B,cAAc;IAAI,GAAGnB,OAAO,GAAGoB,UAAU;IAC7EC,WAAWjC,UAAU,cAAc;QAAC+B,cAAc;IAAI,GAAGnB,OAAO,GAAGoB,UAAU;AAC/E,GACA,CAACE,QAAU;QACTvC,MAAM,wCAAwCwC,EAAE,CAACD,MAAMvB,cAAc;QACrEV,YAAY,0CAA0CkC,EAAE,CAACD,MAAMxB,EAAE,EAAEwB,MAAMvB,cAAc;QACvFlB,MAAM,+CAA+CD,GAAG,CAAC,EAAE0C,MAAML,cAAc,CAAC,IAAI,CAAC;QACrFnC,WAAW;YACToB,MAAM;YACNsB,SAAS;gBAACF,MAAMvB,cAAc;aAAC;YAC/B0B,gBAAgB;gBAAC/B,cAAcI,EAAE;aAAC;QACpC,GAAG4B,QAAQ,CAAC;KACb,EACD;AAKF,OAAO,SAASC,OAAOC,GAAW;IAChC,OAAO;QACL9B,IAAI8B,IAAI9B,EAAE;QACVC,gBAAgB6B,IAAI7B,cAAc;QAClCE,KAAK2B,IAAI3B,GAAG;QACZC,MAAM0B,IAAI1B,IAAI;QACdC,gBAAgByB,IAAIzB,cAAc,IAAI;QACtCE,QAAQuB,IAAIvB,MAAM;QAClBE,cAAcf,mBAAmBoC,IAAIrB,YAAY;QACjDC,iBAAiBoB,IAAIpB,eAAe,IAAI;QACxCC,MAAMmB,IAAInB,IAAI;QACdC,QAAQkB,IAAIlB,MAAM;QAClBC,WAAW,AAACiB,IAAIjB,SAAS,IAA2B;QACpDC,YAAYgB,IAAIhB,UAAU,IAAI;QAC9BC,gBAAgB,AAACe,IAAIf,cAAc,IAAgC;QACnEC,OAAO,AAACc,IAAId,KAAK,IAAgC;QACjDC,UAAUa,IAAIb,QAAQ;QACtBC,SAASY,IAAIZ,OAAO;QACpBC,gBAAgBW,IAAIX,cAAc;QAClCC,WAAWU,IAAIV,SAAS;QACxBG,WAAWO,IAAIP,SAAS;IAC1B;AACF"}

package/dist/db/schema/workflow-run-attempts.d.ts

@@ -0,0 +1,239 @@
+import type { WorkflowModel } from '@shipfox/api-definitions';
+import type { AgentToolMaterializationSnapshot } from '#core/agent-tools.js';
+import type { WorkflowRunAttempt } from '#core/entities/workflow-run-attempt.js';
+export declare const workflowRunAttempts: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_run_attempts";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "workflow_run_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;
+        }, {}, {}>;
+        workflowRunId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workflow_run_id";
+            tableName: "workflow_run_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: "workflow_run_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: "workflow_run_attempts";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "pending" | "running" | "succeeded" | "failed" | "cancelled";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pending", "running", "succeeded", "failed", "cancelled"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        rerunMode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "rerun_mode";
+            tableName: "workflow_run_attempts";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "failed" | "all";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["all", "failed"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        rerunByUserId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "rerun_by_user_id";
+            tableName: "workflow_run_attempts";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        model: import("drizzle-orm/pg-core").PgColumn<{
+            name: "model";
+            tableName: "workflow_run_attempts";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: WorkflowModel;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: WorkflowModel;
+        }>;
+        agentToolMaterialization: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_tool_materialization";
+            tableName: "workflow_run_attempts";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: AgentToolMaterializationSnapshot;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: AgentToolMaterializationSnapshot;
+        }>;
+        version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version";
+            tableName: "workflow_run_attempts";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "workflow_run_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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "workflow_run_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;
+        }, {}, {}>;
+        startedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "started_at";
+            tableName: "workflow_run_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;
+        }, {}, {}>;
+        finishedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "finished_at";
+            tableName: "workflow_run_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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type WorkflowRunAttemptDb = typeof workflowRunAttempts.$inferSelect;
+export type WorkflowRunAttemptCreateDb = typeof workflowRunAttempts.$inferInsert;
+export declare function toWorkflowRunAttempt(row: WorkflowRunAttemptDb): WorkflowRunAttempt;
+//# sourceMappingURL=workflow-run-attempts.d.ts.map