@shipfox/api-triggers 13.0.0 → 14.0.0

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

@@ -1,6 +1,7 @@
 import { and, eq, notInArray } from 'drizzle-orm';
 import { db } from './db.js';
 import { jobListenerSubscriptions, toJobListenerSubscription } from './schema/job-listener-subscriptions.js';
+import { normalizeSubscriptionEvent, subscriptionEventCondition } from './subscription-event.js';
 export async function projectJobListenerSubscriptions(params) {
     await db().transaction(async (tx)=>{
         await pruneStaleMatchers(tx, params.jobId, 'on', params.on ?? []);
@@ -30,7 +31,10 @@ export async function projectJobListenerSubscriptions(params) {
                     kind,
                     matcherOrdinal,
                     source: matcher.source,
-                    event: matcher.event,
+                    event: normalizeSubscriptionEvent({
+                        source: matcher.source,
+                        event: matcher.event
+                    }),
                     config
                 }).onConflictDoUpdate({
                     target: [
@@ -42,7 +46,10 @@ export async function projectJobListenerSubscriptions(params) {
                         workspaceId: params.workspaceId,
                         workflowRunId: params.workflowRunId,
                         source: matcher.source,
-                        event: matcher.event,
+                        event: normalizeSubscriptionEvent({
+                            source: matcher.source,
+                            event: matcher.event
+                        }),
                         config
                     }
                 });
@@ -65,7 +72,7 @@ export async function removeJobListenerSubscriptionsForJob(jobId) {
     return rows.length;
 }
 export async function findMatchingJobListenerSubscriptions(params) {
-    const rows = await db().select().from(jobListenerSubscriptions).where(and(eq(jobListenerSubscriptions.workspaceId, params.workspaceId), eq(jobListenerSubscriptions.source, params.source), eq(jobListenerSubscriptions.event, params.event)));
+    const rows = await db().select().from(jobListenerSubscriptions).where(and(eq(jobListenerSubscriptions.workspaceId, params.workspaceId), eq(jobListenerSubscriptions.source, params.source), subscriptionEventCondition(jobListenerSubscriptions.event, params.event)));
     return rows.map(toJobListenerSubscription);
 }
 export async function hasJobListenerSubscriptions(jobId) {

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

@@ -1 +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  filter_output_types?: 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        if (matcher.filter_output_types !== undefined) {\n          config.filter_output_types = matcher.filter_output_types;\n        }\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\nexport async function hasJobListenerSubscriptions(jobId: string): Promise<boolean> {\n  const [subscription] = await db()\n    .select({id: jobListenerSubscriptions.id})\n    .from(jobListenerSubscriptions)\n    .where(eq(jobListenerSubscriptions.jobId, jobId))\n    .limit(1);\n  return subscription !== undefined;\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","filter_output_types","insert","values","workspaceId","workflowRunId","source","event","onConflictDoUpdate","target","set","base","length","delete","where","map","_matcher","index","removeJobListenerSubscriptionsForJob","rows","returning","id","findMatchingJobListenerSubscriptions","select","from","hasJobListenerSubscriptions","subscription","limit"],"mappings":"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"}
+{"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';\nimport {normalizeSubscriptionEvent, subscriptionEventCondition} from './subscription-event.js';\n\ntype Tx = Parameters<Parameters<ReturnType<typeof db>['transaction']>[0]>[0];\n\nexport interface ListenerMatcher {\n  source: string;\n  event?: string | undefined;\n  inputs?: Readonly<Record<string, unknown>> | undefined;\n  filter?: string | undefined;\n  filter_snapshot?: Readonly<Record<string, unknown>> | undefined;\n  filter_output_types?: 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        if (matcher.filter_output_types !== undefined) {\n          config.filter_output_types = matcher.filter_output_types;\n        }\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: normalizeSubscriptionEvent({source: matcher.source, 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: normalizeSubscriptionEvent({source: matcher.source, 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        subscriptionEventCondition(jobListenerSubscriptions.event, params.event),\n      ),\n    );\n  return rows.map(toJobListenerSubscription);\n}\n\nexport async function hasJobListenerSubscriptions(jobId: string): Promise<boolean> {\n  const [subscription] = await db()\n    .select({id: jobListenerSubscriptions.id})\n    .from(jobListenerSubscriptions)\n    .where(eq(jobListenerSubscriptions.jobId, jobId))\n    .limit(1);\n  return subscription !== undefined;\n}\n"],"names":["and","eq","notInArray","db","jobListenerSubscriptions","toJobListenerSubscription","normalizeSubscriptionEvent","subscriptionEventCondition","projectJobListenerSubscriptions","params","transaction","tx","pruneStaleMatchers","jobId","on","until","kind","matchers","matcherOrdinal","matcher","entries","config","inputs","undefined","filter","filter_snapshot","filter_output_types","insert","values","workspaceId","workflowRunId","source","event","onConflictDoUpdate","target","set","base","length","delete","where","map","_matcher","index","removeJobListenerSubscriptionsForJob","rows","returning","id","findMatchingJobListenerSubscriptions","select","from","hasJobListenerSubscriptions","subscription","limit"],"mappings":"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"}

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

@@ -42,14 +42,14 @@ export declare const triggersDecisions: import("drizzle-orm/pg-core").PgTableWit
             tableName: "decisions";
             dataType: "string";
             columnType: "PgText";
-            data: "listener" | "trigger";
+            data: "dev" | "listener" | "trigger";
             driverParam: string;
             notNull: true;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: ["trigger", "listener"];
+            enumValues: ["trigger", "listener", "dev"];
             baseColumn: never;
             identity: undefined;
             generated: undefined;
@@ -61,7 +61,7 @@ export declare const triggersDecisions: import("drizzle-orm/pg-core").PgTableWit
             columnType: "PgUUID";
             data: string;
             driverParam: string;
-            notNull: true;
+            notNull: false;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2C7B,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

@@ -7,7 +7,8 @@ import { jobListenerMatcherKindEnum } from './job-listener-subscriptions.js';
 import { triggersReceivedEvents } from './received-events.js';
 const triggerDecisionSubscriptionKinds = [
     'trigger',
-    'listener'
+    'listener',
+    'dev'
 ];
 export const triggersDecisions = pgTable('decisions', {
     id: uuidv7PrimaryKey(),
@@ -17,7 +18,9 @@ export const triggersDecisions = pgTable('decisions', {
     subscriptionKind: text('subscription_kind', {
         enum: triggerDecisionSubscriptionKinds
     }).notNull(),
-    subscriptionId: uuid('subscription_id').notNull(),
+    // Null for `dev` decisions: the partial dev index enforces one decision
+    // per received event.
+    subscriptionId: uuid('subscription_id'),
     subscriptionName: text('subscription_name').notNull(),
     workflowDefinitionId: uuid('workflow_definition_id'),
     projectId: uuid('project_id'),
@@ -36,8 +39,10 @@ export const triggersDecisions = pgTable('decisions', {
     }).notNull().defaultNow()
 }, (table)=>[
         uniqueIndex('triggers_decisions_event_subscription_unique').on(table.receivedEventId, table.subscriptionKind, table.subscriptionId),
+        uniqueIndex('triggers_decisions_dev_event_unique').on(table.receivedEventId).where(sql`${table.subscriptionKind} = 'dev'`),
         index('triggers_decisions_run_idx').on(table.runId),
-        check('triggers_decisions_subscription_kind_ck', sql`${table.subscriptionKind} IN ('trigger', 'listener')`)
+        check('triggers_decisions_subscription_kind_ck', sql`${table.subscriptionKind} IN ('trigger', 'listener', 'dev')`),
+        check('triggers_decisions_subscription_id_ck', sql`(${table.subscriptionKind} = 'dev' AND ${table.subscriptionId} IS NULL) OR (${table.subscriptionKind} IN ('trigger', 'listener') AND ${table.subscriptionId} IS NOT NULL)`)
     ]);
 export function toTriggerDecision(row) {
     return {

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

@@ -1 +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"}
+{"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', 'dev'] 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    // Null for `dev` decisions: the partial dev index enforces one decision\n    // per received event.\n    subscriptionId: uuid('subscription_id'),\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    uniqueIndex('triggers_decisions_dev_event_unique')\n      .on(table.receivedEventId)\n      .where(sql`${table.subscriptionKind} = 'dev'`),\n    index('triggers_decisions_run_idx').on(table.runId),\n    check(\n      'triggers_decisions_subscription_kind_ck',\n      sql`${table.subscriptionKind} IN ('trigger', 'listener', 'dev')`,\n    ),\n    check(\n      'triggers_decisions_subscription_id_ck',\n      sql`(${table.subscriptionKind} = 'dev' AND ${table.subscriptionId} IS NULL) OR (${table.subscriptionKind} IN ('trigger', 'listener') AND ${table.subscriptionId} IS NOT NULL)`,\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","where","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;IAAY;CAAM;AAEvE,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;IAC7F,wEAAwE;IACxE,sBAAsB;IACtBK,gBAAgBd,KAAK;IACrBe,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;QAEtBf,YAAY,uCACT+B,EAAE,CAACD,MAAMrB,eAAe,EACxBuB,KAAK,CAACtC,GAAG,CAAC,EAAEoC,MAAMjB,gBAAgB,CAAC,QAAQ,CAAC;QAC/CjB,MAAM,8BAA8BmC,EAAE,CAACD,MAAMN,KAAK;QAClD7B,MACE,2CACAD,GAAG,CAAC,EAAEoC,MAAMjB,gBAAgB,CAAC,kCAAkC,CAAC;QAElElB,MACE,yCACAD,GAAG,CAAC,CAAC,EAAEoC,MAAMjB,gBAAgB,CAAC,aAAa,EAAEiB,MAAMf,cAAc,CAAC,cAAc,EAAEe,MAAMjB,gBAAgB,CAAC,gCAAgC,EAAEiB,MAAMf,cAAc,CAAC,aAAa,CAAC;KAEjL,EACD;AAKF,OAAO,SAASkB,kBAAkBC,GAAsB;IACtD,OAAO;QACL1B,IAAI0B,IAAI1B,EAAE;QACVC,iBAAiByB,IAAIzB,eAAe;QACpCI,kBAAkBqB,IAAIrB,gBAAgB;QACtCE,gBAAgBmB,IAAInB,cAAc;QAClCC,kBAAkBkB,IAAIlB,gBAAgB;QACtCC,sBAAsBiB,IAAIjB,oBAAoB;QAC9CC,WAAWgB,IAAIhB,SAAS;QACxBC,eAAee,IAAIf,aAAa;QAChCC,OAAOc,IAAId,KAAK;QAChBC,aAAaa,IAAIb,WAAW;QAC5BC,gBAAgBY,IAAIZ,cAAc;QAClCC,UAAUY,yBAAyBD,IAAIX,QAAQ;QAC/CC,OAAOU,IAAIV,KAAK;QAChBC,SAASS,IAAIT,OAAO;QACpBC,QAAQQ,IAAIR,MAAM;QAClBC,WAAWO,IAAIP,SAAS;IAC1B;AACF;AAEA,SAASQ,yBAAyBZ,QAAgB;IAChD,IAAIA,aAAa,WAAW,OAAO;IACnC,IAAIA,aAAa,eAAeA,aAAa,kBAAkBA,aAAa,kBAAkB;QAC5F,OAAOA;IACT;IACA,OAAO;AACT"}

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

@@ -130,7 +130,7 @@ export declare const jobListenerSubscriptions: import("drizzle-orm/pg-core").PgT
             columnType: "PgText";
             data: string;
             driverParam: string;
-            notNull: true;
+            notNull: false;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;

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

@@ -1 +1 @@
-{"version":3,"file":"job-listener-subscriptions.d.ts","sourceRoot":"","sources":["../../../src/db/schema/job-listener-subscriptions.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,6CAA6C,CAAC;AAGzF,eAAO,MAAM,0BAA0B,uDAGrC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BpC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,OAAO,wBAAwB,CAAC,YAAY,CAAC;AACrF,MAAM,MAAM,+BAA+B,GAAG,OAAO,wBAAwB,CAAC,YAAY,CAAC;AAE3F,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,yBAAyB,GAAG,uBAAuB,CAajG"}
+{"version":3,"file":"job-listener-subscriptions.d.ts","sourceRoot":"","sources":["../../../src/db/schema/job-listener-subscriptions.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,6CAA6C,CAAC;AAGzF,eAAO,MAAM,0BAA0B,uDAGrC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BpC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,OAAO,wBAAwB,CAAC,YAAY,CAAC;AACrF,MAAM,MAAM,+BAA+B,GAAG,OAAO,wBAAwB,CAAC,YAAY,CAAC;AAE3F,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,yBAAyB,GAAG,uBAAuB,CAajG"}

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

@@ -13,7 +13,8 @@ export const jobListenerSubscriptions = pgTable('job_listener_subscriptions', {
     kind: jobListenerMatcherKindEnum('kind').notNull(),
     matcherOrdinal: integer('matcher_ordinal').notNull(),
     source: text('source').notNull(),
-    event: text('event').notNull(),
+    // NULL is a source subscription: matches every event the source delivers.
+    event: text('event'),
     config: jsonb('config').notNull().$type(),
     createdAt: timestamp('created_at', {
         withTimezone: true

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/db/schema/job-listener-subscriptions.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {\n  index,\n  integer,\n  jsonb,\n  pgEnum,\n  text,\n  timestamp,\n  uniqueIndex,\n  uuid,\n} from 'drizzle-orm/pg-core';\nimport type {JobListenerSubscription} from '#core/entities/job-listener-subscription.js';\nimport {pgTable} from './common.js';\n\nexport const jobListenerMatcherKindEnum = pgEnum('triggers_job_listener_matcher_kind', [\n  'on',\n  'until',\n]);\n\nexport const jobListenerSubscriptions = pgTable(\n  'job_listener_subscriptions',\n  {\n    id: uuidv7PrimaryKey(),\n    workspaceId: uuid('workspace_id').notNull(),\n    workflowRunId: uuid('workflow_run_id').notNull(),\n    jobId: uuid('job_id').notNull(),\n    kind: jobListenerMatcherKindEnum('kind').notNull(),\n    matcherOrdinal: integer('matcher_ordinal').notNull(),\n    source: text('source').notNull(),\n    event: text('event').notNull(),\n    config: jsonb('config').notNull().$type<Record<string, unknown>>(),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('triggers_job_listener_subscriptions_job_kind_ordinal_unique').on(\n      table.jobId,\n      table.kind,\n      table.matcherOrdinal,\n    ),\n    index('triggers_job_listener_subscriptions_match_idx').on(\n      table.workspaceId,\n      table.source,\n      table.event,\n    ),\n    index('triggers_job_listener_subscriptions_job_idx').on(table.jobId),\n  ],\n);\n\nexport type JobListenerSubscriptionDb = typeof jobListenerSubscriptions.$inferSelect;\nexport type JobListenerSubscriptionInsertDb = typeof jobListenerSubscriptions.$inferInsert;\n\nexport function toJobListenerSubscription(row: JobListenerSubscriptionDb): JobListenerSubscription {\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    workflowRunId: row.workflowRunId,\n    jobId: row.jobId,\n    kind: row.kind,\n    matcherOrdinal: row.matcherOrdinal,\n    source: row.source,\n    event: row.event,\n    config: row.config,\n    createdAt: row.createdAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","index","integer","jsonb","pgEnum","text","timestamp","uniqueIndex","uuid","pgTable","jobListenerMatcherKindEnum","jobListenerSubscriptions","id","workspaceId","notNull","workflowRunId","jobId","kind","matcherOrdinal","source","event","config","$type","createdAt","withTimezone","defaultNow","table","on","toJobListenerSubscription","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SACEC,KAAK,EACLC,OAAO,EACPC,KAAK,EACLC,MAAM,EACNC,IAAI,EACJC,SAAS,EACTC,WAAW,EACXC,IAAI,QACC,sBAAsB;AAE7B,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,6BAA6BN,OAAO,sCAAsC;IACrF;IACA;CACD,EAAE;AAEH,OAAO,MAAMO,2BAA2BF,QACtC,8BACA;IACEG,IAAIZ;IACJa,aAAaL,KAAK,gBAAgBM,OAAO;IACzCC,eAAeP,KAAK,mBAAmBM,OAAO;IAC9CE,OAAOR,KAAK,UAAUM,OAAO;IAC7BG,MAAMP,2BAA2B,QAAQI,OAAO;IAChDI,gBAAgBhB,QAAQ,mBAAmBY,OAAO;IAClDK,QAAQd,KAAK,UAAUS,OAAO;IAC9BM,OAAOf,KAAK,SAASS,OAAO;IAC5BO,QAAQlB,MAAM,UAAUW,OAAO,GAAGQ,KAAK;IACvCC,WAAWjB,UAAU,cAAc;QAACkB,cAAc;IAAI,GAAGV,OAAO,GAAGW,UAAU;AAC/E,GACA,CAACC,QAAU;QACTnB,YAAY,+DAA+DoB,EAAE,CAC3ED,MAAMV,KAAK,EACXU,MAAMT,IAAI,EACVS,MAAMR,cAAc;QAEtBjB,MAAM,iDAAiD0B,EAAE,CACvDD,MAAMb,WAAW,EACjBa,MAAMP,MAAM,EACZO,MAAMN,KAAK;QAEbnB,MAAM,+CAA+C0B,EAAE,CAACD,MAAMV,KAAK;KACpE,EACD;AAKF,OAAO,SAASY,0BAA0BC,GAA8B;IACtE,OAAO;QACLjB,IAAIiB,IAAIjB,EAAE;QACVC,aAAagB,IAAIhB,WAAW;QAC5BE,eAAec,IAAId,aAAa;QAChCC,OAAOa,IAAIb,KAAK;QAChBC,MAAMY,IAAIZ,IAAI;QACdC,gBAAgBW,IAAIX,cAAc;QAClCC,QAAQU,IAAIV,MAAM;QAClBC,OAAOS,IAAIT,KAAK;QAChBC,QAAQQ,IAAIR,MAAM;QAClBE,WAAWM,IAAIN,SAAS;IAC1B;AACF"}
+{"version":3,"sources":["../../../src/db/schema/job-listener-subscriptions.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {\n  index,\n  integer,\n  jsonb,\n  pgEnum,\n  text,\n  timestamp,\n  uniqueIndex,\n  uuid,\n} from 'drizzle-orm/pg-core';\nimport type {JobListenerSubscription} from '#core/entities/job-listener-subscription.js';\nimport {pgTable} from './common.js';\n\nexport const jobListenerMatcherKindEnum = pgEnum('triggers_job_listener_matcher_kind', [\n  'on',\n  'until',\n]);\n\nexport const jobListenerSubscriptions = pgTable(\n  'job_listener_subscriptions',\n  {\n    id: uuidv7PrimaryKey(),\n    workspaceId: uuid('workspace_id').notNull(),\n    workflowRunId: uuid('workflow_run_id').notNull(),\n    jobId: uuid('job_id').notNull(),\n    kind: jobListenerMatcherKindEnum('kind').notNull(),\n    matcherOrdinal: integer('matcher_ordinal').notNull(),\n    source: text('source').notNull(),\n    // NULL is a source subscription: matches every event the source delivers.\n    event: text('event'),\n    config: jsonb('config').notNull().$type<Record<string, unknown>>(),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('triggers_job_listener_subscriptions_job_kind_ordinal_unique').on(\n      table.jobId,\n      table.kind,\n      table.matcherOrdinal,\n    ),\n    index('triggers_job_listener_subscriptions_match_idx').on(\n      table.workspaceId,\n      table.source,\n      table.event,\n    ),\n    index('triggers_job_listener_subscriptions_job_idx').on(table.jobId),\n  ],\n);\n\nexport type JobListenerSubscriptionDb = typeof jobListenerSubscriptions.$inferSelect;\nexport type JobListenerSubscriptionInsertDb = typeof jobListenerSubscriptions.$inferInsert;\n\nexport function toJobListenerSubscription(row: JobListenerSubscriptionDb): JobListenerSubscription {\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    workflowRunId: row.workflowRunId,\n    jobId: row.jobId,\n    kind: row.kind,\n    matcherOrdinal: row.matcherOrdinal,\n    source: row.source,\n    event: row.event,\n    config: row.config,\n    createdAt: row.createdAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","index","integer","jsonb","pgEnum","text","timestamp","uniqueIndex","uuid","pgTable","jobListenerMatcherKindEnum","jobListenerSubscriptions","id","workspaceId","notNull","workflowRunId","jobId","kind","matcherOrdinal","source","event","config","$type","createdAt","withTimezone","defaultNow","table","on","toJobListenerSubscription","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SACEC,KAAK,EACLC,OAAO,EACPC,KAAK,EACLC,MAAM,EACNC,IAAI,EACJC,SAAS,EACTC,WAAW,EACXC,IAAI,QACC,sBAAsB;AAE7B,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,6BAA6BN,OAAO,sCAAsC;IACrF;IACA;CACD,EAAE;AAEH,OAAO,MAAMO,2BAA2BF,QACtC,8BACA;IACEG,IAAIZ;IACJa,aAAaL,KAAK,gBAAgBM,OAAO;IACzCC,eAAeP,KAAK,mBAAmBM,OAAO;IAC9CE,OAAOR,KAAK,UAAUM,OAAO;IAC7BG,MAAMP,2BAA2B,QAAQI,OAAO;IAChDI,gBAAgBhB,QAAQ,mBAAmBY,OAAO;IAClDK,QAAQd,KAAK,UAAUS,OAAO;IAC9B,0EAA0E;IAC1EM,OAAOf,KAAK;IACZgB,QAAQlB,MAAM,UAAUW,OAAO,GAAGQ,KAAK;IACvCC,WAAWjB,UAAU,cAAc;QAACkB,cAAc;IAAI,GAAGV,OAAO,GAAGW,UAAU;AAC/E,GACA,CAACC,QAAU;QACTnB,YAAY,+DAA+DoB,EAAE,CAC3ED,MAAMV,KAAK,EACXU,MAAMT,IAAI,EACVS,MAAMR,cAAc;QAEtBjB,MAAM,iDAAiD0B,EAAE,CACvDD,MAAMb,WAAW,EACjBa,MAAMP,MAAM,EACZO,MAAMN,KAAK;QAEbnB,MAAM,+CAA+C0B,EAAE,CAACD,MAAMV,KAAK;KACpE,EACD;AAKF,OAAO,SAASY,0BAA0BC,GAA8B;IACtE,OAAO;QACLjB,IAAIiB,IAAIjB,EAAE;QACVC,aAAagB,IAAIhB,WAAW;QAC5BE,eAAec,IAAId,aAAa;QAChCC,OAAOa,IAAIb,KAAK;QAChBC,MAAMY,IAAIZ,IAAI;QACdC,gBAAgBW,IAAIX,cAAc;QAClCC,QAAQU,IAAIV,MAAM;QAClBC,OAAOS,IAAIT,KAAK;QAChBC,QAAQQ,IAAIR,MAAM;QAClBE,WAAWM,IAAIN,SAAS;IAC1B;AACF"}

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

@@ -42,14 +42,14 @@ export declare const triggersReceivedEvents: import("drizzle-orm/pg-core").PgTab
             tableName: "received_events";
             dataType: "string";
             columnType: "PgText";
-            data: "cron" | "integration" | "manual";
+            data: "cron" | "dev" | "integration" | "manual";
             driverParam: string;
             notNull: true;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: ["integration", "manual", "cron"];
+            enumValues: ["integration", "manual", "cron", "dev"];
             baseColumn: never;
             identity: undefined;
             generated: undefined;
@@ -122,6 +122,23 @@ export declare const triggersReceivedEvents: import("drizzle-orm/pg-core").PgTab
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        replayOfEventId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "replay_of_event_id";
+            tableName: "received_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;
+        }, {}, {}>;
         deliveryId: import("drizzle-orm/pg-core").PgColumn<{
             name: "delivery_id";
             tableName: "received_events";
@@ -323,14 +340,14 @@ export declare const triggerReceivedEventSummaryColumns: {
         tableName: "received_events";
         dataType: "string";
         columnType: "PgText";
-        data: "cron" | "integration" | "manual";
+        data: "cron" | "dev" | "integration" | "manual";
         driverParam: string;
         notNull: true;
         hasDefault: false;
         isPrimaryKey: false;
         isAutoincrement: false;
         hasRuntimeDefault: false;
-        enumValues: ["integration", "manual", "cron"];
+        enumValues: ["integration", "manual", "cron", "dev"];
         baseColumn: never;
         identity: undefined;
         generated: undefined;
@@ -403,6 +420,23 @@ export declare const triggerReceivedEventSummaryColumns: {
         identity: undefined;
         generated: undefined;
     }, {}, {}>;
+    readonly replayOfEventId: import("drizzle-orm/pg-core").PgColumn<{
+        name: "replay_of_event_id";
+        tableName: "received_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;
+    }, {}, {}>;
     readonly deliveryId: import("drizzle-orm/pg-core").PgColumn<{
         name: "delivery_id";
         tableName: "received_events";

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

@@ -1 +1 @@
-{"version":3,"file":"received-events.d.ts","sourceRoot":"","sources":["../../../src/db/schema/received-events.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EAGjC,MAAM,kCAAkC,CAAC;AAG1C,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkClC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAC,YAAY,CAAC;AAChF,MAAM,MAAM,4BAA4B,GAAG,OAAO,sBAAsB,CAAC,YAAY,CAAC;AAEtF,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,sBAAsB,GAAG,oBAAoB,CAmBxF;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBwB,CAAC;AAExE,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,IAAI,CAAC,sBAAsB,EAAE,SAAS,CAAC,GAC3C,2BAA2B,CAE7B"}
+{"version":3,"file":"received-events.d.ts","sourceRoot":"","sources":["../../../src/db/schema/received-events.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EAGjC,MAAM,kCAAkC,CAAC;AAG1C,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0ClC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAC,YAAY,CAAC;AAChF,MAAM,MAAM,4BAA4B,GAAG,OAAO,sBAAsB,CAAC,YAAY,CAAC;AAEtF,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,sBAAsB,GAAG,oBAAoB,CAoBxF;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBwB,CAAC;AAExE,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,IAAI,CAAC,sBAAsB,EAAE,SAAS,CAAC,GAC3C,2BAA2B,CAE7B"}

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

@@ -1,4 +1,5 @@
 import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { sql } from 'drizzle-orm';
 import { index, integer, jsonb, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
 import { triggerEventOrigins, triggerEventOutcomes } from '#core/entities/received-event.js';
 import { pgTable } from './common.js';
@@ -15,6 +16,9 @@ export const triggersReceivedEvents = pgTable('received_events', {
     provider: text('provider'),
     source: text('source').notNull(),
     event: text('event').notNull(),
+    // Source event this entry replays (dev runs only); no foreign key: the
+    // source row may be pruned while its replay link must stay.
+    replayOfEventId: uuid('replay_of_event_id'),
     deliveryId: text('delivery_id'),
     connectionId: uuid('connection_id'),
     connectionName: text('connection_name'),
@@ -36,9 +40,12 @@ export const triggersReceivedEvents = pgTable('received_events', {
         uniqueIndex('triggers_received_events_event_ref_unique').on(table.eventRef),
         index('triggers_received_events_workspace_received_idx').on(table.workspaceId, table.receivedAt.desc()),
         index('triggers_received_events_prune_idx').on(table.createdAt),
-        // Back the workspace-scoped facet group-by (distinct source / event values).
+        // Back the workspace-scoped facet group-by (distinct source / event / origin values).
         index('triggers_received_events_workspace_source_idx').on(table.workspaceId, table.source),
-        index('triggers_received_events_workspace_event_idx').on(table.workspaceId, table.event)
+        index('triggers_received_events_workspace_event_idx').on(table.workspaceId, table.event),
+        index('triggers_received_events_workspace_origin_idx').on(table.workspaceId, table.origin),
+        // Back the replay link direction: which events replayed a given source event.
+        index('triggers_received_events_replay_of_event_id_idx').on(table.replayOfEventId).where(sql`${table.replayOfEventId} IS NOT NULL`)
     ]);
 export function toTriggerReceivedEvent(row) {
     return {
@@ -49,6 +56,7 @@ export function toTriggerReceivedEvent(row) {
         provider: row.provider,
         source: row.source,
         event: row.event,
+        replayOfEventId: row.replayOfEventId,
         deliveryId: row.deliveryId,
         connectionId: row.connectionId,
         connectionName: row.connectionName,
@@ -68,6 +76,7 @@ export const triggerReceivedEventSummaryColumns = {
     provider: triggersReceivedEvents.provider,
     source: triggersReceivedEvents.source,
     event: triggersReceivedEvents.event,
+    replayOfEventId: triggersReceivedEvents.replayOfEventId,
     deliveryId: triggersReceivedEvents.deliveryId,
     connectionId: triggersReceivedEvents.connectionId,
     connectionName: triggersReceivedEvents.connectionName,

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/db/schema/received-events.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {index, integer, jsonb, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport {\n  type TriggerReceivedEvent,\n  type TriggerReceivedEventSummary,\n  triggerEventOrigins,\n  triggerEventOutcomes,\n} from '#core/entities/received-event.js';\nimport {pgTable} from './common.js';\n\nexport const triggersReceivedEvents = pgTable(\n  'received_events',\n  {\n    id: uuidv7PrimaryKey(),\n    // Globally-unique idempotency key (the outbox event id), not the provider\n    // delivery id: delivery ids are only unique per provider and would collide\n    // across workspaces under the global event_ref unique index below.\n    eventRef: text('event_ref').notNull(),\n    origin: text('origin', {enum: triggerEventOrigins}).notNull(),\n    workspaceId: uuid('workspace_id').notNull(),\n    provider: text('provider'),\n    source: text('source').notNull(),\n    event: text('event').notNull(),\n    deliveryId: text('delivery_id'),\n    connectionId: uuid('connection_id'),\n    connectionName: text('connection_name'),\n    outcome: text('outcome', {enum: triggerEventOutcomes}).notNull().default('received'),\n    matchedCount: integer('matched_count').notNull().default(0),\n    payload: jsonb('payload').$type<Record<string, unknown>>(),\n    receivedAt: timestamp('received_at', {withTimezone: true}).notNull(),\n    processedAt: timestamp('processed_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('triggers_received_events_event_ref_unique').on(table.eventRef),\n    index('triggers_received_events_workspace_received_idx').on(\n      table.workspaceId,\n      table.receivedAt.desc(),\n    ),\n    index('triggers_received_events_prune_idx').on(table.createdAt),\n    // Back the workspace-scoped facet group-by (distinct source / event values).\n    index('triggers_received_events_workspace_source_idx').on(table.workspaceId, table.source),\n    index('triggers_received_events_workspace_event_idx').on(table.workspaceId, table.event),\n  ],\n);\n\nexport type TriggerReceivedEventDb = typeof triggersReceivedEvents.$inferSelect;\nexport type TriggerReceivedEventInsertDb = typeof triggersReceivedEvents.$inferInsert;\n\nexport function toTriggerReceivedEvent(row: TriggerReceivedEventDb): TriggerReceivedEvent {\n  return {\n    id: row.id,\n    eventRef: row.eventRef,\n    origin: row.origin,\n    workspaceId: row.workspaceId,\n    provider: row.provider,\n    source: row.source,\n    event: row.event,\n    deliveryId: row.deliveryId,\n    connectionId: row.connectionId,\n    connectionName: row.connectionName,\n    outcome: row.outcome,\n    matchedCount: row.matchedCount,\n    payload: row.payload,\n    receivedAt: row.receivedAt,\n    processedAt: row.processedAt,\n    createdAt: row.createdAt,\n  };\n}\n\nexport const triggerReceivedEventSummaryColumns = {\n  id: triggersReceivedEvents.id,\n  eventRef: triggersReceivedEvents.eventRef,\n  origin: triggersReceivedEvents.origin,\n  workspaceId: triggersReceivedEvents.workspaceId,\n  provider: triggersReceivedEvents.provider,\n  source: triggersReceivedEvents.source,\n  event: triggersReceivedEvents.event,\n  deliveryId: triggersReceivedEvents.deliveryId,\n  connectionId: triggersReceivedEvents.connectionId,\n  connectionName: triggersReceivedEvents.connectionName,\n  outcome: triggersReceivedEvents.outcome,\n  matchedCount: triggersReceivedEvents.matchedCount,\n  receivedAt: triggersReceivedEvents.receivedAt,\n  processedAt: triggersReceivedEvents.processedAt,\n  createdAt: triggersReceivedEvents.createdAt,\n} as const satisfies Record<keyof TriggerReceivedEventSummary, unknown>;\n\nexport function toTriggerReceivedEventSummary(\n  row: Omit<TriggerReceivedEventDb, 'payload'>,\n): TriggerReceivedEventSummary {\n  return {...row};\n}\n"],"names":["uuidv7PrimaryKey","index","integer","jsonb","text","timestamp","uniqueIndex","uuid","triggerEventOrigins","triggerEventOutcomes","pgTable","triggersReceivedEvents","id","eventRef","notNull","origin","enum","workspaceId","provider","source","event","deliveryId","connectionId","connectionName","outcome","default","matchedCount","payload","$type","receivedAt","withTimezone","processedAt","createdAt","defaultNow","table","on","desc","toTriggerReceivedEvent","row","triggerReceivedEventSummaryColumns","toTriggerReceivedEventSummary"],"mappings":"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"}
+{"version":3,"sources":["../../../src/db/schema/received-events.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {index, integer, jsonb, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport {\n  type TriggerReceivedEvent,\n  type TriggerReceivedEventSummary,\n  triggerEventOrigins,\n  triggerEventOutcomes,\n} from '#core/entities/received-event.js';\nimport {pgTable} from './common.js';\n\nexport const triggersReceivedEvents = pgTable(\n  'received_events',\n  {\n    id: uuidv7PrimaryKey(),\n    // Globally-unique idempotency key (the outbox event id), not the provider\n    // delivery id: delivery ids are only unique per provider and would collide\n    // across workspaces under the global event_ref unique index below.\n    eventRef: text('event_ref').notNull(),\n    origin: text('origin', {enum: triggerEventOrigins}).notNull(),\n    workspaceId: uuid('workspace_id').notNull(),\n    provider: text('provider'),\n    source: text('source').notNull(),\n    event: text('event').notNull(),\n    // Source event this entry replays (dev runs only); no foreign key: the\n    // source row may be pruned while its replay link must stay.\n    replayOfEventId: uuid('replay_of_event_id'),\n    deliveryId: text('delivery_id'),\n    connectionId: uuid('connection_id'),\n    connectionName: text('connection_name'),\n    outcome: text('outcome', {enum: triggerEventOutcomes}).notNull().default('received'),\n    matchedCount: integer('matched_count').notNull().default(0),\n    payload: jsonb('payload').$type<Record<string, unknown>>(),\n    receivedAt: timestamp('received_at', {withTimezone: true}).notNull(),\n    processedAt: timestamp('processed_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('triggers_received_events_event_ref_unique').on(table.eventRef),\n    index('triggers_received_events_workspace_received_idx').on(\n      table.workspaceId,\n      table.receivedAt.desc(),\n    ),\n    index('triggers_received_events_prune_idx').on(table.createdAt),\n    // Back the workspace-scoped facet group-by (distinct source / event / origin values).\n    index('triggers_received_events_workspace_source_idx').on(table.workspaceId, table.source),\n    index('triggers_received_events_workspace_event_idx').on(table.workspaceId, table.event),\n    index('triggers_received_events_workspace_origin_idx').on(table.workspaceId, table.origin),\n    // Back the replay link direction: which events replayed a given source event.\n    index('triggers_received_events_replay_of_event_id_idx')\n      .on(table.replayOfEventId)\n      .where(sql`${table.replayOfEventId} IS NOT NULL`),\n  ],\n);\n\nexport type TriggerReceivedEventDb = typeof triggersReceivedEvents.$inferSelect;\nexport type TriggerReceivedEventInsertDb = typeof triggersReceivedEvents.$inferInsert;\n\nexport function toTriggerReceivedEvent(row: TriggerReceivedEventDb): TriggerReceivedEvent {\n  return {\n    id: row.id,\n    eventRef: row.eventRef,\n    origin: row.origin,\n    workspaceId: row.workspaceId,\n    provider: row.provider,\n    source: row.source,\n    event: row.event,\n    replayOfEventId: row.replayOfEventId,\n    deliveryId: row.deliveryId,\n    connectionId: row.connectionId,\n    connectionName: row.connectionName,\n    outcome: row.outcome,\n    matchedCount: row.matchedCount,\n    payload: row.payload,\n    receivedAt: row.receivedAt,\n    processedAt: row.processedAt,\n    createdAt: row.createdAt,\n  };\n}\n\nexport const triggerReceivedEventSummaryColumns = {\n  id: triggersReceivedEvents.id,\n  eventRef: triggersReceivedEvents.eventRef,\n  origin: triggersReceivedEvents.origin,\n  workspaceId: triggersReceivedEvents.workspaceId,\n  provider: triggersReceivedEvents.provider,\n  source: triggersReceivedEvents.source,\n  event: triggersReceivedEvents.event,\n  replayOfEventId: triggersReceivedEvents.replayOfEventId,\n  deliveryId: triggersReceivedEvents.deliveryId,\n  connectionId: triggersReceivedEvents.connectionId,\n  connectionName: triggersReceivedEvents.connectionName,\n  outcome: triggersReceivedEvents.outcome,\n  matchedCount: triggersReceivedEvents.matchedCount,\n  receivedAt: triggersReceivedEvents.receivedAt,\n  processedAt: triggersReceivedEvents.processedAt,\n  createdAt: triggersReceivedEvents.createdAt,\n} as const satisfies Record<keyof TriggerReceivedEventSummary, unknown>;\n\nexport function toTriggerReceivedEventSummary(\n  row: Omit<TriggerReceivedEventDb, 'payload'>,\n): TriggerReceivedEventSummary {\n  return {...row};\n}\n"],"names":["uuidv7PrimaryKey","sql","index","integer","jsonb","text","timestamp","uniqueIndex","uuid","triggerEventOrigins","triggerEventOutcomes","pgTable","triggersReceivedEvents","id","eventRef","notNull","origin","enum","workspaceId","provider","source","event","replayOfEventId","deliveryId","connectionId","connectionName","outcome","default","matchedCount","payload","$type","receivedAt","withTimezone","processedAt","createdAt","defaultNow","table","on","desc","where","toTriggerReceivedEvent","row","triggerReceivedEventSummaryColumns","toTriggerReceivedEventSummary"],"mappings":"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"}

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

@@ -112,7 +112,7 @@ export declare const triggerSubscriptions: import("drizzle-orm/pg-core").PgTable
             columnType: "PgText";
             data: string;
             driverParam: string;
-            notNull: true;
+            notNull: false;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;

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

@@ -1 +1 @@
-{"version":3,"file":"subscriptions.d.ts","sourceRoot":"","sources":["../../../src/db/schema/subscriptions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AAGxE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBhC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AAC7E,MAAM,MAAM,2BAA2B,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AAEnF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,qBAAqB,GAAG,mBAAmB,CAarF"}
+{"version":3,"file":"subscriptions.d.ts","sourceRoot":"","sources":["../../../src/db/schema/subscriptions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AAGxE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBhC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AAC7E,MAAM,MAAM,2BAA2B,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AAEnF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,qBAAqB,GAAG,mBAAmB,CAarF"}

package/dist/db/schema/subscriptions.js

@@ -8,7 +8,8 @@ export const triggerSubscriptions = pgTable('subscriptions', {
     workflowDefinitionId: uuid('workflow_definition_id').notNull(),
     name: text('name').notNull(),
     source: text('source').notNull(),
-    event: text('event').notNull(),
+    // NULL is a source subscription: matches every event the source delivers.
+    event: text('event'),
     config: jsonb('config').notNull(),
     createdAt: timestamp('created_at', {
         withTimezone: true

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/db/schema/subscriptions.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {index, jsonb, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {TriggerSubscription} from '#core/entities/subscription.js';\nimport {pgTable} from './common.js';\n\nexport const triggerSubscriptions = pgTable(\n  'subscriptions',\n  {\n    id: uuidv7PrimaryKey(),\n    workspaceId: uuid('workspace_id').notNull(),\n    projectId: uuid('project_id').notNull(),\n    workflowDefinitionId: uuid('workflow_definition_id').notNull(),\n    name: text('name').notNull(),\n    source: text('source').notNull(),\n    event: text('event').notNull(),\n    config: jsonb('config').notNull(),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('triggers_subscriptions_definition_name_unique').on(\n      table.workflowDefinitionId,\n      table.name,\n    ),\n    index('triggers_subscriptions_match_idx').on(table.workspaceId, table.source, table.event),\n    index('triggers_subscriptions_definition_idx').on(table.workflowDefinitionId),\n  ],\n);\n\nexport type TriggerSubscriptionDb = typeof triggerSubscriptions.$inferSelect;\nexport type TriggerSubscriptionInsertDb = typeof triggerSubscriptions.$inferInsert;\n\nexport function toTriggerSubscription(row: TriggerSubscriptionDb): TriggerSubscription {\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    projectId: row.projectId,\n    workflowDefinitionId: row.workflowDefinitionId,\n    name: row.name,\n    source: row.source,\n    event: row.event,\n    config: row.config as Record<string, unknown>,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","index","jsonb","text","timestamp","uniqueIndex","uuid","pgTable","triggerSubscriptions","id","workspaceId","notNull","projectId","workflowDefinitionId","name","source","event","config","createdAt","withTimezone","defaultNow","updatedAt","table","on","toTriggerSubscription","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,KAAK,EAAEC,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAErF,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,uBAAuBD,QAClC,iBACA;IACEE,IAAIT;IACJU,aAAaJ,KAAK,gBAAgBK,OAAO;IACzCC,WAAWN,KAAK,cAAcK,OAAO;IACrCE,sBAAsBP,KAAK,0BAA0BK,OAAO;IAC5DG,MAAMX,KAAK,QAAQQ,OAAO;IAC1BI,QAAQZ,KAAK,UAAUQ,OAAO;IAC9BK,OAAOb,KAAK,SAASQ,OAAO;IAC5BM,QAAQf,MAAM,UAAUS,OAAO;IAC/BO,WAAWd,UAAU,cAAc;QAACe,cAAc;IAAI,GAAGR,OAAO,GAAGS,UAAU;IAC7EC,WAAWjB,UAAU,cAAc;QAACe,cAAc;IAAI,GAAGR,OAAO,GAAGS,UAAU;AAC/E,GACA,CAACE,QAAU;QACTjB,YAAY,iDAAiDkB,EAAE,CAC7DD,MAAMT,oBAAoB,EAC1BS,MAAMR,IAAI;QAEZb,MAAM,oCAAoCsB,EAAE,CAACD,MAAMZ,WAAW,EAAEY,MAAMP,MAAM,EAAEO,MAAMN,KAAK;QACzFf,MAAM,yCAAyCsB,EAAE,CAACD,MAAMT,oBAAoB;KAC7E,EACD;AAKF,OAAO,SAASW,sBAAsBC,GAA0B;IAC9D,OAAO;QACLhB,IAAIgB,IAAIhB,EAAE;QACVC,aAAae,IAAIf,WAAW;QAC5BE,WAAWa,IAAIb,SAAS;QACxBC,sBAAsBY,IAAIZ,oBAAoB;QAC9CC,MAAMW,IAAIX,IAAI;QACdC,QAAQU,IAAIV,MAAM;QAClBC,OAAOS,IAAIT,KAAK;QAChBC,QAAQQ,IAAIR,MAAM;QAClBC,WAAWO,IAAIP,SAAS;QACxBG,WAAWI,IAAIJ,SAAS;IAC1B;AACF"}
+{"version":3,"sources":["../../../src/db/schema/subscriptions.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {index, jsonb, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {TriggerSubscription} from '#core/entities/subscription.js';\nimport {pgTable} from './common.js';\n\nexport const triggerSubscriptions = pgTable(\n  'subscriptions',\n  {\n    id: uuidv7PrimaryKey(),\n    workspaceId: uuid('workspace_id').notNull(),\n    projectId: uuid('project_id').notNull(),\n    workflowDefinitionId: uuid('workflow_definition_id').notNull(),\n    name: text('name').notNull(),\n    source: text('source').notNull(),\n    // NULL is a source subscription: matches every event the source delivers.\n    event: text('event'),\n    config: jsonb('config').notNull(),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('triggers_subscriptions_definition_name_unique').on(\n      table.workflowDefinitionId,\n      table.name,\n    ),\n    index('triggers_subscriptions_match_idx').on(table.workspaceId, table.source, table.event),\n    index('triggers_subscriptions_definition_idx').on(table.workflowDefinitionId),\n  ],\n);\n\nexport type TriggerSubscriptionDb = typeof triggerSubscriptions.$inferSelect;\nexport type TriggerSubscriptionInsertDb = typeof triggerSubscriptions.$inferInsert;\n\nexport function toTriggerSubscription(row: TriggerSubscriptionDb): TriggerSubscription {\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    projectId: row.projectId,\n    workflowDefinitionId: row.workflowDefinitionId,\n    name: row.name,\n    source: row.source,\n    event: row.event,\n    config: row.config as Record<string, unknown>,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","index","jsonb","text","timestamp","uniqueIndex","uuid","pgTable","triggerSubscriptions","id","workspaceId","notNull","projectId","workflowDefinitionId","name","source","event","config","createdAt","withTimezone","defaultNow","updatedAt","table","on","toTriggerSubscription","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,KAAK,EAAEC,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAErF,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,uBAAuBD,QAClC,iBACA;IACEE,IAAIT;IACJU,aAAaJ,KAAK,gBAAgBK,OAAO;IACzCC,WAAWN,KAAK,cAAcK,OAAO;IACrCE,sBAAsBP,KAAK,0BAA0BK,OAAO;IAC5DG,MAAMX,KAAK,QAAQQ,OAAO;IAC1BI,QAAQZ,KAAK,UAAUQ,OAAO;IAC9B,0EAA0E;IAC1EK,OAAOb,KAAK;IACZc,QAAQf,MAAM,UAAUS,OAAO;IAC/BO,WAAWd,UAAU,cAAc;QAACe,cAAc;IAAI,GAAGR,OAAO,GAAGS,UAAU;IAC7EC,WAAWjB,UAAU,cAAc;QAACe,cAAc;IAAI,GAAGR,OAAO,GAAGS,UAAU;AAC/E,GACA,CAACE,QAAU;QACTjB,YAAY,iDAAiDkB,EAAE,CAC7DD,MAAMT,oBAAoB,EAC1BS,MAAMR,IAAI;QAEZb,MAAM,oCAAoCsB,EAAE,CAACD,MAAMZ,WAAW,EAAEY,MAAMP,MAAM,EAAEO,MAAMN,KAAK;QACzFf,MAAM,yCAAyCsB,EAAE,CAACD,MAAMT,oBAAoB;KAC7E,EACD;AAKF,OAAO,SAASW,sBAAsBC,GAA0B;IAC9D,OAAO;QACLhB,IAAIgB,IAAIhB,EAAE;QACVC,aAAae,IAAIf,WAAW;QAC5BE,WAAWa,IAAIb,SAAS;QACxBC,sBAAsBY,IAAIZ,oBAAoB;QAC9CC,MAAMW,IAAIX,IAAI;QACdC,QAAQU,IAAIV,MAAM;QAClBC,OAAOS,IAAIT,KAAK;QAChBC,QAAQQ,IAAIR,MAAM;QAClBC,WAAWO,IAAIP,SAAS;QACxBG,WAAWI,IAAIJ,SAAS;IAC1B;AACF"}

package/dist/db/subscription-event.d.ts

@@ -0,0 +1,7 @@
+import type { PgColumn } from 'drizzle-orm/pg-core';
+export declare function normalizeSubscriptionEvent(params: {
+    source: string;
+    event: string | null | undefined;
+}): string | null;
+export declare function subscriptionEventCondition(column: PgColumn, event: string): import("drizzle-orm").SQL<unknown> | undefined;
+//# sourceMappingURL=subscription-event.d.ts.map

package/dist/db/subscription-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription-event.d.ts","sourceRoot":"","sources":["../../src/db/subscription-event.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,qBAAqB,CAAC;AAElD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAClC,GAAG,MAAM,GAAG,IAAI,CAahB;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,kDAEzE"}

package/dist/db/subscription-event.js

@@ -0,0 +1,19 @@
+import { eq, isNull, or } from 'drizzle-orm';
+export function normalizeSubscriptionEvent(params) {
+    if (params.event === undefined || params.event === null) {
+        if (params.source === 'manual' || params.source === 'cron') {
+            throw new Error(`A ${params.source} subscription requires an event`);
+        }
+        return null;
+    }
+    const normalizedEvent = params.event.trim();
+    if (normalizedEvent === '') {
+        throw new Error(`A ${params.source} subscription event cannot be blank`);
+    }
+    return normalizedEvent;
+}
+export function subscriptionEventCondition(column, event) {
+    return or(eq(column, event), isNull(column));
+}
+
+//# sourceMappingURL=subscription-event.js.map

package/dist/db/subscription-event.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/subscription-event.ts"],"sourcesContent":["import {eq, isNull, or} from 'drizzle-orm';\nimport type {PgColumn} from 'drizzle-orm/pg-core';\n\nexport function normalizeSubscriptionEvent(params: {\n  source: string;\n  event: string | null | undefined;\n}): string | null {\n  if (params.event === undefined || params.event === null) {\n    if (params.source === 'manual' || params.source === 'cron') {\n      throw new Error(`A ${params.source} subscription requires an event`);\n    }\n    return null;\n  }\n\n  const normalizedEvent = params.event.trim();\n  if (normalizedEvent === '') {\n    throw new Error(`A ${params.source} subscription event cannot be blank`);\n  }\n  return normalizedEvent;\n}\n\nexport function subscriptionEventCondition(column: PgColumn, event: string) {\n  return or(eq(column, event), isNull(column));\n}\n"],"names":["eq","isNull","or","normalizeSubscriptionEvent","params","event","undefined","source","Error","normalizedEvent","trim","subscriptionEventCondition","column"],"mappings":"AAAA,SAAQA,EAAE,EAAEC,MAAM,EAAEC,EAAE,QAAO,cAAc;AAG3C,OAAO,SAASC,2BAA2BC,MAG1C;IACC,IAAIA,OAAOC,KAAK,KAAKC,aAAaF,OAAOC,KAAK,KAAK,MAAM;QACvD,IAAID,OAAOG,MAAM,KAAK,YAAYH,OAAOG,MAAM,KAAK,QAAQ;YAC1D,MAAM,IAAIC,MAAM,CAAC,EAAE,EAAEJ,OAAOG,MAAM,CAAC,+BAA+B,CAAC;QACrE;QACA,OAAO;IACT;IAEA,MAAME,kBAAkBL,OAAOC,KAAK,CAACK,IAAI;IACzC,IAAID,oBAAoB,IAAI;QAC1B,MAAM,IAAID,MAAM,CAAC,EAAE,EAAEJ,OAAOG,MAAM,CAAC,mCAAmC,CAAC;IACzE;IACA,OAAOE;AACT;AAEA,OAAO,SAASE,2BAA2BC,MAAgB,EAAEP,KAAa;IACxE,OAAOH,GAAGF,GAAGY,QAAQP,QAAQJ,OAAOW;AACtC"}

package/dist/db/subscriptions.d.ts

@@ -1,12 +1,15 @@
 import type { TriggerDto } from '@shipfox/api-definitions-dto';
 import type { TriggerSubscription } from '#core/entities/subscription.js';
 import { type Tx } from './db.js';
+interface ProjectDefinitionTrigger extends Omit<TriggerDto, 'event'> {
+    event?: string | undefined;
+}
 export interface ProjectDefinitionTriggersParams {
     tx?: Tx | undefined;
     workspaceId: string;
     projectId: string;
     workflowDefinitionId: string;
-    triggers: Record<string, TriggerDto>;
+    triggers: Record<string, ProjectDefinitionTrigger>;
 }
 export declare function projectDefinitionTriggers(params: ProjectDefinitionTriggersParams): Promise<void>;
 export interface DeleteSubscriptionsForDefinitionParams {
@@ -23,4 +26,5 @@ export interface FindMatchingSubscriptionsParams {
 }
 export declare function findMatchingSubscriptions(params: FindMatchingSubscriptionsParams): Promise<TriggerSubscription[]>;
 export declare function listSubscriptionsByWorkflowDefinitionIds(workflowDefinitionIds: string[]): Promise<TriggerSubscription[]>;
+export {};
 //# sourceMappingURL=subscriptions.d.ts.map

package/dist/db/subscriptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subscriptions.d.ts","sourceRoot":"","sources":["../../src/db/subscriptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAE7D,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AAExE,OAAO,EAAoB,KAAK,EAAE,EAAC,MAAM,SAAS,CAAC;AAGnD,MAAM,WAAW,+BAA+B;IAC9C,EAAE,CAAC,EAAE,EAAE,GAAG,SAAS,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACtC;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,+BAA+B,GACtC,OAAO,CAAC,IAAI,CAAC,CAqEf;AAED,MAAM,WAAW,sCAAsC;IACrD,EAAE,CAAC,EAAE,EAAE,GAAG,SAAS,CAAC;IACpB,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,wBAAsB,gCAAgC,CACpD,MAAM,EAAE,sCAAsC,GAC7C,OAAO,CAAC,MAAM,CAAC,CAUjB;AAED,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAS1C;AAED,wBAAsB,mCAAmC,CACvD,oBAAoB,EAAE,MAAM,GAC3B,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAoB1C;AAED,MAAM,WAAW,+BAA+B;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAKD,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,+BAA+B,GACtC,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAYhC;AAED,wBAAsB,wCAAwC,CAC5D,qBAAqB,EAAE,MAAM,EAAE,GAC9B,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAOhC"}
+{"version":3,"file":"subscriptions.d.ts","sourceRoot":"","sources":["../../src/db/subscriptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAE7D,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AAExE,OAAO,EAAoB,KAAK,EAAE,EAAC,MAAM,SAAS,CAAC;AAInD,UAAU,wBAAyB,SAAQ,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC;IAClE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B;AAED,MAAM,WAAW,+BAA+B;IAC9C,EAAE,CAAC,EAAE,EAAE,GAAG,SAAS,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;CACpD;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,+BAA+B,GACtC,OAAO,CAAC,IAAI,CAAC,CAqEf;AAED,MAAM,WAAW,sCAAsC;IACrD,EAAE,CAAC,EAAE,EAAE,GAAG,SAAS,CAAC;IACpB,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,wBAAsB,gCAAgC,CACpD,MAAM,EAAE,sCAAsC,GAC7C,OAAO,CAAC,MAAM,CAAC,CAUjB;AAED,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAS1C;AAED,wBAAsB,mCAAmC,CACvD,oBAAoB,EAAE,MAAM,GAC3B,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAoB1C;AAED,MAAM,WAAW,+BAA+B;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAKD,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,+BAA+B,GACtC,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAYhC;AAED,wBAAsB,wCAAwC,CAC5D,qBAAqB,EAAE,MAAM,EAAE,GAC9B,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAOhC"}

package/dist/db/subscriptions.js

@@ -2,6 +2,7 @@ import { and, eq, inArray, notInArray } from 'drizzle-orm';
 import { deleteCronScheduleForSubscription, syncCronSchedule } from './cron-schedules.js';
 import { db } from './db.js';
 import { toTriggerSubscription, triggerSubscriptions } from './schema/subscriptions.js';
+import { normalizeSubscriptionEvent, subscriptionEventCondition } from './subscription-event.js';
 export async function projectDefinitionTriggers(params) {
     const work = async (tx)=>{
         const entries = Object.entries(params.triggers);
@@ -21,7 +22,10 @@ export async function projectDefinitionTriggers(params) {
                 workflowDefinitionId: params.workflowDefinitionId,
                 name,
                 source: trigger.source,
-                event: trigger.event,
+                event: normalizeSubscriptionEvent({
+                    source: trigger.source,
+                    event: trigger.event
+                }),
                 config
             }).onConflictDoUpdate({
                 target: [
@@ -32,7 +36,10 @@ export async function projectDefinitionTriggers(params) {
                     workspaceId: params.workspaceId,
                     projectId: params.projectId,
                     source: trigger.source,
-                    event: trigger.event,
+                    event: normalizeSubscriptionEvent({
+                        source: trigger.source,
+                        event: trigger.event
+                    }),
                     config,
                     updatedAt: new Date()
                 }
@@ -91,7 +98,7 @@ export async function getManualSubscriptionByDefinitionId(workflowDefinitionId)
 // fact, not addressed to a project. Narrowing to a repo/project/branch is left to
 // user-defined per-workflow filters, not inferred here.
 export async function findMatchingSubscriptions(params) {
-    const rows = await db().select().from(triggerSubscriptions).where(and(eq(triggerSubscriptions.workspaceId, params.workspaceId), eq(triggerSubscriptions.source, params.source), eq(triggerSubscriptions.event, params.event)));
+    const rows = await db().select().from(triggerSubscriptions).where(and(eq(triggerSubscriptions.workspaceId, params.workspaceId), eq(triggerSubscriptions.source, params.source), subscriptionEventCondition(triggerSubscriptions.event, params.event)));
     return rows.map(toTriggerSubscription);
 }
 export async function listSubscriptionsByWorkflowDefinitionIds(workflowDefinitionIds) {