@shipfox/api-workflows 2.0.0

package/dist/db/schema/common.js

@@ -0,0 +1,4 @@
+import { pgTableCreator } from 'drizzle-orm/pg-core';
+export const pgTable = pgTableCreator((name)=>`workflows_${name}`);
+
+//# sourceMappingURL=common.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/common.ts"],"sourcesContent":["import {pgTableCreator} from 'drizzle-orm/pg-core';\n\nexport const pgTable = pgTableCreator((name) => `workflows_${name}`);\n"],"names":["pgTableCreator","pgTable","name"],"mappings":"AAAA,SAAQA,cAAc,QAAO,sBAAsB;AAEnD,OAAO,MAAMC,UAAUD,eAAe,CAACE,OAAS,CAAC,UAAU,EAAEA,MAAM,EAAE"}

package/dist/db/schema/job-executions.d.ts

@@ -0,0 +1,311 @@
+import type { JobExecution, WorkflowExecutionEvent } from '#core/entities/job-execution.js';
+import type { PersistedEvaluationTraceEntry } from '#core/entities/step.js';
+export declare const jobExecutionStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "running", "succeeded", "failed", "cancelled"]>;
+export declare const jobExecutions: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "job_executions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "job_executions";
+            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;
+        }, {}, {}>;
+        jobId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "job_id";
+            tableName: "job_executions";
+            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;
+        }, {}, {}>;
+        sequence: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sequence";
+            tableName: "job_executions";
+            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;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "job_executions";
+            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;
+        }, {}, {}>;
+        runner: import("drizzle-orm/pg-core").PgColumn<{
+            name: "runner";
+            tableName: "job_executions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            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: "job_executions";
+            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;
+        }, {}, {}>;
+        statusReason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status_reason";
+            tableName: "job_executions";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "default_gate_rejected" | "condition_rejected" | "condition_errored" | "dependency_not_completed" | "condition_false" | "user_cancelled" | "run_cancelled" | "timed_out" | "runner_lost" | "step_failed" | "unknown";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["dependency_not_completed", "condition_false", "default_gate_rejected", "condition_rejected", "condition_errored", "user_cancelled", "run_cancelled", "timed_out", "runner_lost", "step_failed", "unknown"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        triggerEvents: import("drizzle-orm/pg-core").PgColumn<{
+            name: "trigger_events";
+            tableName: "job_executions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: WorkflowExecutionEvent[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: WorkflowExecutionEvent[];
+        }>;
+        outputs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "outputs";
+            tableName: "job_executions";
+            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;
+        }>;
+        evaluationTrace: import("drizzle-orm/pg-core").PgColumn<{
+            name: "evaluation_trace";
+            tableName: "job_executions";
+            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[];
+        }>;
+        version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version";
+            tableName: "job_executions";
+            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: "job_executions";
+            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: "job_executions";
+            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;
+        }, {}, {}>;
+        queuedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "queued_at";
+            tableName: "job_executions";
+            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;
+        }, {}, {}>;
+        startedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "started_at";
+            tableName: "job_executions";
+            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: "job_executions";
+            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;
+        }, {}, {}>;
+        timedOutAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "timed_out_at";
+            tableName: "job_executions";
+            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 JobExecutionDb = typeof jobExecutions.$inferSelect;
+export type JobExecutionCreateDb = typeof jobExecutions.$inferInsert;
+export declare function toJobExecution(row: JobExecutionDb): JobExecution;
+//# sourceMappingURL=job-executions.d.ts.map

package/dist/db/schema/job-executions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-executions.d.ts","sourceRoot":"","sources":["../../../src/db/schema/job-executions.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAC,YAAY,EAAE,sBAAsB,EAAC,MAAM,iCAAiC,CAAC;AAC1F,OAAO,KAAK,EAAC,6BAA6B,EAAC,MAAM,wBAAwB,CAAC;AAI1E,eAAO,MAAM,sBAAsB,kGAMjC,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCzB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,OAAO,aAAa,CAAC,YAAY,CAAC;AAC/D,MAAM,MAAM,oBAAoB,GAAG,OAAO,aAAa,CAAC,YAAY,CAAC;AAErE,wBAAgB,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,YAAY,CAoBhE"}

package/dist/db/schema/job-executions.js

@@ -0,0 +1,76 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { sql } from 'drizzle-orm';
+import { index, integer, jsonb, pgEnum, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { toJobStatusReason } from '#core/entities/job.js';
+import { pgTable } from './common.js';
+import { jobStatusReasonEnum, jobs } from './jobs.js';
+export const jobExecutionStatusEnum = pgEnum('workflows_job_execution_status', [
+    'pending',
+    'running',
+    'succeeded',
+    'failed',
+    'cancelled'
+]);
+export const jobExecutions = pgTable('job_executions', {
+    id: uuidv7PrimaryKey(),
+    jobId: uuid('job_id').notNull().references(()=>jobs.id, {
+        onDelete: 'cascade'
+    }),
+    sequence: integer('sequence').notNull(),
+    name: text('name').notNull(),
+    runner: jsonb('runner').$type(),
+    status: jobExecutionStatusEnum('status').notNull().default('pending'),
+    statusReason: jobStatusReasonEnum('status_reason'),
+    triggerEvents: jsonb('trigger_events').notNull().default([]).$type(),
+    outputs: jsonb('outputs').$type(),
+    evaluationTrace: jsonb('evaluation_trace').$type(),
+    version: integer('version').notNull().default(1),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    queuedAt: timestamp('queued_at', {
+        withTimezone: true
+    }),
+    startedAt: timestamp('started_at', {
+        withTimezone: true
+    }),
+    finishedAt: timestamp('finished_at', {
+        withTimezone: true
+    }),
+    timedOutAt: timestamp('timed_out_at', {
+        withTimezone: true
+    })
+}, (table)=>[
+        index('workflows_job_executions_job_id_idx').on(table.jobId),
+        // Partial index backing the running-executions depth gauge, which counts on
+        // every Prometheus scrape. Indexes only active rows so the count stays cheap
+        // as the historical table grows.
+        index('workflows_job_executions_running_idx').on(table.status).where(sql`${table.status} = 'running'`),
+        uniqueIndex('workflows_job_executions_job_sequence_uq').on(table.jobId, table.sequence)
+    ]);
+export function toJobExecution(row) {
+    return {
+        id: row.id,
+        jobId: row.jobId,
+        sequence: row.sequence,
+        name: row.name,
+        runner: row.runner,
+        status: row.status,
+        statusReason: toJobStatusReason(row.statusReason),
+        triggerEvents: row.triggerEvents,
+        outputs: row.outputs,
+        evaluationTrace: row.evaluationTrace ?? null,
+        version: row.version,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        queuedAt: row.queuedAt,
+        startedAt: row.startedAt,
+        finishedAt: row.finishedAt,
+        timedOutAt: row.timedOutAt
+    };
+}
+
+//# sourceMappingURL=job-executions.js.map

package/dist/db/schema/job-executions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/job-executions.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {\n  index,\n  integer,\n  jsonb,\n  pgEnum,\n  text,\n  timestamp,\n  uniqueIndex,\n  uuid,\n} from 'drizzle-orm/pg-core';\nimport {toJobStatusReason} from '#core/entities/job.js';\nimport type {JobExecution, WorkflowExecutionEvent} from '#core/entities/job-execution.js';\nimport type {PersistedEvaluationTraceEntry} from '#core/entities/step.js';\nimport {pgTable} from './common.js';\nimport {jobStatusReasonEnum, jobs} from './jobs.js';\n\nexport const jobExecutionStatusEnum = pgEnum('workflows_job_execution_status', [\n  'pending',\n  'running',\n  'succeeded',\n  'failed',\n  'cancelled',\n]);\n\nexport const jobExecutions = pgTable(\n  'job_executions',\n  {\n    id: uuidv7PrimaryKey(),\n    jobId: uuid('job_id')\n      .notNull()\n      .references(() => jobs.id, {onDelete: 'cascade'}),\n    sequence: integer('sequence').notNull(),\n    name: text('name').notNull(),\n    runner: jsonb('runner').$type<string[]>(),\n    status: jobExecutionStatusEnum('status').notNull().default('pending'),\n    statusReason: jobStatusReasonEnum('status_reason'),\n    triggerEvents: jsonb('trigger_events').notNull().default([]).$type<WorkflowExecutionEvent[]>(),\n    outputs: jsonb('outputs').$type<Record<string, unknown> | null>(),\n    evaluationTrace: jsonb('evaluation_trace').$type<readonly PersistedEvaluationTraceEntry[]>(),\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    queuedAt: timestamp('queued_at', {withTimezone: true}),\n    startedAt: timestamp('started_at', {withTimezone: true}),\n    finishedAt: timestamp('finished_at', {withTimezone: true}),\n    timedOutAt: timestamp('timed_out_at', {withTimezone: true}),\n  },\n  (table) => [\n    index('workflows_job_executions_job_id_idx').on(table.jobId),\n    // Partial index backing the running-executions depth gauge, which counts on\n    // every Prometheus scrape. Indexes only active rows so the count stays cheap\n    // as the historical table grows.\n    index('workflows_job_executions_running_idx')\n      .on(table.status)\n      .where(sql`${table.status} = 'running'`),\n    uniqueIndex('workflows_job_executions_job_sequence_uq').on(table.jobId, table.sequence),\n  ],\n);\n\nexport type JobExecutionDb = typeof jobExecutions.$inferSelect;\nexport type JobExecutionCreateDb = typeof jobExecutions.$inferInsert;\n\nexport function toJobExecution(row: JobExecutionDb): JobExecution {\n  return {\n    id: row.id,\n    jobId: row.jobId,\n    sequence: row.sequence,\n    name: row.name,\n    runner: row.runner as string[] | null,\n    status: row.status,\n    statusReason: toJobStatusReason(row.statusReason),\n    triggerEvents: row.triggerEvents,\n    outputs: row.outputs,\n    evaluationTrace: row.evaluationTrace ?? null,\n    version: row.version,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n    queuedAt: row.queuedAt,\n    startedAt: row.startedAt,\n    finishedAt: row.finishedAt,\n    timedOutAt: row.timedOutAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","index","integer","jsonb","pgEnum","text","timestamp","uniqueIndex","uuid","toJobStatusReason","pgTable","jobStatusReasonEnum","jobs","jobExecutionStatusEnum","jobExecutions","id","jobId","notNull","references","onDelete","sequence","name","runner","$type","status","default","statusReason","triggerEvents","outputs","evaluationTrace","version","createdAt","withTimezone","defaultNow","updatedAt","queuedAt","startedAt","finishedAt","timedOutAt","table","on","where","toJobExecution","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,GAAG,QAAO,cAAc;AAChC,SACEC,KAAK,EACLC,OAAO,EACPC,KAAK,EACLC,MAAM,EACNC,IAAI,EACJC,SAAS,EACTC,WAAW,EACXC,IAAI,QACC,sBAAsB;AAC7B,SAAQC,iBAAiB,QAAO,wBAAwB;AAGxD,SAAQC,OAAO,QAAO,cAAc;AACpC,SAAQC,mBAAmB,EAAEC,IAAI,QAAO,YAAY;AAEpD,OAAO,MAAMC,yBAAyBT,OAAO,kCAAkC;IAC7E;IACA;IACA;IACA;IACA;CACD,EAAE;AAEH,OAAO,MAAMU,gBAAgBJ,QAC3B,kBACA;IACEK,IAAIhB;IACJiB,OAAOR,KAAK,UACTS,OAAO,GACPC,UAAU,CAAC,IAAMN,KAAKG,EAAE,EAAE;QAACI,UAAU;IAAS;IACjDC,UAAUlB,QAAQ,YAAYe,OAAO;IACrCI,MAAMhB,KAAK,QAAQY,OAAO;IAC1BK,QAAQnB,MAAM,UAAUoB,KAAK;IAC7BC,QAAQX,uBAAuB,UAAUI,OAAO,GAAGQ,OAAO,CAAC;IAC3DC,cAAcf,oBAAoB;IAClCgB,eAAexB,MAAM,kBAAkBc,OAAO,GAAGQ,OAAO,CAAC,EAAE,EAAEF,KAAK;IAClEK,SAASzB,MAAM,WAAWoB,KAAK;IAC/BM,iBAAiB1B,MAAM,oBAAoBoB,KAAK;IAChDO,SAAS5B,QAAQ,WAAWe,OAAO,GAAGQ,OAAO,CAAC;IAC9CM,WAAWzB,UAAU,cAAc;QAAC0B,cAAc;IAAI,GAAGf,OAAO,GAAGgB,UAAU;IAC7EC,WAAW5B,UAAU,cAAc;QAAC0B,cAAc;IAAI,GAAGf,OAAO,GAAGgB,UAAU;IAC7EE,UAAU7B,UAAU,aAAa;QAAC0B,cAAc;IAAI;IACpDI,WAAW9B,UAAU,cAAc;QAAC0B,cAAc;IAAI;IACtDK,YAAY/B,UAAU,eAAe;QAAC0B,cAAc;IAAI;IACxDM,YAAYhC,UAAU,gBAAgB;QAAC0B,cAAc;IAAI;AAC3D,GACA,CAACO,QAAU;QACTtC,MAAM,uCAAuCuC,EAAE,CAACD,MAAMvB,KAAK;QAC3D,4EAA4E;QAC5E,6EAA6E;QAC7E,iCAAiC;QACjCf,MAAM,wCACHuC,EAAE,CAACD,MAAMf,MAAM,EACfiB,KAAK,CAACzC,GAAG,CAAC,EAAEuC,MAAMf,MAAM,CAAC,YAAY,CAAC;QACzCjB,YAAY,4CAA4CiC,EAAE,CAACD,MAAMvB,KAAK,EAAEuB,MAAMnB,QAAQ;KACvF,EACD;AAKF,OAAO,SAASsB,eAAeC,GAAmB;IAChD,OAAO;QACL5B,IAAI4B,IAAI5B,EAAE;QACVC,OAAO2B,IAAI3B,KAAK;QAChBI,UAAUuB,IAAIvB,QAAQ;QACtBC,MAAMsB,IAAItB,IAAI;QACdC,QAAQqB,IAAIrB,MAAM;QAClBE,QAAQmB,IAAInB,MAAM;QAClBE,cAAcjB,kBAAkBkC,IAAIjB,YAAY;QAChDC,eAAegB,IAAIhB,aAAa;QAChCC,SAASe,IAAIf,OAAO;QACpBC,iBAAiBc,IAAId,eAAe,IAAI;QACxCC,SAASa,IAAIb,OAAO;QACpBC,WAAWY,IAAIZ,SAAS;QACxBG,WAAWS,IAAIT,SAAS;QACxBC,UAAUQ,IAAIR,QAAQ;QACtBC,WAAWO,IAAIP,SAAS;QACxBC,YAAYM,IAAIN,UAAU;QAC1BC,YAAYK,IAAIL,UAAU;IAC5B;AACF"}

package/dist/db/schema/job-listener-events.d.ts

@@ -0,0 +1,200 @@
+import type { JobListenerEvent } from '#core/entities/job-listener-event.js';
+export declare const jobListenerEventDispositionEnum: import("drizzle-orm/pg-core").PgEnum<["fire", "resolve"]>;
+export declare const jobListenerEvents: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "job_listener_events";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "job_listener_events";
+            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;
+        }, {}, {}>;
+        jobId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "job_id";
+            tableName: "job_listener_events";
+            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;
+        }, {}, {}>;
+        disposition: import("drizzle-orm/pg-core").PgColumn<{
+            name: "disposition";
+            tableName: "job_listener_events";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "fire" | "resolve";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["fire", "resolve"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventRef: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_ref";
+            tableName: "job_listener_events";
+            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;
+        }, {}, {}>;
+        deliveryId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "delivery_id";
+            tableName: "job_listener_events";
+            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;
+        }, {}, {}>;
+        source: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source";
+            tableName: "job_listener_events";
+            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;
+        }, {}, {}>;
+        event: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event";
+            tableName: "job_listener_events";
+            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;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "job_listener_events";
+            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;
+        }, {}, {}>;
+        receivedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "received_at";
+            tableName: "job_listener_events";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        consumedByExecutionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "consumed_by_execution_id";
+            tableName: "job_listener_events";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "job_listener_events";
+            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 JobListenerEventDb = typeof jobListenerEvents.$inferSelect;
+export type JobListenerEventCreateDb = typeof jobListenerEvents.$inferInsert;
+export declare function toJobListenerEvent(row: JobListenerEventDb): JobListenerEvent;
+//# sourceMappingURL=job-listener-events.d.ts.map

package/dist/db/schema/job-listener-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-listener-events.d.ts","sourceRoot":"","sources":["../../../src/db/schema/job-listener-events.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,sCAAsC,CAAC;AAK3E,eAAO,MAAM,+BAA+B,2DAG1C,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B7B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAC;AACvE,MAAM,MAAM,wBAAwB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAC;AAE7E,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,kBAAkB,GAAG,gBAAgB,CAc5E"}

package/dist/db/schema/job-listener-events.js

@@ -0,0 +1,50 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { index, jsonb, pgEnum, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+import { jobExecutions } from './job-executions.js';
+import { jobs } from './jobs.js';
+export const jobListenerEventDispositionEnum = pgEnum('workflows_job_listener_event_disposition', [
+    'fire',
+    'resolve'
+]);
+export const jobListenerEvents = pgTable('job_listener_events', {
+    id: uuidv7PrimaryKey(),
+    jobId: uuid('job_id').notNull().references(()=>jobs.id, {
+        onDelete: 'cascade'
+    }),
+    disposition: jobListenerEventDispositionEnum('disposition').notNull(),
+    eventRef: text('event_ref').notNull(),
+    deliveryId: text('delivery_id').notNull(),
+    source: text('source').notNull(),
+    event: text('event').notNull(),
+    payload: jsonb('payload').notNull(),
+    receivedAt: timestamp('received_at', {
+        withTimezone: true
+    }).notNull(),
+    consumedByExecutionId: uuid('consumed_by_execution_id').references(()=>jobExecutions.id, {
+        onDelete: 'set null'
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('workflows_job_listener_events_job_event_ref_unique').on(table.jobId, table.eventRef),
+        index('workflows_job_listener_events_job_received_idx').on(table.jobId, table.receivedAt)
+    ]);
+export function toJobListenerEvent(row) {
+    return {
+        id: row.id,
+        jobId: row.jobId,
+        disposition: row.disposition,
+        eventRef: row.eventRef,
+        deliveryId: row.deliveryId,
+        source: row.source,
+        event: row.event,
+        payload: row.payload,
+        receivedAt: row.receivedAt,
+        consumedByExecutionId: row.consumedByExecutionId,
+        createdAt: row.createdAt
+    };
+}
+
+//# sourceMappingURL=job-listener-events.js.map