@shipfox/api-triggers 2.0.0

package/dist/core/errors.d.ts

@@ -0,0 +1,25 @@
+export declare class TriggerSubscriptionNotFoundError extends Error {
+    readonly subscriptionId: string;
+    constructor(subscriptionId: string);
+}
+export declare class ManualTriggerNotFoundError extends Error {
+    readonly workflowDefinitionId: string;
+    constructor(workflowDefinitionId: string);
+}
+export declare class TriggerSubscriptionNotManualError extends Error {
+    readonly subscriptionId: string;
+    readonly source: string;
+    constructor(subscriptionId: string, source: string);
+}
+export declare class TriggerSubscriptionNotCronError extends Error {
+    readonly subscriptionId: string;
+    readonly source: string;
+    constructor(subscriptionId: string, source: string);
+}
+export declare class TriggerWorkspaceMismatchError extends Error {
+    readonly subscriptionId: string;
+    readonly subscriptionWorkspaceId: string;
+    readonly callerWorkspaceId: string;
+    constructor(subscriptionId: string, subscriptionWorkspaceId: string, callerWorkspaceId: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/core/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,gCAAiC,SAAQ,KAAK;IACzD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;gBAEpB,cAAc,EAAE,MAAM;CAKnC;AAED,qBAAa,0BAA2B,SAAQ,KAAK;IACnD,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;gBAE1B,oBAAoB,EAAE,MAAM;CAKzC;AAED,qBAAa,iCAAkC,SAAQ,KAAK;IAC1D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAQnD;AAED,qBAAa,+BAAgC,SAAQ,KAAK;IACxD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAQnD;AAED,qBAAa,6BAA8B,SAAQ,KAAK;IACtD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;gBAEvB,cAAc,EAAE,MAAM,EAAE,uBAAuB,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM;CAS/F"}

package/dist/core/errors.js

@@ -0,0 +1,41 @@
+export class TriggerSubscriptionNotFoundError extends Error {
+    constructor(subscriptionId){
+        super(`Trigger subscription not found: ${subscriptionId}`);
+        this.name = 'TriggerSubscriptionNotFoundError';
+        this.subscriptionId = subscriptionId;
+    }
+}
+export class ManualTriggerNotFoundError extends Error {
+    constructor(workflowDefinitionId){
+        super(`Workflow definition ${workflowDefinitionId} has no manual trigger`);
+        this.name = 'ManualTriggerNotFoundError';
+        this.workflowDefinitionId = workflowDefinitionId;
+    }
+}
+export class TriggerSubscriptionNotManualError extends Error {
+    constructor(subscriptionId, source){
+        super(`Trigger subscription ${subscriptionId} has source '${source}', expected 'manual' for manual fire`);
+        this.name = 'TriggerSubscriptionNotManualError';
+        this.subscriptionId = subscriptionId;
+        this.source = source;
+    }
+}
+export class TriggerSubscriptionNotCronError extends Error {
+    constructor(subscriptionId, source){
+        super(`Trigger subscription ${subscriptionId} has source '${source}', expected 'cron' for cron fire`);
+        this.name = 'TriggerSubscriptionNotCronError';
+        this.subscriptionId = subscriptionId;
+        this.source = source;
+    }
+}
+export class TriggerWorkspaceMismatchError extends Error {
+    constructor(subscriptionId, subscriptionWorkspaceId, callerWorkspaceId){
+        super(`Trigger subscription ${subscriptionId} belongs to workspace ${subscriptionWorkspaceId}, not ${callerWorkspaceId}`);
+        this.name = 'TriggerWorkspaceMismatchError';
+        this.subscriptionId = subscriptionId;
+        this.subscriptionWorkspaceId = subscriptionWorkspaceId;
+        this.callerWorkspaceId = callerWorkspaceId;
+    }
+}
+
+//# sourceMappingURL=errors.js.map

package/dist/core/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/errors.ts"],"sourcesContent":["export class TriggerSubscriptionNotFoundError extends Error {\n  readonly subscriptionId: string;\n\n  constructor(subscriptionId: string) {\n    super(`Trigger subscription not found: ${subscriptionId}`);\n    this.name = 'TriggerSubscriptionNotFoundError';\n    this.subscriptionId = subscriptionId;\n  }\n}\n\nexport class ManualTriggerNotFoundError extends Error {\n  readonly workflowDefinitionId: string;\n\n  constructor(workflowDefinitionId: string) {\n    super(`Workflow definition ${workflowDefinitionId} has no manual trigger`);\n    this.name = 'ManualTriggerNotFoundError';\n    this.workflowDefinitionId = workflowDefinitionId;\n  }\n}\n\nexport class TriggerSubscriptionNotManualError extends Error {\n  readonly subscriptionId: string;\n  readonly source: string;\n\n  constructor(subscriptionId: string, source: string) {\n    super(\n      `Trigger subscription ${subscriptionId} has source '${source}', expected 'manual' for manual fire`,\n    );\n    this.name = 'TriggerSubscriptionNotManualError';\n    this.subscriptionId = subscriptionId;\n    this.source = source;\n  }\n}\n\nexport class TriggerSubscriptionNotCronError extends Error {\n  readonly subscriptionId: string;\n  readonly source: string;\n\n  constructor(subscriptionId: string, source: string) {\n    super(\n      `Trigger subscription ${subscriptionId} has source '${source}', expected 'cron' for cron fire`,\n    );\n    this.name = 'TriggerSubscriptionNotCronError';\n    this.subscriptionId = subscriptionId;\n    this.source = source;\n  }\n}\n\nexport class TriggerWorkspaceMismatchError extends Error {\n  readonly subscriptionId: string;\n  readonly subscriptionWorkspaceId: string;\n  readonly callerWorkspaceId: string;\n\n  constructor(subscriptionId: string, subscriptionWorkspaceId: string, callerWorkspaceId: string) {\n    super(\n      `Trigger subscription ${subscriptionId} belongs to workspace ${subscriptionWorkspaceId}, not ${callerWorkspaceId}`,\n    );\n    this.name = 'TriggerWorkspaceMismatchError';\n    this.subscriptionId = subscriptionId;\n    this.subscriptionWorkspaceId = subscriptionWorkspaceId;\n    this.callerWorkspaceId = callerWorkspaceId;\n  }\n}\n"],"names":["TriggerSubscriptionNotFoundError","Error","subscriptionId","name","ManualTriggerNotFoundError","workflowDefinitionId","TriggerSubscriptionNotManualError","source","TriggerSubscriptionNotCronError","TriggerWorkspaceMismatchError","subscriptionWorkspaceId","callerWorkspaceId"],"mappings":"AAAA,OAAO,MAAMA,yCAAyCC;IAGpD,YAAYC,cAAsB,CAAE;QAClC,KAAK,CAAC,CAAC,gCAAgC,EAAEA,gBAAgB;QACzD,IAAI,CAACC,IAAI,GAAG;QACZ,IAAI,CAACD,cAAc,GAAGA;IACxB;AACF;AAEA,OAAO,MAAME,mCAAmCH;IAG9C,YAAYI,oBAA4B,CAAE;QACxC,KAAK,CAAC,CAAC,oBAAoB,EAAEA,qBAAqB,sBAAsB,CAAC;QACzE,IAAI,CAACF,IAAI,GAAG;QACZ,IAAI,CAACE,oBAAoB,GAAGA;IAC9B;AACF;AAEA,OAAO,MAAMC,0CAA0CL;IAIrD,YAAYC,cAAsB,EAAEK,MAAc,CAAE;QAClD,KAAK,CACH,CAAC,qBAAqB,EAAEL,eAAe,aAAa,EAAEK,OAAO,oCAAoC,CAAC;QAEpG,IAAI,CAACJ,IAAI,GAAG;QACZ,IAAI,CAACD,cAAc,GAAGA;QACtB,IAAI,CAACK,MAAM,GAAGA;IAChB;AACF;AAEA,OAAO,MAAMC,wCAAwCP;IAInD,YAAYC,cAAsB,EAAEK,MAAc,CAAE;QAClD,KAAK,CACH,CAAC,qBAAqB,EAAEL,eAAe,aAAa,EAAEK,OAAO,gCAAgC,CAAC;QAEhG,IAAI,CAACJ,IAAI,GAAG;QACZ,IAAI,CAACD,cAAc,GAAGA;QACtB,IAAI,CAACK,MAAM,GAAGA;IAChB;AACF;AAEA,OAAO,MAAME,sCAAsCR;IAKjD,YAAYC,cAAsB,EAAEQ,uBAA+B,EAAEC,iBAAyB,CAAE;QAC9F,KAAK,CACH,CAAC,qBAAqB,EAAET,eAAe,sBAAsB,EAAEQ,wBAAwB,MAAM,EAAEC,mBAAmB;QAEpH,IAAI,CAACR,IAAI,GAAG;QACZ,IAAI,CAACD,cAAc,GAAGA;QACtB,IAAI,CAACQ,uBAAuB,GAAGA;QAC/B,IAAI,CAACC,iBAAiB,GAAGA;IAC3B;AACF"}

package/dist/core/fire-cron.d.ts

@@ -0,0 +1,28 @@
+import { type WorkflowRun } from '@shipfox/api-workflows';
+export interface FireCronSubscriptionParams {
+    subscriptionId: string;
+    /**
+     * The `next_fire_at` value the schedule held when it was claimed. Anchoring the
+     * idempotency key and history `event_ref` on this slot, rather than wall-clock
+     * time, makes a retry of the same occurrence a deterministic no-op.
+     */
+    scheduledSlot: Date;
+}
+export type FireCronSubscriptionResult = {
+    outcome: 'fired';
+    run: WorkflowRun;
+} | {
+    outcome: 'errored';
+};
+/**
+ * Fires one cron schedule occurrence. Mirrors `fireManualSubscription`, but is driven
+ * by the drain activity rather than an HTTP route, and reports the outcome instead of
+ * throwing on a permanent failure so the caller can advance the schedule past a
+ * permanently broken definition:
+ *
+ * - `{outcome: 'fired'}` on success (or an idempotent replay of an already-created run),
+ * - `{outcome: 'errored'}` on a permanent `runWorkflow` failure (recorded, schedule advances),
+ * - throws on a transient failure so the caller rolls back the advance and retries.
+ */
+export declare function fireCronSubscription(params: FireCronSubscriptionParams): Promise<FireCronSubscriptionResult>;
+//# sourceMappingURL=fire-cron.d.ts.map

package/dist/core/fire-cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fire-cron.d.ts","sourceRoot":"","sources":["../../src/core/fire-cron.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,KAAK,WAAW,EAAC,MAAM,wBAAwB,CAAC;AAOlG,MAAM,WAAW,0BAA0B;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,aAAa,EAAE,IAAI,CAAC;CACrB;AAED,MAAM,MAAM,0BAA0B,GAClC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,WAAW,CAAA;CAAC,GACpC;IAAC,OAAO,EAAE,SAAS,CAAA;CAAC,CAAC;AAEzB;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,0BAA0B,CAAC,CA2DrC"}

package/dist/core/fire-cron.js

@@ -0,0 +1,85 @@
+import { isPermanentRunWorkflowError, runWorkflow } from '@shipfox/api-workflows';
+import { getTriggerSubscriptionById } from '#db/subscriptions.js';
+import { cronFiredCount, cronFireLag } from '#metrics/instance.js';
+import { readConfigInputs } from './config.js';
+import { TriggerSubscriptionNotCronError, TriggerSubscriptionNotFoundError } from './errors.js';
+import { beginTriggerHistory, toReason } from './record-trigger-history.js';
+/**
+ * Fires one cron schedule occurrence. Mirrors `fireManualSubscription`, but is driven
+ * by the drain activity rather than an HTTP route, and reports the outcome instead of
+ * throwing on a permanent failure so the caller can advance the schedule past a
+ * permanently broken definition:
+ *
+ * - `{outcome: 'fired'}` on success (or an idempotent replay of an already-created run),
+ * - `{outcome: 'errored'}` on a permanent `runWorkflow` failure (recorded, schedule advances),
+ * - throws on a transient failure so the caller rolls back the advance and retries.
+ */ export async function fireCronSubscription(params) {
+    const subscription = await getTriggerSubscriptionById(params.subscriptionId);
+    if (!subscription) throw new TriggerSubscriptionNotFoundError(params.subscriptionId);
+    if (subscription.source !== 'cron') {
+        throw new TriggerSubscriptionNotCronError(params.subscriptionId, subscription.source);
+    }
+    // Deterministic per-occurrence identity: unique across (subscription, slot), stable
+    // across retries. Used for both the run idempotency key and the received-event ref.
+    const eventRef = `${subscription.id}:${params.scheduledSlot.toISOString()}`;
+    const historyBase = {
+        origin: 'cron',
+        workspaceId: subscription.workspaceId,
+        provider: null,
+        source: subscription.source,
+        event: subscription.event,
+        deliveryId: null,
+        connectionId: null,
+        connectionName: null,
+        payload: null,
+        // The scheduled occurrence is the logical arrival time of the tick event.
+        receivedAt: params.scheduledSlot,
+        eventRef
+    };
+    let run;
+    try {
+        run = await runWorkflow({
+            workspaceId: subscription.workspaceId,
+            projectId: subscription.projectId,
+            definitionId: subscription.workflowDefinitionId,
+            triggerPayload: {
+                provider: 'cron',
+                source: 'cron',
+                event: 'tick',
+                scheduleId: subscription.id
+            },
+            inputs: readConfigInputs(subscription),
+            triggerIdempotencyKey: eventRef
+        });
+    } catch (error) {
+        const failure = await beginTriggerHistory(historyBase);
+        await failure.dispatchErrored(subscription, toReason(error));
+        if (isPermanentRunWorkflowError(error)) {
+            recordFire('errored', params.scheduledSlot);
+            await failure.allErrored(1);
+            return {
+                outcome: 'errored'
+            };
+        }
+        // Transient: leave the event non-terminal and re-throw so the caller rolls back
+        // the advance and the schedule stays due for the next tick.
+        await failure.failed(1);
+        throw error;
+    }
+    const history = await beginTriggerHistory(historyBase);
+    await history.triggered(subscription, run);
+    recordFire('fired', params.scheduledSlot);
+    await history.routed(1);
+    return {
+        outcome: 'fired',
+        run
+    };
+}
+function recordFire(outcome, scheduledSlot) {
+    cronFiredCount.add(1, {
+        outcome
+    });
+    cronFireLag.record(Math.max(0, Date.now() - scheduledSlot.getTime()));
+}
+
+//# sourceMappingURL=fire-cron.js.map

package/dist/core/fire-cron.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/fire-cron.ts"],"sourcesContent":["import {isPermanentRunWorkflowError, runWorkflow, type WorkflowRun} from '@shipfox/api-workflows';\nimport {getTriggerSubscriptionById} from '#db/subscriptions.js';\nimport {cronFiredCount, cronFireLag} from '#metrics/instance.js';\nimport {readConfigInputs} from './config.js';\nimport {TriggerSubscriptionNotCronError, TriggerSubscriptionNotFoundError} from './errors.js';\nimport {beginTriggerHistory, toReason} from './record-trigger-history.js';\n\nexport interface FireCronSubscriptionParams {\n  subscriptionId: string;\n  /**\n   * The `next_fire_at` value the schedule held when it was claimed. Anchoring the\n   * idempotency key and history `event_ref` on this slot, rather than wall-clock\n   * time, makes a retry of the same occurrence a deterministic no-op.\n   */\n  scheduledSlot: Date;\n}\n\nexport type FireCronSubscriptionResult =\n  | {outcome: 'fired'; run: WorkflowRun}\n  | {outcome: 'errored'};\n\n/**\n * Fires one cron schedule occurrence. Mirrors `fireManualSubscription`, but is driven\n * by the drain activity rather than an HTTP route, and reports the outcome instead of\n * throwing on a permanent failure so the caller can advance the schedule past a\n * permanently broken definition:\n *\n * - `{outcome: 'fired'}` on success (or an idempotent replay of an already-created run),\n * - `{outcome: 'errored'}` on a permanent `runWorkflow` failure (recorded, schedule advances),\n * - throws on a transient failure so the caller rolls back the advance and retries.\n */\nexport async function fireCronSubscription(\n  params: FireCronSubscriptionParams,\n): Promise<FireCronSubscriptionResult> {\n  const subscription = await getTriggerSubscriptionById(params.subscriptionId);\n  if (!subscription) throw new TriggerSubscriptionNotFoundError(params.subscriptionId);\n  if (subscription.source !== 'cron') {\n    throw new TriggerSubscriptionNotCronError(params.subscriptionId, subscription.source);\n  }\n\n  // Deterministic per-occurrence identity: unique across (subscription, slot), stable\n  // across retries. Used for both the run idempotency key and the received-event ref.\n  const eventRef = `${subscription.id}:${params.scheduledSlot.toISOString()}`;\n  const historyBase = {\n    origin: 'cron' as const,\n    workspaceId: subscription.workspaceId,\n    provider: null,\n    source: subscription.source,\n    event: subscription.event,\n    deliveryId: null,\n    connectionId: null,\n    connectionName: null,\n    payload: null,\n    // The scheduled occurrence is the logical arrival time of the tick event.\n    receivedAt: params.scheduledSlot,\n    eventRef,\n  };\n\n  let run: WorkflowRun;\n  try {\n    run = await runWorkflow({\n      workspaceId: subscription.workspaceId,\n      projectId: subscription.projectId,\n      definitionId: subscription.workflowDefinitionId,\n      triggerPayload: {\n        provider: 'cron',\n        source: 'cron',\n        event: 'tick',\n        scheduleId: subscription.id,\n      },\n      inputs: readConfigInputs(subscription),\n      triggerIdempotencyKey: eventRef,\n    });\n  } catch (error) {\n    const failure = await beginTriggerHistory(historyBase);\n    await failure.dispatchErrored(subscription, toReason(error));\n    if (isPermanentRunWorkflowError(error)) {\n      recordFire('errored', params.scheduledSlot);\n      await failure.allErrored(1);\n      return {outcome: 'errored'};\n    }\n    // Transient: leave the event non-terminal and re-throw so the caller rolls back\n    // the advance and the schedule stays due for the next tick.\n    await failure.failed(1);\n    throw error;\n  }\n\n  const history = await beginTriggerHistory(historyBase);\n  await history.triggered(subscription, run);\n  recordFire('fired', params.scheduledSlot);\n  await history.routed(1);\n  return {outcome: 'fired', run};\n}\n\nfunction recordFire(outcome: 'fired' | 'errored', scheduledSlot: Date): void {\n  cronFiredCount.add(1, {outcome});\n  cronFireLag.record(Math.max(0, Date.now() - scheduledSlot.getTime()));\n}\n"],"names":["isPermanentRunWorkflowError","runWorkflow","getTriggerSubscriptionById","cronFiredCount","cronFireLag","readConfigInputs","TriggerSubscriptionNotCronError","TriggerSubscriptionNotFoundError","beginTriggerHistory","toReason","fireCronSubscription","params","subscription","subscriptionId","source","eventRef","id","scheduledSlot","toISOString","historyBase","origin","workspaceId","provider","event","deliveryId","connectionId","connectionName","payload","receivedAt","run","projectId","definitionId","workflowDefinitionId","triggerPayload","scheduleId","inputs","triggerIdempotencyKey","error","failure","dispatchErrored","recordFire","allErrored","outcome","failed","history","triggered","routed","add","record","Math","max","Date","now","getTime"],"mappings":"AAAA,SAAQA,2BAA2B,EAAEC,WAAW,QAAyB,yBAAyB;AAClG,SAAQC,0BAA0B,QAAO,uBAAuB;AAChE,SAAQC,cAAc,EAAEC,WAAW,QAAO,uBAAuB;AACjE,SAAQC,gBAAgB,QAAO,cAAc;AAC7C,SAAQC,+BAA+B,EAAEC,gCAAgC,QAAO,cAAc;AAC9F,SAAQC,mBAAmB,EAAEC,QAAQ,QAAO,8BAA8B;AAgB1E;;;;;;;;;CASC,GACD,OAAO,eAAeC,qBACpBC,MAAkC;IAElC,MAAMC,eAAe,MAAMV,2BAA2BS,OAAOE,cAAc;IAC3E,IAAI,CAACD,cAAc,MAAM,IAAIL,iCAAiCI,OAAOE,cAAc;IACnF,IAAID,aAAaE,MAAM,KAAK,QAAQ;QAClC,MAAM,IAAIR,gCAAgCK,OAAOE,cAAc,EAAED,aAAaE,MAAM;IACtF;IAEA,oFAAoF;IACpF,oFAAoF;IACpF,MAAMC,WAAW,GAAGH,aAAaI,EAAE,CAAC,CAAC,EAAEL,OAAOM,aAAa,CAACC,WAAW,IAAI;IAC3E,MAAMC,cAAc;QAClBC,QAAQ;QACRC,aAAaT,aAAaS,WAAW;QACrCC,UAAU;QACVR,QAAQF,aAAaE,MAAM;QAC3BS,OAAOX,aAAaW,KAAK;QACzBC,YAAY;QACZC,cAAc;QACdC,gBAAgB;QAChBC,SAAS;QACT,0EAA0E;QAC1EC,YAAYjB,OAAOM,aAAa;QAChCF;IACF;IAEA,IAAIc;IACJ,IAAI;QACFA,MAAM,MAAM5B,YAAY;YACtBoB,aAAaT,aAAaS,WAAW;YACrCS,WAAWlB,aAAakB,SAAS;YACjCC,cAAcnB,aAAaoB,oBAAoB;YAC/CC,gBAAgB;gBACdX,UAAU;gBACVR,QAAQ;gBACRS,OAAO;gBACPW,YAAYtB,aAAaI,EAAE;YAC7B;YACAmB,QAAQ9B,iBAAiBO;YACzBwB,uBAAuBrB;QACzB;IACF,EAAE,OAAOsB,OAAO;QACd,MAAMC,UAAU,MAAM9B,oBAAoBW;QAC1C,MAAMmB,QAAQC,eAAe,CAAC3B,cAAcH,SAAS4B;QACrD,IAAIrC,4BAA4BqC,QAAQ;YACtCG,WAAW,WAAW7B,OAAOM,aAAa;YAC1C,MAAMqB,QAAQG,UAAU,CAAC;YACzB,OAAO;gBAACC,SAAS;YAAS;QAC5B;QACA,gFAAgF;QAChF,4DAA4D;QAC5D,MAAMJ,QAAQK,MAAM,CAAC;QACrB,MAAMN;IACR;IAEA,MAAMO,UAAU,MAAMpC,oBAAoBW;IAC1C,MAAMyB,QAAQC,SAAS,CAACjC,cAAciB;IACtCW,WAAW,SAAS7B,OAAOM,aAAa;IACxC,MAAM2B,QAAQE,MAAM,CAAC;IACrB,OAAO;QAACJ,SAAS;QAASb;IAAG;AAC/B;AAEA,SAASW,WAAWE,OAA4B,EAAEzB,aAAmB;IACnEd,eAAe4C,GAAG,CAAC,GAAG;QAACL;IAAO;IAC9BtC,YAAY4C,MAAM,CAACC,KAAKC,GAAG,CAAC,GAAGC,KAAKC,GAAG,KAAKnC,cAAcoC,OAAO;AACnE"}

package/dist/core/fire-manual.d.ts

@@ -0,0 +1,9 @@
+import { type WorkflowRun } from '@shipfox/api-workflows';
+export interface FireManualSubscriptionParams {
+    subscriptionId: string;
+    callerWorkspaceId: string;
+    userId: string;
+    inputs?: Record<string, unknown> | undefined;
+}
+export declare function fireManualSubscription(params: FireManualSubscriptionParams): Promise<WorkflowRun>;
+//# sourceMappingURL=fire-manual.d.ts.map

package/dist/core/fire-manual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fire-manual.d.ts","sourceRoot":"","sources":["../../src/core/fire-manual.ts"],"names":[],"mappings":"AACA,OAAO,EAA2C,KAAK,WAAW,EAAC,MAAM,wBAAwB,CAAC;AAelG,MAAM,WAAW,4BAA4B;IAC3C,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CAC9C;AAED,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,4BAA4B,GACnC,OAAO,CAAC,WAAW,CAAC,CAkEtB"}

package/dist/core/fire-manual.js

@@ -0,0 +1,87 @@
+import { randomUUID } from 'node:crypto';
+import { isPermanentRunWorkflowError, runWorkflow } from '@shipfox/api-workflows';
+import { getTriggerSubscriptionById } from '#db/subscriptions.js';
+import { eventOutcomeCount, eventReceivedCount, subscriptionTriggeredCount } from '#metrics/instance.js';
+import { readConfigInputs } from './config.js';
+import { TriggerSubscriptionNotFoundError, TriggerSubscriptionNotManualError, TriggerWorkspaceMismatchError } from './errors.js';
+import { beginTriggerHistory, toReason } from './record-trigger-history.js';
+export async function fireManualSubscription(params) {
+    const subscription = await getTriggerSubscriptionById(params.subscriptionId);
+    if (!subscription) throw new TriggerSubscriptionNotFoundError(params.subscriptionId);
+    if (subscription.source !== 'manual') {
+        throw new TriggerSubscriptionNotManualError(params.subscriptionId, subscription.source);
+    }
+    // Defence in depth: unreachable from the HTTP route, but required for any direct caller.
+    if (subscription.workspaceId !== params.callerWorkspaceId) {
+        throw new TriggerWorkspaceMismatchError(params.subscriptionId, subscription.workspaceId, params.callerWorkspaceId);
+    }
+    // Manual fires have no upstream event id. Use the run id after success; failed
+    // attempts need a synthesized ref because there is no run to key on.
+    const historyBase = {
+        origin: 'manual',
+        workspaceId: subscription.workspaceId,
+        provider: null,
+        source: subscription.source,
+        event: subscription.event,
+        deliveryId: null,
+        connectionId: null,
+        connectionName: null,
+        payload: null,
+        receivedAt: new Date()
+    };
+    eventReceivedCount.add(1, {
+        provider: 'manual'
+    });
+    let run;
+    try {
+        run = await runWorkflow({
+            workspaceId: subscription.workspaceId,
+            projectId: subscription.projectId,
+            definitionId: subscription.workflowDefinitionId,
+            triggerPayload: {
+                provider: 'manual',
+                source: 'manual',
+                event: 'fire',
+                subscriptionId: subscription.id,
+                userId: params.userId
+            },
+            inputs: params.inputs ?? readConfigInputs(subscription)
+        });
+    } catch (error) {
+        const failure = await beginTriggerHistory({
+            ...historyBase,
+            eventRef: randomUUID()
+        });
+        await failure.dispatchErrored(subscription, toReason(error));
+        if (isPermanentRunWorkflowError(error)) {
+            eventOutcomeCount.add(1, {
+                provider: 'manual',
+                outcome: 'errored'
+            });
+            await failure.allErrored(1);
+        } else {
+            eventOutcomeCount.add(1, {
+                provider: 'manual',
+                outcome: 'failed'
+            });
+            await failure.failed(1);
+        }
+        throw error;
+    }
+    const history = await beginTriggerHistory({
+        ...historyBase,
+        eventRef: run.id
+    });
+    await history.triggered(subscription, run);
+    subscriptionTriggeredCount.add(1, {
+        provider: 'manual'
+    });
+    eventOutcomeCount.add(1, {
+        provider: 'manual',
+        outcome: 'routed'
+    });
+    await history.routed(1);
+    return run;
+}
+
+//# sourceMappingURL=fire-manual.js.map

package/dist/core/fire-manual.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/fire-manual.ts"],"sourcesContent":["import {randomUUID} from 'node:crypto';\nimport {isPermanentRunWorkflowError, runWorkflow, type WorkflowRun} from '@shipfox/api-workflows';\nimport {getTriggerSubscriptionById} from '#db/subscriptions.js';\nimport {\n  eventOutcomeCount,\n  eventReceivedCount,\n  subscriptionTriggeredCount,\n} from '#metrics/instance.js';\nimport {readConfigInputs} from './config.js';\nimport {\n  TriggerSubscriptionNotFoundError,\n  TriggerSubscriptionNotManualError,\n  TriggerWorkspaceMismatchError,\n} from './errors.js';\nimport {beginTriggerHistory, toReason} from './record-trigger-history.js';\n\nexport interface FireManualSubscriptionParams {\n  subscriptionId: string;\n  callerWorkspaceId: string;\n  userId: string;\n  inputs?: Record<string, unknown> | undefined;\n}\n\nexport async function fireManualSubscription(\n  params: FireManualSubscriptionParams,\n): Promise<WorkflowRun> {\n  const subscription = await getTriggerSubscriptionById(params.subscriptionId);\n  if (!subscription) throw new TriggerSubscriptionNotFoundError(params.subscriptionId);\n  if (subscription.source !== 'manual') {\n    throw new TriggerSubscriptionNotManualError(params.subscriptionId, subscription.source);\n  }\n  // Defence in depth: unreachable from the HTTP route, but required for any direct caller.\n  if (subscription.workspaceId !== params.callerWorkspaceId) {\n    throw new TriggerWorkspaceMismatchError(\n      params.subscriptionId,\n      subscription.workspaceId,\n      params.callerWorkspaceId,\n    );\n  }\n\n  // Manual fires have no upstream event id. Use the run id after success; failed\n  // attempts need a synthesized ref because there is no run to key on.\n  const historyBase = {\n    origin: 'manual' as const,\n    workspaceId: subscription.workspaceId,\n    provider: null,\n    source: subscription.source,\n    event: subscription.event,\n    deliveryId: null,\n    connectionId: null,\n    connectionName: null,\n    payload: null,\n    receivedAt: new Date(),\n  };\n\n  eventReceivedCount.add(1, {provider: 'manual'});\n\n  let run: WorkflowRun;\n  try {\n    run = await runWorkflow({\n      workspaceId: subscription.workspaceId,\n      projectId: subscription.projectId,\n      definitionId: subscription.workflowDefinitionId,\n      triggerPayload: {\n        provider: 'manual',\n        source: 'manual',\n        event: 'fire',\n        subscriptionId: subscription.id,\n        userId: params.userId,\n      },\n      inputs: params.inputs ?? readConfigInputs(subscription),\n    });\n  } catch (error) {\n    const failure = await beginTriggerHistory({...historyBase, eventRef: randomUUID()});\n    await failure.dispatchErrored(subscription, toReason(error));\n    if (isPermanentRunWorkflowError(error)) {\n      eventOutcomeCount.add(1, {provider: 'manual', outcome: 'errored'});\n      await failure.allErrored(1);\n    } else {\n      eventOutcomeCount.add(1, {provider: 'manual', outcome: 'failed'});\n      await failure.failed(1);\n    }\n    throw error;\n  }\n\n  const history = await beginTriggerHistory({...historyBase, eventRef: run.id});\n  await history.triggered(subscription, run);\n  subscriptionTriggeredCount.add(1, {provider: 'manual'});\n  eventOutcomeCount.add(1, {provider: 'manual', outcome: 'routed'});\n  await history.routed(1);\n  return run;\n}\n"],"names":["randomUUID","isPermanentRunWorkflowError","runWorkflow","getTriggerSubscriptionById","eventOutcomeCount","eventReceivedCount","subscriptionTriggeredCount","readConfigInputs","TriggerSubscriptionNotFoundError","TriggerSubscriptionNotManualError","TriggerWorkspaceMismatchError","beginTriggerHistory","toReason","fireManualSubscription","params","subscription","subscriptionId","source","workspaceId","callerWorkspaceId","historyBase","origin","provider","event","deliveryId","connectionId","connectionName","payload","receivedAt","Date","add","run","projectId","definitionId","workflowDefinitionId","triggerPayload","id","userId","inputs","error","failure","eventRef","dispatchErrored","outcome","allErrored","failed","history","triggered","routed"],"mappings":"AAAA,SAAQA,UAAU,QAAO,cAAc;AACvC,SAAQC,2BAA2B,EAAEC,WAAW,QAAyB,yBAAyB;AAClG,SAAQC,0BAA0B,QAAO,uBAAuB;AAChE,SACEC,iBAAiB,EACjBC,kBAAkB,EAClBC,0BAA0B,QACrB,uBAAuB;AAC9B,SAAQC,gBAAgB,QAAO,cAAc;AAC7C,SACEC,gCAAgC,EAChCC,iCAAiC,EACjCC,6BAA6B,QACxB,cAAc;AACrB,SAAQC,mBAAmB,EAAEC,QAAQ,QAAO,8BAA8B;AAS1E,OAAO,eAAeC,uBACpBC,MAAoC;IAEpC,MAAMC,eAAe,MAAMZ,2BAA2BW,OAAOE,cAAc;IAC3E,IAAI,CAACD,cAAc,MAAM,IAAIP,iCAAiCM,OAAOE,cAAc;IACnF,IAAID,aAAaE,MAAM,KAAK,UAAU;QACpC,MAAM,IAAIR,kCAAkCK,OAAOE,cAAc,EAAED,aAAaE,MAAM;IACxF;IACA,yFAAyF;IACzF,IAAIF,aAAaG,WAAW,KAAKJ,OAAOK,iBAAiB,EAAE;QACzD,MAAM,IAAIT,8BACRI,OAAOE,cAAc,EACrBD,aAAaG,WAAW,EACxBJ,OAAOK,iBAAiB;IAE5B;IAEA,+EAA+E;IAC/E,qEAAqE;IACrE,MAAMC,cAAc;QAClBC,QAAQ;QACRH,aAAaH,aAAaG,WAAW;QACrCI,UAAU;QACVL,QAAQF,aAAaE,MAAM;QAC3BM,OAAOR,aAAaQ,KAAK;QACzBC,YAAY;QACZC,cAAc;QACdC,gBAAgB;QAChBC,SAAS;QACTC,YAAY,IAAIC;IAClB;IAEAxB,mBAAmByB,GAAG,CAAC,GAAG;QAACR,UAAU;IAAQ;IAE7C,IAAIS;IACJ,IAAI;QACFA,MAAM,MAAM7B,YAAY;YACtBgB,aAAaH,aAAaG,WAAW;YACrCc,WAAWjB,aAAaiB,SAAS;YACjCC,cAAclB,aAAamB,oBAAoB;YAC/CC,gBAAgB;gBACdb,UAAU;gBACVL,QAAQ;gBACRM,OAAO;gBACPP,gBAAgBD,aAAaqB,EAAE;gBAC/BC,QAAQvB,OAAOuB,MAAM;YACvB;YACAC,QAAQxB,OAAOwB,MAAM,IAAI/B,iBAAiBQ;QAC5C;IACF,EAAE,OAAOwB,OAAO;QACd,MAAMC,UAAU,MAAM7B,oBAAoB;YAAC,GAAGS,WAAW;YAAEqB,UAAUzC;QAAY;QACjF,MAAMwC,QAAQE,eAAe,CAAC3B,cAAcH,SAAS2B;QACrD,IAAItC,4BAA4BsC,QAAQ;YACtCnC,kBAAkB0B,GAAG,CAAC,GAAG;gBAACR,UAAU;gBAAUqB,SAAS;YAAS;YAChE,MAAMH,QAAQI,UAAU,CAAC;QAC3B,OAAO;YACLxC,kBAAkB0B,GAAG,CAAC,GAAG;gBAACR,UAAU;gBAAUqB,SAAS;YAAQ;YAC/D,MAAMH,QAAQK,MAAM,CAAC;QACvB;QACA,MAAMN;IACR;IAEA,MAAMO,UAAU,MAAMnC,oBAAoB;QAAC,GAAGS,WAAW;QAAEqB,UAAUV,IAAIK,EAAE;IAAA;IAC3E,MAAMU,QAAQC,SAAS,CAAChC,cAAcgB;IACtCzB,2BAA2BwB,GAAG,CAAC,GAAG;QAACR,UAAU;IAAQ;IACrDlB,kBAAkB0B,GAAG,CAAC,GAAG;QAACR,UAAU;QAAUqB,SAAS;IAAQ;IAC/D,MAAMG,QAAQE,MAAM,CAAC;IACrB,OAAOjB;AACT"}

package/dist/core/index.d.ts

@@ -0,0 +1,11 @@
+export { type ComputeNextFireAtParams, computeNextFireAt, } from './compute-next-fire-at.js';
+export { readConfigInputs } from './config.js';
+export { type DispatchIntegrationEventParams, dispatchIntegrationEvent, } from './dispatch-integration-event.js';
+export { type CronDrainSummary, type DrainDueCronSchedulesParams, drainDueCronSchedules, } from './drain-cron-schedules.js';
+export type { CronSchedule } from './entities/cron-schedule.js';
+export type { TriggerSubscription } from './entities/subscription.js';
+export { ManualTriggerNotFoundError, TriggerSubscriptionNotCronError, TriggerSubscriptionNotFoundError, TriggerSubscriptionNotManualError, TriggerWorkspaceMismatchError, } from './errors.js';
+export { type FireCronSubscriptionParams, type FireCronSubscriptionResult, fireCronSubscription, } from './fire-cron.js';
+export { type FireManualSubscriptionParams, fireManualSubscription } from './fire-manual.js';
+export { type RouteEventToJobListenersParams, type RouteEventToJobListenersResult, routeEventToJobListeners, } from './route-event-to-job-listeners.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAC5B,iBAAiB,GAClB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAC,gBAAgB,EAAC,MAAM,aAAa,CAAC;AAC7C,OAAO,EACL,KAAK,8BAA8B,EACnC,wBAAwB,GACzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,2BAA2B,EAChC,qBAAqB,GACtB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EAAC,YAAY,EAAC,MAAM,6BAA6B,CAAC;AAC9D,YAAY,EAAC,mBAAmB,EAAC,MAAM,4BAA4B,CAAC;AACpE,OAAO,EACL,0BAA0B,EAC1B,+BAA+B,EAC/B,gCAAgC,EAChC,iCAAiC,EACjC,6BAA6B,GAC9B,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAC/B,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAC,KAAK,4BAA4B,EAAE,sBAAsB,EAAC,MAAM,kBAAkB,CAAC;AAC3F,OAAO,EACL,KAAK,8BAA8B,EACnC,KAAK,8BAA8B,EACnC,wBAAwB,GACzB,MAAM,mCAAmC,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,10 @@
+export { computeNextFireAt } from './compute-next-fire-at.js';
+export { readConfigInputs } from './config.js';
+export { dispatchIntegrationEvent } from './dispatch-integration-event.js';
+export { drainDueCronSchedules } from './drain-cron-schedules.js';
+export { ManualTriggerNotFoundError, TriggerSubscriptionNotCronError, TriggerSubscriptionNotFoundError, TriggerSubscriptionNotManualError, TriggerWorkspaceMismatchError } from './errors.js';
+export { fireCronSubscription } from './fire-cron.js';
+export { fireManualSubscription } from './fire-manual.js';
+export { routeEventToJobListeners } from './route-event-to-job-listeners.js';
+
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/index.ts"],"sourcesContent":["export {\n  type ComputeNextFireAtParams,\n  computeNextFireAt,\n} from './compute-next-fire-at.js';\nexport {readConfigInputs} from './config.js';\nexport {\n  type DispatchIntegrationEventParams,\n  dispatchIntegrationEvent,\n} from './dispatch-integration-event.js';\nexport {\n  type CronDrainSummary,\n  type DrainDueCronSchedulesParams,\n  drainDueCronSchedules,\n} from './drain-cron-schedules.js';\nexport type {CronSchedule} from './entities/cron-schedule.js';\nexport type {TriggerSubscription} from './entities/subscription.js';\nexport {\n  ManualTriggerNotFoundError,\n  TriggerSubscriptionNotCronError,\n  TriggerSubscriptionNotFoundError,\n  TriggerSubscriptionNotManualError,\n  TriggerWorkspaceMismatchError,\n} from './errors.js';\nexport {\n  type FireCronSubscriptionParams,\n  type FireCronSubscriptionResult,\n  fireCronSubscription,\n} from './fire-cron.js';\nexport {type FireManualSubscriptionParams, fireManualSubscription} from './fire-manual.js';\nexport {\n  type RouteEventToJobListenersParams,\n  type RouteEventToJobListenersResult,\n  routeEventToJobListeners,\n} from './route-event-to-job-listeners.js';\n"],"names":["computeNextFireAt","readConfigInputs","dispatchIntegrationEvent","drainDueCronSchedules","ManualTriggerNotFoundError","TriggerSubscriptionNotCronError","TriggerSubscriptionNotFoundError","TriggerSubscriptionNotManualError","TriggerWorkspaceMismatchError","fireCronSubscription","fireManualSubscription","routeEventToJobListeners"],"mappings":"AAAA,SAEEA,iBAAiB,QACZ,4BAA4B;AACnC,SAAQC,gBAAgB,QAAO,cAAc;AAC7C,SAEEC,wBAAwB,QACnB,kCAAkC;AACzC,SAGEC,qBAAqB,QAChB,4BAA4B;AAGnC,SACEC,0BAA0B,EAC1BC,+BAA+B,EAC/BC,gCAAgC,EAChCC,iCAAiC,EACjCC,6BAA6B,QACxB,cAAc;AACrB,SAGEC,oBAAoB,QACf,iBAAiB;AACxB,SAA2CC,sBAAsB,QAAO,mBAAmB;AAC3F,SAGEC,wBAAwB,QACnB,oCAAoC"}

package/dist/core/record-trigger-history.d.ts

@@ -0,0 +1,35 @@
+import type { JobListenerSubscription } from '#core/entities/job-listener-subscription.js';
+import type { TriggerEventOrigin } from '#core/entities/received-event.js';
+import type { TriggerSubscription } from '#core/entities/subscription.js';
+export declare function toReason(error: unknown): string;
+export interface TriggerRun {
+    id: string;
+    name: string;
+}
+export interface TriggerHistoryRecorder {
+    triggered(subscription: TriggerSubscription, run: TriggerRun): Promise<void>;
+    filterErrored(subscription: TriggerSubscription, reason: string): Promise<void>;
+    dispatchErrored(subscription: TriggerSubscription, reason: string): Promise<void>;
+    listenerTriggered(subscription: JobListenerSubscription): Promise<void>;
+    listenerFilterErrored(subscription: JobListenerSubscription, reason: string): Promise<void>;
+    listenerDispatchErrored(subscription: JobListenerSubscription, reason: string): Promise<void>;
+    discarded(): Promise<void>;
+    routed(matchedCount: number): Promise<void>;
+    failed(matchedCount: number): Promise<void>;
+    allErrored(matchedCount: number): Promise<void>;
+}
+export interface BeginTriggerHistoryParams {
+    eventRef: string;
+    origin: TriggerEventOrigin;
+    workspaceId: string;
+    provider: string | null;
+    source: string;
+    event: string;
+    deliveryId: string | null;
+    connectionId: string | null;
+    connectionName: string | null;
+    payload: Record<string, unknown> | null;
+    receivedAt: Date;
+}
+export declare function beginTriggerHistory(params: BeginTriggerHistoryParams): Promise<TriggerHistoryRecorder>;
+//# sourceMappingURL=record-trigger-history.d.ts.map

package/dist/core/record-trigger-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-trigger-history.d.ts","sourceRoot":"","sources":["../../src/core/record-trigger-history.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,6CAA6C,CAAC;AACzF,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AAmBxE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAQ/C;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,YAAY,EAAE,mBAAmB,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7E,aAAa,CAAC,YAAY,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,eAAe,CAAC,YAAY,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClF,iBAAiB,CAAC,YAAY,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxE,qBAAqB,CAAC,YAAY,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5F,uBAAuB,CAAC,YAAY,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9F,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,UAAU,EAAE,IAAI,CAAC;CAClB;AAID,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,sBAAsB,CAAC,CA2DjC"}

package/dist/core/record-trigger-history.js

@@ -0,0 +1,75 @@
+import { logger } from '@shipfox/node-opentelemetry';
+import { insertReceivedEvent, markReceivedEventDiscarded, markReceivedEventErrored, markReceivedEventFailed, markReceivedEventRouted, upsertDispatchErrorDecision, upsertFilterErrorDecision, upsertListenerDispatchErrorDecision, upsertListenerFilterErrorDecision, upsertListenerTriggeredDecision, upsertTriggeredDecision } from '#db/event-history.js';
+const MAX_REASON_LENGTH = 2000;
+// A bounded, deterministic reason string safe to persist: error messages can be
+// long or carry untrusted data, so cap the length and never serialize the object.
+export function toReason(error) {
+    let message;
+    try {
+        message = error instanceof Error ? error.message : String(error);
+    } catch  {
+        message = '[unprintable thrown value]';
+    }
+    return message.slice(0, MAX_REASON_LENGTH);
+}
+// History writes are best-effort and log stable ids only, never payloads or tokens.
+// If the parent insert fails there is no row to attach to, so later calls no-op.
+export async function beginTriggerHistory(params) {
+    const receivedEventId = await safe(params.eventRef, 'insert-received-event', ()=>insertReceivedEvent(params));
+    const record = async (label, write, subscriptionId)=>{
+        if (receivedEventId === undefined) return;
+        await safe(params.eventRef, label, ()=>write(receivedEventId), subscriptionId);
+    };
+    return {
+        triggered: (subscription, run)=>record('triggered-decision', (id)=>upsertTriggeredDecision({
+                    receivedEventId: id,
+                    subscription,
+                    run
+                }), subscription.id),
+        filterErrored: (subscription, reason)=>record('filter-error-decision', (id)=>upsertFilterErrorDecision({
+                    receivedEventId: id,
+                    subscription,
+                    reason
+                }), subscription.id),
+        dispatchErrored: (subscription, reason)=>record('dispatch-error-decision', (id)=>upsertDispatchErrorDecision({
+                    receivedEventId: id,
+                    subscription,
+                    reason
+                }), subscription.id),
+        listenerTriggered: (subscription)=>record('listener-triggered-decision', (id)=>upsertListenerTriggeredDecision({
+                    receivedEventId: id,
+                    subscription
+                }), subscription.id),
+        listenerFilterErrored: (subscription, reason)=>record('listener-filter-error-decision', (id)=>upsertListenerFilterErrorDecision({
+                    receivedEventId: id,
+                    subscription,
+                    reason
+                }), subscription.id),
+        listenerDispatchErrored: (subscription, reason)=>record('listener-dispatch-error-decision', (id)=>upsertListenerDispatchErrorDecision({
+                    receivedEventId: id,
+                    subscription,
+                    reason
+                }), subscription.id),
+        discarded: ()=>record('discard-event', (id)=>markReceivedEventDiscarded(id)),
+        routed: (matchedCount)=>record('route-event', (id)=>markReceivedEventRouted(id, matchedCount)),
+        failed: (matchedCount)=>record('fail-event', (id)=>markReceivedEventFailed(id, matchedCount)),
+        allErrored: (matchedCount)=>record('all-errored-event', (id)=>markReceivedEventErrored(id, matchedCount))
+    };
+}
+async function safe(eventRef, label, fn, subscriptionId) {
+    try {
+        return await fn();
+    } catch (error) {
+        logger().warn({
+            err: error,
+            label,
+            eventRef,
+            ...subscriptionId ? {
+                subscriptionId
+            } : {}
+        }, 'trigger history write failed; ignored (best-effort)');
+        return undefined;
+    }
+}
+
+//# sourceMappingURL=record-trigger-history.js.map

package/dist/core/record-trigger-history.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/record-trigger-history.ts"],"sourcesContent":["import {logger} from '@shipfox/node-opentelemetry';\nimport type {JobListenerSubscription} from '#core/entities/job-listener-subscription.js';\nimport type {TriggerEventOrigin} from '#core/entities/received-event.js';\nimport type {TriggerSubscription} from '#core/entities/subscription.js';\nimport {\n  insertReceivedEvent,\n  markReceivedEventDiscarded,\n  markReceivedEventErrored,\n  markReceivedEventFailed,\n  markReceivedEventRouted,\n  upsertDispatchErrorDecision,\n  upsertFilterErrorDecision,\n  upsertListenerDispatchErrorDecision,\n  upsertListenerFilterErrorDecision,\n  upsertListenerTriggeredDecision,\n  upsertTriggeredDecision,\n} from '#db/event-history.js';\n\nconst MAX_REASON_LENGTH = 2000;\n\n// A bounded, deterministic reason string safe to persist: error messages can be\n// long or carry untrusted data, so cap the length and never serialize the object.\nexport function toReason(error: unknown): string {\n  let message: string;\n  try {\n    message = error instanceof Error ? error.message : String(error);\n  } catch {\n    message = '[unprintable thrown value]';\n  }\n  return message.slice(0, MAX_REASON_LENGTH);\n}\n\nexport interface TriggerRun {\n  id: string;\n  name: string;\n}\n\nexport interface TriggerHistoryRecorder {\n  triggered(subscription: TriggerSubscription, run: TriggerRun): Promise<void>;\n  filterErrored(subscription: TriggerSubscription, reason: string): Promise<void>;\n  dispatchErrored(subscription: TriggerSubscription, reason: string): Promise<void>;\n  listenerTriggered(subscription: JobListenerSubscription): Promise<void>;\n  listenerFilterErrored(subscription: JobListenerSubscription, reason: string): Promise<void>;\n  listenerDispatchErrored(subscription: JobListenerSubscription, reason: string): Promise<void>;\n  discarded(): Promise<void>;\n  routed(matchedCount: number): Promise<void>;\n  failed(matchedCount: number): Promise<void>;\n  allErrored(matchedCount: number): Promise<void>;\n}\n\nexport interface BeginTriggerHistoryParams {\n  eventRef: string;\n  origin: TriggerEventOrigin;\n  workspaceId: string;\n  provider: string | null;\n  source: string;\n  event: string;\n  deliveryId: string | null;\n  connectionId: string | null;\n  connectionName: string | null;\n  payload: Record<string, unknown> | null;\n  receivedAt: Date;\n}\n\n// History writes are best-effort and log stable ids only, never payloads or tokens.\n// If the parent insert fails there is no row to attach to, so later calls no-op.\nexport async function beginTriggerHistory(\n  params: BeginTriggerHistoryParams,\n): Promise<TriggerHistoryRecorder> {\n  const receivedEventId = await safe(params.eventRef, 'insert-received-event', () =>\n    insertReceivedEvent(params),\n  );\n\n  const record = async (\n    label: string,\n    write: (receivedEventId: string) => Promise<unknown>,\n    subscriptionId?: string,\n  ): Promise<void> => {\n    if (receivedEventId === undefined) return;\n    await safe(params.eventRef, label, () => write(receivedEventId), subscriptionId);\n  };\n\n  return {\n    triggered: (subscription, run) =>\n      record(\n        'triggered-decision',\n        (id) => upsertTriggeredDecision({receivedEventId: id, subscription, run}),\n        subscription.id,\n      ),\n    filterErrored: (subscription, reason) =>\n      record(\n        'filter-error-decision',\n        (id) => upsertFilterErrorDecision({receivedEventId: id, subscription, reason}),\n        subscription.id,\n      ),\n    dispatchErrored: (subscription, reason) =>\n      record(\n        'dispatch-error-decision',\n        (id) => upsertDispatchErrorDecision({receivedEventId: id, subscription, reason}),\n        subscription.id,\n      ),\n    listenerTriggered: (subscription) =>\n      record(\n        'listener-triggered-decision',\n        (id) => upsertListenerTriggeredDecision({receivedEventId: id, subscription}),\n        subscription.id,\n      ),\n    listenerFilterErrored: (subscription, reason) =>\n      record(\n        'listener-filter-error-decision',\n        (id) => upsertListenerFilterErrorDecision({receivedEventId: id, subscription, reason}),\n        subscription.id,\n      ),\n    listenerDispatchErrored: (subscription, reason) =>\n      record(\n        'listener-dispatch-error-decision',\n        (id) => upsertListenerDispatchErrorDecision({receivedEventId: id, subscription, reason}),\n        subscription.id,\n      ),\n    discarded: () => record('discard-event', (id) => markReceivedEventDiscarded(id)),\n    routed: (matchedCount) =>\n      record('route-event', (id) => markReceivedEventRouted(id, matchedCount)),\n    failed: (matchedCount) =>\n      record('fail-event', (id) => markReceivedEventFailed(id, matchedCount)),\n    allErrored: (matchedCount) =>\n      record('all-errored-event', (id) => markReceivedEventErrored(id, matchedCount)),\n  };\n}\n\nasync function safe<T>(\n  eventRef: string,\n  label: string,\n  fn: () => Promise<T>,\n  subscriptionId?: string,\n): Promise<T | undefined> {\n  try {\n    return await fn();\n  } catch (error) {\n    logger().warn(\n      {err: error, label, eventRef, ...(subscriptionId ? {subscriptionId} : {})},\n      'trigger history write failed; ignored (best-effort)',\n    );\n    return undefined;\n  }\n}\n"],"names":["logger","insertReceivedEvent","markReceivedEventDiscarded","markReceivedEventErrored","markReceivedEventFailed","markReceivedEventRouted","upsertDispatchErrorDecision","upsertFilterErrorDecision","upsertListenerDispatchErrorDecision","upsertListenerFilterErrorDecision","upsertListenerTriggeredDecision","upsertTriggeredDecision","MAX_REASON_LENGTH","toReason","error","message","Error","String","slice","beginTriggerHistory","params","receivedEventId","safe","eventRef","record","label","write","subscriptionId","undefined","triggered","subscription","run","id","filterErrored","reason","dispatchErrored","listenerTriggered","listenerFilterErrored","listenerDispatchErrored","discarded","routed","matchedCount","failed","allErrored","fn","warn","err"],"mappings":"AAAA,SAAQA,MAAM,QAAO,8BAA8B;AAInD,SACEC,mBAAmB,EACnBC,0BAA0B,EAC1BC,wBAAwB,EACxBC,uBAAuB,EACvBC,uBAAuB,EACvBC,2BAA2B,EAC3BC,yBAAyB,EACzBC,mCAAmC,EACnCC,iCAAiC,EACjCC,+BAA+B,EAC/BC,uBAAuB,QAClB,uBAAuB;AAE9B,MAAMC,oBAAoB;AAE1B,gFAAgF;AAChF,kFAAkF;AAClF,OAAO,SAASC,SAASC,KAAc;IACrC,IAAIC;IACJ,IAAI;QACFA,UAAUD,iBAAiBE,QAAQF,MAAMC,OAAO,GAAGE,OAAOH;IAC5D,EAAE,OAAM;QACNC,UAAU;IACZ;IACA,OAAOA,QAAQG,KAAK,CAAC,GAAGN;AAC1B;AAkCA,oFAAoF;AACpF,iFAAiF;AACjF,OAAO,eAAeO,oBACpBC,MAAiC;IAEjC,MAAMC,kBAAkB,MAAMC,KAAKF,OAAOG,QAAQ,EAAE,yBAAyB,IAC3EtB,oBAAoBmB;IAGtB,MAAMI,SAAS,OACbC,OACAC,OACAC;QAEA,IAAIN,oBAAoBO,WAAW;QACnC,MAAMN,KAAKF,OAAOG,QAAQ,EAAEE,OAAO,IAAMC,MAAML,kBAAkBM;IACnE;IAEA,OAAO;QACLE,WAAW,CAACC,cAAcC,MACxBP,OACE,sBACA,CAACQ,KAAOrB,wBAAwB;oBAACU,iBAAiBW;oBAAIF;oBAAcC;gBAAG,IACvED,aAAaE,EAAE;QAEnBC,eAAe,CAACH,cAAcI,SAC5BV,OACE,yBACA,CAACQ,KAAOzB,0BAA0B;oBAACc,iBAAiBW;oBAAIF;oBAAcI;gBAAM,IAC5EJ,aAAaE,EAAE;QAEnBG,iBAAiB,CAACL,cAAcI,SAC9BV,OACE,2BACA,CAACQ,KAAO1B,4BAA4B;oBAACe,iBAAiBW;oBAAIF;oBAAcI;gBAAM,IAC9EJ,aAAaE,EAAE;QAEnBI,mBAAmB,CAACN,eAClBN,OACE,+BACA,CAACQ,KAAOtB,gCAAgC;oBAACW,iBAAiBW;oBAAIF;gBAAY,IAC1EA,aAAaE,EAAE;QAEnBK,uBAAuB,CAACP,cAAcI,SACpCV,OACE,kCACA,CAACQ,KAAOvB,kCAAkC;oBAACY,iBAAiBW;oBAAIF;oBAAcI;gBAAM,IACpFJ,aAAaE,EAAE;QAEnBM,yBAAyB,CAACR,cAAcI,SACtCV,OACE,oCACA,CAACQ,KAAOxB,oCAAoC;oBAACa,iBAAiBW;oBAAIF;oBAAcI;gBAAM,IACtFJ,aAAaE,EAAE;QAEnBO,WAAW,IAAMf,OAAO,iBAAiB,CAACQ,KAAO9B,2BAA2B8B;QAC5EQ,QAAQ,CAACC,eACPjB,OAAO,eAAe,CAACQ,KAAO3B,wBAAwB2B,IAAIS;QAC5DC,QAAQ,CAACD,eACPjB,OAAO,cAAc,CAACQ,KAAO5B,wBAAwB4B,IAAIS;QAC3DE,YAAY,CAACF,eACXjB,OAAO,qBAAqB,CAACQ,KAAO7B,yBAAyB6B,IAAIS;IACrE;AACF;AAEA,eAAenB,KACbC,QAAgB,EAChBE,KAAa,EACbmB,EAAoB,EACpBjB,cAAuB;IAEvB,IAAI;QACF,OAAO,MAAMiB;IACf,EAAE,OAAO9B,OAAO;QACdd,SAAS6C,IAAI,CACX;YAACC,KAAKhC;YAAOW;YAAOF;YAAU,GAAII,iBAAiB;gBAACA;YAAc,IAAI,CAAC,CAAC;QAAC,GACzE;QAEF,OAAOC;IACT;AACF"}

package/dist/core/route-event-to-job-listeners.d.ts

@@ -0,0 +1,31 @@
+import { type TriggerHistoryRecorder } from './record-trigger-history.js';
+export interface RouteEventToJobListenersParams {
+    history: TriggerHistoryRecorder;
+    eventRef: string;
+    workspaceId: string;
+    provider: string;
+    source: string;
+    event: string;
+    deliveryId: string;
+    payload: unknown;
+    receivedAt: Date;
+}
+export interface RouteEventToJobListenersResult {
+    /**
+     * Listener outcomes that should contribute to received_event.matched_count:
+     * filter errors, accepted deliveries, and dispatch errors. Stale skipped jobs
+     * are intentionally excluded because they did not produce an auditable decision.
+     */
+    engagedCount: number;
+    /**
+     * Jobs with an effective matcher after source/event/filter checks, including
+     * stale skipped jobs.
+     */
+    matchedJobCount: number;
+    acceptedJobCount: number;
+    deliveredCount: number;
+    transientErrored: boolean;
+    transientError: unknown;
+}
+export declare function routeEventToJobListeners(params: RouteEventToJobListenersParams): Promise<RouteEventToJobListenersResult>;
+//# sourceMappingURL=route-event-to-job-listeners.d.ts.map

package/dist/core/route-event-to-job-listeners.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-event-to-job-listeners.d.ts","sourceRoot":"","sources":["../../src/core/route-event-to-job-listeners.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,KAAK,sBAAsB,EAAW,MAAM,6BAA6B,CAAC;AAElF,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,sBAAsB,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,8BAA8B;IAC7C;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,8BAA8B,GACrC,OAAO,CAAC,8BAA8B,CAAC,CAmEzC"}