@shipfox/api-workflows 2.0.0

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/job-listener-events.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {index, jsonb, pgEnum, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {JobListenerEvent} from '#core/entities/job-listener-event.js';\nimport {pgTable} from './common.js';\nimport {jobExecutions} from './job-executions.js';\nimport {jobs} from './jobs.js';\n\nexport const jobListenerEventDispositionEnum = pgEnum('workflows_job_listener_event_disposition', [\n  'fire',\n  'resolve',\n]);\n\nexport const jobListenerEvents = pgTable(\n  'job_listener_events',\n  {\n    id: uuidv7PrimaryKey(),\n    jobId: uuid('job_id')\n      .notNull()\n      .references(() => jobs.id, {onDelete: 'cascade'}),\n    disposition: jobListenerEventDispositionEnum('disposition').notNull(),\n    eventRef: text('event_ref').notNull(),\n    deliveryId: text('delivery_id').notNull(),\n    source: text('source').notNull(),\n    event: text('event').notNull(),\n    payload: jsonb('payload').notNull(),\n    receivedAt: timestamp('received_at', {withTimezone: true}).notNull(),\n    consumedByExecutionId: uuid('consumed_by_execution_id').references(() => jobExecutions.id, {\n      onDelete: 'set null',\n    }),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('workflows_job_listener_events_job_event_ref_unique').on(\n      table.jobId,\n      table.eventRef,\n    ),\n    index('workflows_job_listener_events_job_received_idx').on(table.jobId, table.receivedAt),\n  ],\n);\n\nexport type JobListenerEventDb = typeof jobListenerEvents.$inferSelect;\nexport type JobListenerEventCreateDb = typeof jobListenerEvents.$inferInsert;\n\nexport function toJobListenerEvent(row: JobListenerEventDb): JobListenerEvent {\n  return {\n    id: row.id,\n    jobId: row.jobId,\n    disposition: row.disposition,\n    eventRef: row.eventRef,\n    deliveryId: row.deliveryId,\n    source: row.source,\n    event: row.event,\n    payload: row.payload,\n    receivedAt: row.receivedAt,\n    consumedByExecutionId: row.consumedByExecutionId,\n    createdAt: row.createdAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","index","jsonb","pgEnum","text","timestamp","uniqueIndex","uuid","pgTable","jobExecutions","jobs","jobListenerEventDispositionEnum","jobListenerEvents","id","jobId","notNull","references","onDelete","disposition","eventRef","deliveryId","source","event","payload","receivedAt","withTimezone","consumedByExecutionId","createdAt","defaultNow","table","on","toJobListenerEvent","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,KAAK,EAAEC,KAAK,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAE7F,SAAQC,OAAO,QAAO,cAAc;AACpC,SAAQC,aAAa,QAAO,sBAAsB;AAClD,SAAQC,IAAI,QAAO,YAAY;AAE/B,OAAO,MAAMC,kCAAkCR,OAAO,4CAA4C;IAChG;IACA;CACD,EAAE;AAEH,OAAO,MAAMS,oBAAoBJ,QAC/B,uBACA;IACEK,IAAIb;IACJc,OAAOP,KAAK,UACTQ,OAAO,GACPC,UAAU,CAAC,IAAMN,KAAKG,EAAE,EAAE;QAACI,UAAU;IAAS;IACjDC,aAAaP,gCAAgC,eAAeI,OAAO;IACnEI,UAAUf,KAAK,aAAaW,OAAO;IACnCK,YAAYhB,KAAK,eAAeW,OAAO;IACvCM,QAAQjB,KAAK,UAAUW,OAAO;IAC9BO,OAAOlB,KAAK,SAASW,OAAO;IAC5BQ,SAASrB,MAAM,WAAWa,OAAO;IACjCS,YAAYnB,UAAU,eAAe;QAACoB,cAAc;IAAI,GAAGV,OAAO;IAClEW,uBAAuBnB,KAAK,4BAA4BS,UAAU,CAAC,IAAMP,cAAcI,EAAE,EAAE;QACzFI,UAAU;IACZ;IACAU,WAAWtB,UAAU,cAAc;QAACoB,cAAc;IAAI,GAAGV,OAAO,GAAGa,UAAU;AAC/E,GACA,CAACC,QAAU;QACTvB,YAAY,sDAAsDwB,EAAE,CAClED,MAAMf,KAAK,EACXe,MAAMV,QAAQ;QAEhBlB,MAAM,kDAAkD6B,EAAE,CAACD,MAAMf,KAAK,EAAEe,MAAML,UAAU;KACzF,EACD;AAKF,OAAO,SAASO,mBAAmBC,GAAuB;IACxD,OAAO;QACLnB,IAAImB,IAAInB,EAAE;QACVC,OAAOkB,IAAIlB,KAAK;QAChBI,aAAac,IAAId,WAAW;QAC5BC,UAAUa,IAAIb,QAAQ;QACtBC,YAAYY,IAAIZ,UAAU;QAC1BC,QAAQW,IAAIX,MAAM;QAClBC,OAAOU,IAAIV,KAAK;QAChBC,SAASS,IAAIT,OAAO;QACpBC,YAAYQ,IAAIR,UAAU;QAC1BE,uBAAuBM,IAAIN,qBAAqB;QAChDC,WAAWK,IAAIL,SAAS;IAC1B;AACF"}

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

@@ -0,0 +1,542 @@
+import { type Job, type JobListeningTrigger } from '#core/entities/job.js';
+import type { PersistedEvaluationTraceEntry } from '#core/entities/step.js';
+export declare const jobStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "running", "succeeded", "failed", "cancelled", "skipped"]>;
+export declare const jobStatusReasonEnum: import("drizzle-orm/pg-core").PgEnum<["dependency_not_completed", "condition_false", "default_gate_rejected", "condition_rejected", "condition_errored", "user_cancelled", "run_cancelled", "timed_out", "runner_lost", "step_failed", "unknown"]>;
+export declare const jobModeEnum: import("drizzle-orm/pg-core").PgEnum<["one_shot", "listening"]>;
+export declare const jobCheckoutContentsEnum: import("drizzle-orm/pg-core").PgEnum<["read", "write"]>;
+export declare const jobOnResolveEnum: import("drizzle-orm/pg-core").PgEnum<["finish", "cancel"]>;
+export declare const listenerStatusEnum: import("drizzle-orm/pg-core").PgEnum<["inactive", "listening", "resolved"]>;
+export declare const resolutionReasonEnum: import("drizzle-orm/pg-core").PgEnum<["until", "timeout", "max_executions", "cancelled"]>;
+export declare const jobs: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "jobs";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "jobs";
+            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;
+        }, {}, {}>;
+        workflowRunAttemptId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workflow_run_attempt_id";
+            tableName: "jobs";
+            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: "jobs";
+            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;
+        }, {}, {}>;
+        mode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "mode";
+            tableName: "jobs";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "one_shot" | "listening";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["one_shot", "listening"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "jobs";
+            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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "jobs";
+            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: "jobs";
+            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;
+        }, {}, {}>;
+        carriedOver: import("drizzle-orm/pg-core").PgColumn<{
+            name: "carried_over";
+            tableName: "jobs";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        checkoutPersistCredentials: import("drizzle-orm/pg-core").PgColumn<{
+            name: "checkout_persist_credentials";
+            tableName: "jobs";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        checkoutPermissionsContents: import("drizzle-orm/pg-core").PgColumn<{
+            name: "checkout_permissions_contents";
+            tableName: "jobs";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "read" | "write";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["read", "write"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        success: import("drizzle-orm/pg-core").PgColumn<{
+            name: "success";
+            tableName: "jobs";
+            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;
+        }, {}, {}>;
+        evaluationTrace: import("drizzle-orm/pg-core").PgColumn<{
+            name: "evaluation_trace";
+            tableName: "jobs";
+            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[];
+        }>;
+        executionTimeoutMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "execution_timeout_ms";
+            tableName: "jobs";
+            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;
+        }, {}, {}>;
+        listeningTimeoutMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "listening_timeout_ms";
+            tableName: "jobs";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        maxExecutions: import("drizzle-orm/pg-core").PgColumn<{
+            name: "max_executions";
+            tableName: "jobs";
+            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;
+        }, {}, {}>;
+        onResolve: import("drizzle-orm/pg-core").PgColumn<{
+            name: "on_resolve";
+            tableName: "jobs";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "finish" | "cancel";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["finish", "cancel"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        batchDebounceMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "batch_debounce_ms";
+            tableName: "jobs";
+            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;
+        }, {}, {}>;
+        batchMaxSize: import("drizzle-orm/pg-core").PgColumn<{
+            name: "batch_max_size";
+            tableName: "jobs";
+            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;
+        }, {}, {}>;
+        batchMaxWaitMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "batch_max_wait_ms";
+            tableName: "jobs";
+            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;
+        }, {}, {}>;
+        listenerStatus: import("drizzle-orm/pg-core").PgColumn<{
+            name: "listener_status";
+            tableName: "jobs";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "listening" | "inactive" | "resolved";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["inactive", "listening", "resolved"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        resolutionReason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "resolution_reason";
+            tableName: "jobs";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "cancelled" | "until" | "timeout" | "max_executions";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["until", "timeout", "max_executions", "cancelled"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        listeningOn: import("drizzle-orm/pg-core").PgColumn<{
+            name: "listening_on";
+            tableName: "jobs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: JobListeningTrigger[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: JobListeningTrigger[];
+        }>;
+        listeningUntil: import("drizzle-orm/pg-core").PgColumn<{
+            name: "listening_until";
+            tableName: "jobs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: JobListeningTrigger[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: JobListeningTrigger[];
+        }>;
+        outputs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "outputs";
+            tableName: "jobs";
+            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;
+        }>;
+        dependencies: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dependencies";
+            tableName: "jobs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        runner: import("drizzle-orm/pg-core").PgColumn<{
+            name: "runner";
+            tableName: "jobs";
+            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[];
+        }>;
+        position: import("drizzle-orm/pg-core").PgColumn<{
+            name: "position";
+            tableName: "jobs";
+            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: "jobs";
+            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: "jobs";
+            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: "jobs";
+            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 JobDb = typeof jobs.$inferSelect;
+export type JobCreateDb = typeof jobs.$inferInsert;
+export declare function toJob(row: JobDb): Job;
+//# sourceMappingURL=jobs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jobs.d.ts","sourceRoot":"","sources":["../../../src/db/schema/jobs.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,GAAG,EACR,KAAK,mBAAmB,EAEzB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAC,6BAA6B,EAAC,MAAM,wBAAwB,CAAC;AAI1E,eAAO,MAAM,aAAa,6GAOxB,CAAC;AAEH,eAAO,MAAM,mBAAmB,oPAA4D,CAAC;AAE7F,eAAO,MAAM,WAAW,iEAA0D,CAAC;AAEnF,eAAO,MAAM,uBAAuB,yDAA2D,CAAC;AAEhG,eAAO,MAAM,gBAAgB,4DAA2D,CAAC;AAEzF,eAAO,MAAM,kBAAkB,6EAI7B,CAAC;AAEH,eAAO,MAAM,oBAAoB,2FAK/B,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0ChB,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG,OAAO,IAAI,CAAC,YAAY,CAAC;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,IAAI,CAAC,YAAY,CAAC;AAEnD,wBAAgB,KAAK,CAAC,GAAG,EAAE,KAAK,GAAG,GAAG,CAmCrC"}

package/dist/db/schema/jobs.js

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