@shipfox/api-triggers 2.0.0

package/dist/db/job-listener-subscriptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/job-listener-subscriptions.ts"],"sourcesContent":["import {and, eq, notInArray} from 'drizzle-orm';\nimport type {\n  JobListenerMatcherKind,\n  JobListenerSubscription,\n} from '#core/entities/job-listener-subscription.js';\nimport {db} from './db.js';\nimport {\n  jobListenerSubscriptions,\n  toJobListenerSubscription,\n} from './schema/job-listener-subscriptions.js';\n\ntype Tx = Parameters<Parameters<ReturnType<typeof db>['transaction']>[0]>[0];\n\nexport interface ListenerMatcher {\n  source: string;\n  event: string;\n  inputs?: Readonly<Record<string, unknown>> | undefined;\n  filter?: string | undefined;\n  filter_snapshot?: Readonly<Record<string, unknown>> | undefined;\n}\n\nexport interface ProjectJobListenerSubscriptionsParams {\n  workspaceId: string;\n  workflowRunId: string;\n  jobId: string;\n  on: readonly ListenerMatcher[] | null;\n  until: readonly ListenerMatcher[] | null;\n}\n\nexport async function projectJobListenerSubscriptions(\n  params: ProjectJobListenerSubscriptionsParams,\n): Promise<void> {\n  await db().transaction(async (tx) => {\n    await pruneStaleMatchers(tx, params.jobId, 'on', params.on ?? []);\n    await pruneStaleMatchers(tx, params.jobId, 'until', params.until ?? []);\n\n    for (const [kind, matchers] of [\n      ['on', params.on ?? []],\n      ['until', params.until ?? []],\n    ] as const) {\n      for (const [matcherOrdinal, matcher] of matchers.entries()) {\n        const config: Record<string, unknown> = {};\n        if (matcher.inputs !== undefined) config.inputs = matcher.inputs;\n        if (matcher.filter !== undefined) config.filter = matcher.filter;\n        if (matcher.filter_snapshot !== undefined) config.filter_snapshot = matcher.filter_snapshot;\n\n        await tx\n          .insert(jobListenerSubscriptions)\n          .values({\n            workspaceId: params.workspaceId,\n            workflowRunId: params.workflowRunId,\n            jobId: params.jobId,\n            kind,\n            matcherOrdinal,\n            source: matcher.source,\n            event: matcher.event,\n            config,\n          })\n          .onConflictDoUpdate({\n            target: [\n              jobListenerSubscriptions.jobId,\n              jobListenerSubscriptions.kind,\n              jobListenerSubscriptions.matcherOrdinal,\n            ],\n            set: {\n              workspaceId: params.workspaceId,\n              workflowRunId: params.workflowRunId,\n              source: matcher.source,\n              event: matcher.event,\n              config,\n            },\n          });\n      }\n    }\n  });\n}\n\nasync function pruneStaleMatchers(\n  tx: Tx,\n  jobId: string,\n  kind: JobListenerMatcherKind,\n  matchers: readonly ListenerMatcher[],\n): Promise<void> {\n  const base = and(\n    eq(jobListenerSubscriptions.jobId, jobId),\n    eq(jobListenerSubscriptions.kind, kind),\n  );\n\n  if (matchers.length === 0) {\n    await tx.delete(jobListenerSubscriptions).where(base);\n    return;\n  }\n\n  await tx.delete(jobListenerSubscriptions).where(\n    and(\n      base,\n      notInArray(\n        jobListenerSubscriptions.matcherOrdinal,\n        matchers.map((_matcher, index) => index),\n      ),\n    ),\n  );\n}\n\nexport async function removeJobListenerSubscriptionsForJob(jobId: string): Promise<number> {\n  const rows = await db()\n    .delete(jobListenerSubscriptions)\n    .where(eq(jobListenerSubscriptions.jobId, jobId))\n    .returning({id: jobListenerSubscriptions.id});\n  return rows.length;\n}\n\nexport interface FindMatchingJobListenerSubscriptionsParams {\n  workspaceId: string;\n  source: string;\n  event: string;\n}\n\nexport async function findMatchingJobListenerSubscriptions(\n  params: FindMatchingJobListenerSubscriptionsParams,\n): Promise<JobListenerSubscription[]> {\n  const rows = await db()\n    .select()\n    .from(jobListenerSubscriptions)\n    .where(\n      and(\n        eq(jobListenerSubscriptions.workspaceId, params.workspaceId),\n        eq(jobListenerSubscriptions.source, params.source),\n        eq(jobListenerSubscriptions.event, params.event),\n      ),\n    );\n  return rows.map(toJobListenerSubscription);\n}\n"],"names":["and","eq","notInArray","db","jobListenerSubscriptions","toJobListenerSubscription","projectJobListenerSubscriptions","params","transaction","tx","pruneStaleMatchers","jobId","on","until","kind","matchers","matcherOrdinal","matcher","entries","config","inputs","undefined","filter","filter_snapshot","insert","values","workspaceId","workflowRunId","source","event","onConflictDoUpdate","target","set","base","length","delete","where","map","_matcher","index","removeJobListenerSubscriptionsForJob","rows","returning","id","findMatchingJobListenerSubscriptions","select","from"],"mappings":"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"}

package/dist/db/received-events.d.ts

@@ -0,0 +1,7 @@
+export interface PruneTriggerEventsParams {
+    olderThan: Date;
+}
+export declare function pruneTriggerEvents(params: PruneTriggerEventsParams): Promise<{
+    deleted: number;
+}>;
+//# sourceMappingURL=received-events.d.ts.map

package/dist/db/received-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"received-events.d.ts","sourceRoot":"","sources":["../../src/db/received-events.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,wBAAwB,GAC/B,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAK5B"}

package/dist/db/received-events.js

@@ -0,0 +1,11 @@
+import { lt } from 'drizzle-orm';
+import { db } from './db.js';
+import { triggersReceivedEvents } from './schema/received-events.js';
+export async function pruneTriggerEvents(params) {
+    const result = await db().delete(triggersReceivedEvents).where(lt(triggersReceivedEvents.createdAt, params.olderThan));
+    return {
+        deleted: result.rowCount ?? 0
+    };
+}
+
+//# sourceMappingURL=received-events.js.map

package/dist/db/received-events.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/received-events.ts"],"sourcesContent":["import {lt} from 'drizzle-orm';\nimport {db} from './db.js';\nimport {triggersReceivedEvents} from './schema/received-events.js';\n\nexport interface PruneTriggerEventsParams {\n  olderThan: Date;\n}\n\nexport async function pruneTriggerEvents(\n  params: PruneTriggerEventsParams,\n): Promise<{deleted: number}> {\n  const result = await db()\n    .delete(triggersReceivedEvents)\n    .where(lt(triggersReceivedEvents.createdAt, params.olderThan));\n  return {deleted: result.rowCount ?? 0};\n}\n"],"names":["lt","db","triggersReceivedEvents","pruneTriggerEvents","params","result","delete","where","createdAt","olderThan","deleted","rowCount"],"mappings":"AAAA,SAAQA,EAAE,QAAO,cAAc;AAC/B,SAAQC,EAAE,QAAO,UAAU;AAC3B,SAAQC,sBAAsB,QAAO,8BAA8B;AAMnE,OAAO,eAAeC,mBACpBC,MAAgC;IAEhC,MAAMC,SAAS,MAAMJ,KAClBK,MAAM,CAACJ,wBACPK,KAAK,CAACP,GAAGE,uBAAuBM,SAAS,EAAEJ,OAAOK,SAAS;IAC9D,OAAO;QAACC,SAASL,OAAOM,QAAQ,IAAI;IAAC;AACvC"}

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

@@ -0,0 +1,2 @@
+export declare const pgTable: import("drizzle-orm/pg-core").PgTableFn<undefined>;
+//# sourceMappingURL=common.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/db/schema/common.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,oDAA+C,CAAC"}

package/dist/db/schema/common.js

@@ -0,0 +1,4 @@
+import { pgTableCreator } from 'drizzle-orm/pg-core';
+export const pgTable = pgTableCreator((name)=>`triggers_${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) => `triggers_${name}`);\n"],"names":["pgTableCreator","pgTable","name"],"mappings":"AAAA,SAAQA,cAAc,QAAO,sBAAsB;AAEnD,OAAO,MAAMC,UAAUD,eAAe,CAACE,OAAS,CAAC,SAAS,EAAEA,MAAM,EAAE"}

package/dist/db/schema/cron-schedules.d.ts

@@ -0,0 +1,148 @@
+import type { CronSchedule } from '#core/entities/cron-schedule.js';
+export declare const triggersCronSchedules: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "cron_schedules";
+    schema: undefined;
+    columns: {
+        subscriptionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "subscription_id";
+            tableName: "cron_schedules";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "cron_schedules";
+            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;
+        }, {}, {}>;
+        cronExpression: import("drizzle-orm/pg-core").PgColumn<{
+            name: "cron_expression";
+            tableName: "cron_schedules";
+            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;
+        }, {}, {}>;
+        timezone: import("drizzle-orm/pg-core").PgColumn<{
+            name: "timezone";
+            tableName: "cron_schedules";
+            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;
+        }, {}, {}>;
+        nextFireAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_fire_at";
+            tableName: "cron_schedules";
+            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;
+        }, {}, {}>;
+        lastFiredAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_fired_at";
+            tableName: "cron_schedules";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "cron_schedules";
+            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: "cron_schedules";
+            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 CronScheduleDb = typeof triggersCronSchedules.$inferSelect;
+export type CronScheduleInsertDb = typeof triggersCronSchedules.$inferInsert;
+export declare function toCronSchedule(row: CronScheduleDb): CronSchedule;
+//# sourceMappingURL=cron-schedules.d.ts.map

package/dist/db/schema/cron-schedules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-schedules.d.ts","sourceRoot":"","sources":["../../../src/db/schema/cron-schedules.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,iCAAiC,CAAC;AAIlE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAejC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAC;AACvE,MAAM,MAAM,oBAAoB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAC;AAE7E,wBAAgB,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,YAAY,CAWhE"}

package/dist/db/schema/cron-schedules.js

@@ -0,0 +1,39 @@
+import { index, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+import { triggerSubscriptions } from './subscriptions.js';
+export const triggersCronSchedules = pgTable('cron_schedules', {
+    subscriptionId: uuid('subscription_id').primaryKey().references(()=>triggerSubscriptions.id, {
+        onDelete: 'cascade'
+    }),
+    workspaceId: uuid('workspace_id').notNull(),
+    cronExpression: text('cron_expression').notNull(),
+    timezone: text('timezone').notNull(),
+    nextFireAt: timestamp('next_fire_at', {
+        withTimezone: true
+    }).notNull(),
+    lastFiredAt: timestamp('last_fired_at', {
+        withTimezone: true
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        index('triggers_cron_schedules_next_fire_at_idx').on(table.nextFireAt)
+    ]);
+export function toCronSchedule(row) {
+    return {
+        subscriptionId: row.subscriptionId,
+        workspaceId: row.workspaceId,
+        cronExpression: row.cronExpression,
+        timezone: row.timezone,
+        nextFireAt: row.nextFireAt,
+        lastFiredAt: row.lastFiredAt,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+    };
+}
+
+//# sourceMappingURL=cron-schedules.js.map

package/dist/db/schema/cron-schedules.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/cron-schedules.ts"],"sourcesContent":["import {index, text, timestamp, uuid} from 'drizzle-orm/pg-core';\nimport type {CronSchedule} from '#core/entities/cron-schedule.js';\nimport {pgTable} from './common.js';\nimport {triggerSubscriptions} from './subscriptions.js';\n\nexport const triggersCronSchedules = pgTable(\n  'cron_schedules',\n  {\n    subscriptionId: uuid('subscription_id')\n      .primaryKey()\n      .references(() => triggerSubscriptions.id, {onDelete: 'cascade'}),\n    workspaceId: uuid('workspace_id').notNull(),\n    cronExpression: text('cron_expression').notNull(),\n    timezone: text('timezone').notNull(),\n    nextFireAt: timestamp('next_fire_at', {withTimezone: true}).notNull(),\n    lastFiredAt: timestamp('last_fired_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [index('triggers_cron_schedules_next_fire_at_idx').on(table.nextFireAt)],\n);\n\nexport type CronScheduleDb = typeof triggersCronSchedules.$inferSelect;\nexport type CronScheduleInsertDb = typeof triggersCronSchedules.$inferInsert;\n\nexport function toCronSchedule(row: CronScheduleDb): CronSchedule {\n  return {\n    subscriptionId: row.subscriptionId,\n    workspaceId: row.workspaceId,\n    cronExpression: row.cronExpression,\n    timezone: row.timezone,\n    nextFireAt: row.nextFireAt,\n    lastFiredAt: row.lastFiredAt,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["index","text","timestamp","uuid","pgTable","triggerSubscriptions","triggersCronSchedules","subscriptionId","primaryKey","references","id","onDelete","workspaceId","notNull","cronExpression","timezone","nextFireAt","withTimezone","lastFiredAt","createdAt","defaultNow","updatedAt","table","on","toCronSchedule","row"],"mappings":"AAAA,SAAQA,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,IAAI,QAAO,sBAAsB;AAEjE,SAAQC,OAAO,QAAO,cAAc;AACpC,SAAQC,oBAAoB,QAAO,qBAAqB;AAExD,OAAO,MAAMC,wBAAwBF,QACnC,kBACA;IACEG,gBAAgBJ,KAAK,mBAClBK,UAAU,GACVC,UAAU,CAAC,IAAMJ,qBAAqBK,EAAE,EAAE;QAACC,UAAU;IAAS;IACjEC,aAAaT,KAAK,gBAAgBU,OAAO;IACzCC,gBAAgBb,KAAK,mBAAmBY,OAAO;IAC/CE,UAAUd,KAAK,YAAYY,OAAO;IAClCG,YAAYd,UAAU,gBAAgB;QAACe,cAAc;IAAI,GAAGJ,OAAO;IACnEK,aAAahB,UAAU,iBAAiB;QAACe,cAAc;IAAI;IAC3DE,WAAWjB,UAAU,cAAc;QAACe,cAAc;IAAI,GAAGJ,OAAO,GAAGO,UAAU;IAC7EC,WAAWnB,UAAU,cAAc;QAACe,cAAc;IAAI,GAAGJ,OAAO,GAAGO,UAAU;AAC/E,GACA,CAACE,QAAU;QAACtB,MAAM,4CAA4CuB,EAAE,CAACD,MAAMN,UAAU;KAAE,EACnF;AAKF,OAAO,SAASQ,eAAeC,GAAmB;IAChD,OAAO;QACLlB,gBAAgBkB,IAAIlB,cAAc;QAClCK,aAAaa,IAAIb,WAAW;QAC5BE,gBAAgBW,IAAIX,cAAc;QAClCC,UAAUU,IAAIV,QAAQ;QACtBC,YAAYS,IAAIT,UAAU;QAC1BE,aAAaO,IAAIP,WAAW;QAC5BC,WAAWM,IAAIN,SAAS;QACxBE,WAAWI,IAAIJ,SAAS;IAC1B;AACF"}

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

@@ -0,0 +1,284 @@
+import { type TriggerDecision } from '#core/entities/decision.js';
+export declare const triggersDecisions: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "decisions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "decisions";
+            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;
+        }, {}, {}>;
+        receivedEventId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "received_event_id";
+            tableName: "decisions";
+            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;
+        }, {}, {}>;
+        subscriptionKind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "subscription_kind";
+            tableName: "decisions";
+            dataType: "string";
+            columnType: "PgText";
+            data: "trigger" | "listener";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["trigger", "listener"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        subscriptionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "subscription_id";
+            tableName: "decisions";
+            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;
+        }, {}, {}>;
+        subscriptionName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "subscription_name";
+            tableName: "decisions";
+            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;
+        }, {}, {}>;
+        workflowDefinitionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workflow_definition_id";
+            tableName: "decisions";
+            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;
+        }, {}, {}>;
+        projectId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "project_id";
+            tableName: "decisions";
+            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;
+        }, {}, {}>;
+        workflowRunId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workflow_run_id";
+            tableName: "decisions";
+            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;
+        }, {}, {}>;
+        jobId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "job_id";
+            tableName: "decisions";
+            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;
+        }, {}, {}>;
+        matcherKind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "matcher_kind";
+            tableName: "decisions";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "on" | "until";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["on", "until"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        matcherOrdinal: import("drizzle-orm/pg-core").PgColumn<{
+            name: "matcher_ordinal";
+            tableName: "decisions";
+            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;
+        }, {}, {}>;
+        decision: import("drizzle-orm/pg-core").PgColumn<{
+            name: "decision";
+            tableName: "decisions";
+            dataType: "string";
+            columnType: "PgText";
+            data: "triggered" | "filter-error" | "dispatch-error";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["triggered", "filter-error", "dispatch-error"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "run_id";
+            tableName: "decisions";
+            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;
+        }, {}, {}>;
+        runName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "run_name";
+            tableName: "decisions";
+            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;
+        }, {}, {}>;
+        reason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "reason";
+            tableName: "decisions";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "decisions";
+            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 TriggerDecisionDb = typeof triggersDecisions.$inferSelect;
+export type TriggerDecisionInsertDb = typeof triggersDecisions.$inferInsert;
+export declare function toTriggerDecision(row: TriggerDecisionDb): TriggerDecision;
+//# sourceMappingURL=decisions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decisions.d.ts","sourceRoot":"","sources":["../../../src/db/schema/decisions.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,KAAK,eAAe,EAA0B,MAAM,4BAA4B,CAAC;AAOzF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC7B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAC;AACtE,MAAM,MAAM,uBAAuB,GAAG,OAAO,iBAAiB,CAAC,YAAY,CAAC;AAE5E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,iBAAiB,GAAG,eAAe,CAmBzE"}

package/dist/db/schema/decisions.js

@@ -0,0 +1,70 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { sql } from 'drizzle-orm';
+import { check, index, integer, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { triggerDecisionOutcomes } from '#core/entities/decision.js';
+import { pgTable } from './common.js';
+import { jobListenerMatcherKindEnum } from './job-listener-subscriptions.js';
+import { triggersReceivedEvents } from './received-events.js';
+const triggerDecisionSubscriptionKinds = [
+    'trigger',
+    'listener'
+];
+export const triggersDecisions = pgTable('decisions', {
+    id: uuidv7PrimaryKey(),
+    receivedEventId: uuid('received_event_id').notNull().references(()=>triggersReceivedEvents.id, {
+        onDelete: 'cascade'
+    }),
+    subscriptionKind: text('subscription_kind', {
+        enum: triggerDecisionSubscriptionKinds
+    }).notNull(),
+    subscriptionId: uuid('subscription_id').notNull(),
+    subscriptionName: text('subscription_name').notNull(),
+    workflowDefinitionId: uuid('workflow_definition_id'),
+    projectId: uuid('project_id'),
+    workflowRunId: uuid('workflow_run_id'),
+    jobId: uuid('job_id'),
+    matcherKind: jobListenerMatcherKindEnum('matcher_kind'),
+    matcherOrdinal: integer('matcher_ordinal'),
+    decision: text('decision', {
+        enum: triggerDecisionOutcomes
+    }).notNull(),
+    runId: uuid('run_id'),
+    runName: text('run_name'),
+    reason: text('reason'),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('triggers_decisions_event_subscription_unique').on(table.receivedEventId, table.subscriptionKind, table.subscriptionId),
+        index('triggers_decisions_run_idx').on(table.runId),
+        check('triggers_decisions_subscription_kind_ck', sql`${table.subscriptionKind} IN ('trigger', 'listener')`)
+    ]);
+export function toTriggerDecision(row) {
+    return {
+        id: row.id,
+        receivedEventId: row.receivedEventId,
+        subscriptionKind: row.subscriptionKind,
+        subscriptionId: row.subscriptionId,
+        subscriptionName: row.subscriptionName,
+        workflowDefinitionId: row.workflowDefinitionId,
+        projectId: row.projectId,
+        workflowRunId: row.workflowRunId,
+        jobId: row.jobId,
+        matcherKind: row.matcherKind,
+        matcherOrdinal: row.matcherOrdinal,
+        decision: toTriggerDecisionOutcome(row.decision),
+        runId: row.runId,
+        runName: row.runName,
+        reason: row.reason,
+        createdAt: row.createdAt
+    };
+}
+function toTriggerDecisionOutcome(decision) {
+    if (decision === 'errored') return 'dispatch-error';
+    if (decision === 'triggered' || decision === 'filter-error' || decision === 'dispatch-error') {
+        return decision;
+    }
+    return 'dispatch-error';
+}
+
+//# sourceMappingURL=decisions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/decisions.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {check, index, integer, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport {type TriggerDecision, triggerDecisionOutcomes} from '#core/entities/decision.js';\nimport {pgTable} from './common.js';\nimport {jobListenerMatcherKindEnum} from './job-listener-subscriptions.js';\nimport {triggersReceivedEvents} from './received-events.js';\n\nconst triggerDecisionSubscriptionKinds = ['trigger', 'listener'] as const;\n\nexport const triggersDecisions = pgTable(\n  'decisions',\n  {\n    id: uuidv7PrimaryKey(),\n    receivedEventId: uuid('received_event_id')\n      .notNull()\n      .references(() => triggersReceivedEvents.id, {onDelete: 'cascade'}),\n    subscriptionKind: text('subscription_kind', {enum: triggerDecisionSubscriptionKinds}).notNull(),\n    subscriptionId: uuid('subscription_id').notNull(),\n    subscriptionName: text('subscription_name').notNull(),\n    workflowDefinitionId: uuid('workflow_definition_id'),\n    projectId: uuid('project_id'),\n    workflowRunId: uuid('workflow_run_id'),\n    jobId: uuid('job_id'),\n    matcherKind: jobListenerMatcherKindEnum('matcher_kind'),\n    matcherOrdinal: integer('matcher_ordinal'),\n    decision: text('decision', {enum: triggerDecisionOutcomes}).notNull(),\n    runId: uuid('run_id'),\n    runName: text('run_name'),\n    reason: text('reason'),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('triggers_decisions_event_subscription_unique').on(\n      table.receivedEventId,\n      table.subscriptionKind,\n      table.subscriptionId,\n    ),\n    index('triggers_decisions_run_idx').on(table.runId),\n    check(\n      'triggers_decisions_subscription_kind_ck',\n      sql`${table.subscriptionKind} IN ('trigger', 'listener')`,\n    ),\n  ],\n);\n\nexport type TriggerDecisionDb = typeof triggersDecisions.$inferSelect;\nexport type TriggerDecisionInsertDb = typeof triggersDecisions.$inferInsert;\n\nexport function toTriggerDecision(row: TriggerDecisionDb): TriggerDecision {\n  return {\n    id: row.id,\n    receivedEventId: row.receivedEventId,\n    subscriptionKind: row.subscriptionKind,\n    subscriptionId: row.subscriptionId,\n    subscriptionName: row.subscriptionName,\n    workflowDefinitionId: row.workflowDefinitionId,\n    projectId: row.projectId,\n    workflowRunId: row.workflowRunId,\n    jobId: row.jobId,\n    matcherKind: row.matcherKind,\n    matcherOrdinal: row.matcherOrdinal,\n    decision: toTriggerDecisionOutcome(row.decision),\n    runId: row.runId,\n    runName: row.runName,\n    reason: row.reason,\n    createdAt: row.createdAt,\n  };\n}\n\nfunction toTriggerDecisionOutcome(decision: string): TriggerDecision['decision'] {\n  if (decision === 'errored') return 'dispatch-error';\n  if (decision === 'triggered' || decision === 'filter-error' || decision === 'dispatch-error') {\n    return decision;\n  }\n  return 'dispatch-error';\n}\n"],"names":["uuidv7PrimaryKey","sql","check","index","integer","text","timestamp","uniqueIndex","uuid","triggerDecisionOutcomes","pgTable","jobListenerMatcherKindEnum","triggersReceivedEvents","triggerDecisionSubscriptionKinds","triggersDecisions","id","receivedEventId","notNull","references","onDelete","subscriptionKind","enum","subscriptionId","subscriptionName","workflowDefinitionId","projectId","workflowRunId","jobId","matcherKind","matcherOrdinal","decision","runId","runName","reason","createdAt","withTimezone","defaultNow","table","on","toTriggerDecision","row","toTriggerDecisionOutcome"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,GAAG,QAAO,cAAc;AAChC,SAAQC,KAAK,EAAEC,KAAK,EAAEC,OAAO,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAC9F,SAA8BC,uBAAuB,QAAO,6BAA6B;AACzF,SAAQC,OAAO,QAAO,cAAc;AACpC,SAAQC,0BAA0B,QAAO,kCAAkC;AAC3E,SAAQC,sBAAsB,QAAO,uBAAuB;AAE5D,MAAMC,mCAAmC;IAAC;IAAW;CAAW;AAEhE,OAAO,MAAMC,oBAAoBJ,QAC/B,aACA;IACEK,IAAIf;IACJgB,iBAAiBR,KAAK,qBACnBS,OAAO,GACPC,UAAU,CAAC,IAAMN,uBAAuBG,EAAE,EAAE;QAACI,UAAU;IAAS;IACnEC,kBAAkBf,KAAK,qBAAqB;QAACgB,MAAMR;IAAgC,GAAGI,OAAO;IAC7FK,gBAAgBd,KAAK,mBAAmBS,OAAO;IAC/CM,kBAAkBlB,KAAK,qBAAqBY,OAAO;IACnDO,sBAAsBhB,KAAK;IAC3BiB,WAAWjB,KAAK;IAChBkB,eAAelB,KAAK;IACpBmB,OAAOnB,KAAK;IACZoB,aAAajB,2BAA2B;IACxCkB,gBAAgBzB,QAAQ;IACxB0B,UAAUzB,KAAK,YAAY;QAACgB,MAAMZ;IAAuB,GAAGQ,OAAO;IACnEc,OAAOvB,KAAK;IACZwB,SAAS3B,KAAK;IACd4B,QAAQ5B,KAAK;IACb6B,WAAW5B,UAAU,cAAc;QAAC6B,cAAc;IAAI,GAAGlB,OAAO,GAAGmB,UAAU;AAC/E,GACA,CAACC,QAAU;QACT9B,YAAY,gDAAgD+B,EAAE,CAC5DD,MAAMrB,eAAe,EACrBqB,MAAMjB,gBAAgB,EACtBiB,MAAMf,cAAc;QAEtBnB,MAAM,8BAA8BmC,EAAE,CAACD,MAAMN,KAAK;QAClD7B,MACE,2CACAD,GAAG,CAAC,EAAEoC,MAAMjB,gBAAgB,CAAC,2BAA2B,CAAC;KAE5D,EACD;AAKF,OAAO,SAASmB,kBAAkBC,GAAsB;IACtD,OAAO;QACLzB,IAAIyB,IAAIzB,EAAE;QACVC,iBAAiBwB,IAAIxB,eAAe;QACpCI,kBAAkBoB,IAAIpB,gBAAgB;QACtCE,gBAAgBkB,IAAIlB,cAAc;QAClCC,kBAAkBiB,IAAIjB,gBAAgB;QACtCC,sBAAsBgB,IAAIhB,oBAAoB;QAC9CC,WAAWe,IAAIf,SAAS;QACxBC,eAAec,IAAId,aAAa;QAChCC,OAAOa,IAAIb,KAAK;QAChBC,aAAaY,IAAIZ,WAAW;QAC5BC,gBAAgBW,IAAIX,cAAc;QAClCC,UAAUW,yBAAyBD,IAAIV,QAAQ;QAC/CC,OAAOS,IAAIT,KAAK;QAChBC,SAASQ,IAAIR,OAAO;QACpBC,QAAQO,IAAIP,MAAM;QAClBC,WAAWM,IAAIN,SAAS;IAC1B;AACF;AAEA,SAASO,yBAAyBX,QAAgB;IAChD,IAAIA,aAAa,WAAW,OAAO;IACnC,IAAIA,aAAa,eAAeA,aAAa,kBAAkBA,aAAa,kBAAkB;QAC5F,OAAOA;IACT;IACA,OAAO;AACT"}