@shipfox/api-triggers 2.0.0

package/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1783263628394,
+      "tag": "0000_initial",
+      "breakpoints": true
+    }
+  ]
+}

package/drizzle.config.ts

@@ -0,0 +1,14 @@
+import {defineConfig} from 'drizzle-kit';
+
+export default defineConfig({
+  schema: [
+    './src/db/schema/cron-schedules.ts',
+    './src/db/schema/decisions.ts',
+    './src/db/schema/job-listener-subscriptions.ts',
+    './src/db/schema/outbox.ts',
+    './src/db/schema/received-events.ts',
+    './src/db/schema/subscriptions.ts',
+  ],
+  out: './drizzle',
+  dialect: 'postgresql',
+});

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@shipfox/api-triggers",
+  "license": "MIT",
+  "version": "2.0.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
+    "directory": "libs/api/triggers"
+  },
+  "private": false,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "imports": {
+    "#test/*": "./test/*",
+    "#*": {
+      "workspace-source": "./src/*",
+      "development": "./src/*",
+      "default": "./dist/*"
+    }
+  },
+  "exports": {
+    ".": {
+      "development": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "dependencies": {
+    "@temporalio/workflow": "^1.16.1",
+    "cron-parser": "^5.6.1",
+    "drizzle-orm": "^0.45.2",
+    "zod": "^4.4.3",
+    "@shipfox/api-definitions-dto": "2.0.0",
+    "@shipfox/api-projects": "2.0.0",
+    "@shipfox/api-triggers-dto": "2.0.0",
+    "@shipfox/api-integration-core-dto": "2.0.0",
+    "@shipfox/api-workflows-dto": "2.0.0",
+    "@shipfox/api-workflows": "2.0.0",
+    "@shipfox/config": "1.2.1",
+    "@shipfox/api-auth-context": "2.0.0",
+    "@shipfox/node-drizzle": "0.2.1",
+    "@shipfox/node-opentelemetry": "0.5.0",
+    "@shipfox/node-fastify": "0.2.1",
+    "@shipfox/node-outbox": "0.2.1",
+    "@shipfox/node-module": "0.2.0",
+    "@shipfox/node-postgres": "0.4.1",
+    "@shipfox/node-temporal": "0.2.0",
+    "@shipfox/workflow-document": "2.0.1",
+    "@shipfox/expression": "1.1.1"
+  },
+  "devDependencies": {
+    "@temporalio/activity": "^1.16.1",
+    "@temporalio/client": "^1.16.1",
+    "@temporalio/common": "^1.16.1",
+    "@temporalio/testing": "^1.16.1",
+    "@temporalio/worker": "^1.16.1",
+    "@types/pg": "^8.15.5",
+    "drizzle-kit": "^0.31.10",
+    "fastify": "^5.3.3",
+    "fastify-type-provider-zod": "^6.0.0",
+    "fishery": "^2.2.2",
+    "@shipfox/swc": "1.2.5",
+    "@shipfox/ts-config": "1.3.8",
+    "@shipfox/typescript": "1.1.6",
+    "@shipfox/biome": "1.8.1",
+    "@shipfox/vitest": "1.2.2"
+  },
+  "scripts": {
+    "build": "shipfox-swc",
+    "check": "shipfox-biome-check",
+    "check:fix": "shipfox-biome-check --write",
+    "test": "shipfox-vitest-run",
+    "test:watch": "shipfox-vitest-watch",
+    "type": "shipfox-tsc-check",
+    "type:emit": "shipfox-tsc-emit"
+  }
+}

package/src/config.test.ts

@@ -0,0 +1,33 @@
+import {assertCronConfigWithinBounds, assertRetentionDaysWithinBounds} from './config.js';
+
+const RETENTION_ERROR = /TRIGGER_EVENT_RETENTION_DAYS/;
+const CRON_JITTER_ERROR = /TRIGGER_CRON_JITTER_WINDOW_SECONDS/;
+
+describe('assertRetentionDaysWithinBounds', () => {
+  test.each([1, 30, 365])('accepts a finite window of at least 1 day (%p)', (days) => {
+    expect(() => assertRetentionDaysWithinBounds(days)).not.toThrow();
+  });
+
+  test.each([
+    0,
+    -1,
+    Number.NaN,
+    Number.POSITIVE_INFINITY,
+  ])('rejects a window below 1 day or non-finite (%p)', (days) => {
+    expect(() => assertRetentionDaysWithinBounds(days)).toThrow(RETENTION_ERROR);
+  });
+});
+
+describe('assertCronConfigWithinBounds', () => {
+  test.each([0, 1, 60, 600])('accepts a finite non-negative jitter window (%p)', (seconds) => {
+    expect(() => assertCronConfigWithinBounds(seconds)).not.toThrow();
+  });
+
+  test.each([
+    -1,
+    Number.NaN,
+    Number.POSITIVE_INFINITY,
+  ])('rejects a negative or non-finite jitter window (%p)', (seconds) => {
+    expect(() => assertCronConfigWithinBounds(seconds)).toThrow(CRON_JITTER_ERROR);
+  });
+});

package/src/config.ts

@@ -0,0 +1,53 @@
+import {createConfig, num} from '@shipfox/config';
+
+export const config = createConfig({
+  TRIGGER_EVENT_RETENTION_DAYS: num({
+    desc: 'How many days a recorded trigger event (and its decisions) is kept before the hourly prune cron deletes it. Must be at least 1; a smaller value moves the cutoff to now or the future and would delete freshly recorded events. Defaults to 30.',
+    default: 30,
+  }),
+  TRIGGER_CRON_JITTER_WINDOW_SECONDS: num({
+    desc: 'Maximum number of seconds added as deterministic jitter to a cron trigger fire time. Use 0 to disable jitter. Values below about 60 seconds are usually no-ops when cron ticking runs at minute resolution; multi-minute windows spread large schedule herds.',
+    default: 0,
+  }),
+  TRIGGER_CRON_FANOUT: num({
+    desc: 'How many drain activities the once-per-minute cron tick runs in parallel. Each activity claims and fires one bounded batch, so the per-minute ceiling is TRIGGER_CRON_FANOUT times TRIGGER_CRON_CLAIM_BATCH runs. Raise it (and pod count) to fire more schedules per minute. Must be at least 1. Defaults to 2.',
+    default: 2,
+  }),
+  TRIGGER_CRON_CLAIM_BATCH: num({
+    desc: 'How many due cron schedules a single drain activity claims and fires per tick. Bounds the load a cron burst can put on the database and the run-creation path. Must be at least 1. Defaults to 100.',
+    default: 100,
+  }),
+});
+
+export function assertRetentionDaysWithinBounds(days: number): void {
+  if (!Number.isFinite(days) || days < 1) {
+    throw new Error(
+      `TRIGGER_EVENT_RETENTION_DAYS must be a finite number of at least 1, received ${days}.`,
+    );
+  }
+}
+
+assertRetentionDaysWithinBounds(config.TRIGGER_EVENT_RETENTION_DAYS);
+
+export function assertCronConfigWithinBounds(jitterWindowSeconds: number): void {
+  if (!Number.isFinite(jitterWindowSeconds) || jitterWindowSeconds < 0) {
+    throw new Error(
+      `TRIGGER_CRON_JITTER_WINDOW_SECONDS must be a finite non-negative number, received ${jitterWindowSeconds}.`,
+    );
+  }
+}
+
+assertCronConfigWithinBounds(config.TRIGGER_CRON_JITTER_WINDOW_SECONDS);
+
+export function assertCronThroughputWithinBounds(fanout: number, claimBatch: number): void {
+  if (!Number.isInteger(fanout) || fanout < 1) {
+    throw new Error(`TRIGGER_CRON_FANOUT must be an integer of at least 1, received ${fanout}.`);
+  }
+  if (!Number.isInteger(claimBatch) || claimBatch < 1) {
+    throw new Error(
+      `TRIGGER_CRON_CLAIM_BATCH must be an integer of at least 1, received ${claimBatch}.`,
+    );
+  }
+}
+
+assertCronThroughputWithinBounds(config.TRIGGER_CRON_FANOUT, config.TRIGGER_CRON_CLAIM_BATCH);

package/src/core/compute-next-fire-at.test.ts

@@ -0,0 +1,69 @@
+import {computeNextFireAt} from './compute-next-fire-at.js';
+
+describe('computeNextFireAt', () => {
+  test('returns the next occurrence strictly after the from instant', () => {
+    const result = computeNextFireAt({
+      cronExpression: '0 2 * * *',
+      timezone: 'UTC',
+      from: new Date('2026-01-01T02:00:00.000Z'),
+      subscriptionId: crypto.randomUUID(),
+      jitterWindowSeconds: 0,
+    });
+
+    expect(result).toEqual(new Date('2026-01-02T02:00:00.000Z'));
+  });
+
+  test('evaluates the schedule in the supplied timezone', () => {
+    const result = computeNextFireAt({
+      cronExpression: '0 2 * * *',
+      timezone: 'America/New_York',
+      from: new Date('2026-01-01T00:00:00.000Z'),
+      subscriptionId: crypto.randomUUID(),
+      jitterWindowSeconds: 0,
+    });
+
+    expect(result).toEqual(new Date('2026-01-01T07:00:00.000Z'));
+  });
+
+  test('applies deterministic jitter for the subscription', () => {
+    const params = {
+      cronExpression: '0 2 * * *',
+      timezone: 'UTC',
+      from: new Date('2026-01-01T00:00:00.000Z'),
+      subscriptionId: crypto.randomUUID(),
+      jitterWindowSeconds: 600,
+    };
+
+    const first = computeNextFireAt(params);
+    const second = computeNextFireAt(params);
+
+    expect(second).toEqual(first);
+    expect(first.getTime()).toBeGreaterThanOrEqual(new Date('2026-01-01T02:00:00.000Z').getTime());
+    expect(first.getTime()).toBeLessThan(new Date('2026-01-02T02:00:00.000Z').getTime());
+  });
+
+  test('does not jitter past the following occurrence', () => {
+    const result = computeNextFireAt({
+      cronExpression: '*/5 * * * *',
+      timezone: 'UTC',
+      from: new Date('2026-01-01T00:00:00.000Z'),
+      subscriptionId: crypto.randomUUID(),
+      jitterWindowSeconds: 60 * 60,
+    });
+
+    expect(result.getTime()).toBeGreaterThanOrEqual(new Date('2026-01-01T00:05:00.000Z').getTime());
+    expect(result.getTime()).toBeLessThan(new Date('2026-01-01T00:10:00.000Z').getTime());
+  });
+
+  test('returns the exact occurrence when the jitter window is disabled', () => {
+    const result = computeNextFireAt({
+      cronExpression: '*/5 * * * *',
+      timezone: 'UTC',
+      from: new Date('2026-01-01T00:00:00.000Z'),
+      subscriptionId: crypto.randomUUID(),
+      jitterWindowSeconds: 0,
+    });
+
+    expect(result).toEqual(new Date('2026-01-01T00:05:00.000Z'));
+  });
+});

package/src/core/compute-next-fire-at.ts

@@ -0,0 +1,37 @@
+import {CronExpressionParser} from 'cron-parser';
+
+export interface ComputeNextFireAtParams {
+  readonly cronExpression: string;
+  readonly timezone: string;
+  readonly from: Date;
+  readonly subscriptionId: string;
+  readonly jitterWindowSeconds: number;
+}
+
+export function computeNextFireAt(params: ComputeNextFireAtParams): Date {
+  const iterator = CronExpressionParser.parse(params.cronExpression, {
+    currentDate: params.from,
+    tz: params.timezone,
+  });
+  const occurrence = iterator.next().toDate();
+  const following = iterator.next().toDate();
+  const gapMs = following.getTime() - occurrence.getTime();
+  const offsetMs = jitterOffsetMs(params.subscriptionId, params.jitterWindowSeconds, gapMs);
+  return new Date(occurrence.getTime() + offsetMs);
+}
+
+function jitterOffsetMs(subscriptionId: string, windowSeconds: number, gapMs: number): number {
+  const windowMs = Math.floor(windowSeconds * 1000);
+  const clampMs = Math.min(windowMs, gapMs);
+  if (clampMs <= 0) return 0;
+  return hashStringToUint32(subscriptionId) % clampMs;
+}
+
+function hashStringToUint32(value: string): number {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return hash >>> 0;
+}

package/src/core/config.test.ts

@@ -0,0 +1,213 @@
+import {evaluateStoredFilter, evaluateTriggerFilter, readConfigInputs} from './config.js';
+import type {TriggerSubscription} from './entities/subscription.js';
+
+function subscriptionWithConfig(config: Record<string, unknown>): TriggerSubscription {
+  return {
+    id: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    projectId: crypto.randomUUID(),
+    workflowDefinitionId: crypto.randomUUID(),
+    name: 'test',
+    source: 'github',
+    event: 'push',
+    config,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+}
+
+describe('readConfigInputs', () => {
+  test('returns the with object when it is a plain object', () => {
+    const inputs = readConfigInputs(subscriptionWithConfig({with: {env: 'staging'}}));
+
+    expect(inputs).toEqual({env: 'staging'});
+  });
+
+  test('returns undefined when with is missing', () => {
+    const inputs = readConfigInputs(subscriptionWithConfig({on: 'main'}));
+
+    expect(inputs).toBeUndefined();
+  });
+
+  test('returns undefined when with is null', () => {
+    const inputs = readConfigInputs(subscriptionWithConfig({with: null}));
+
+    expect(inputs).toBeUndefined();
+  });
+
+  test('returns undefined when with is an array', () => {
+    const inputs = readConfigInputs(subscriptionWithConfig({with: ['env']}));
+
+    expect(inputs).toBeUndefined();
+  });
+
+  test('returns undefined when with is a primitive', () => {
+    const inputs = readConfigInputs(subscriptionWithConfig({with: 'staging'}));
+
+    expect(inputs).toBeUndefined();
+  });
+});
+
+describe('evaluateTriggerFilter', () => {
+  test('returns matched when filter is missing', () => {
+    const result = evaluateTriggerFilter({
+      subscription: subscriptionWithConfig({}),
+      source: 'github',
+      event: 'push',
+      payload: {ref: 'refs/heads/main'},
+    });
+
+    expect(result).toEqual({kind: 'matched'});
+  });
+
+  test('evaluates filter expressions against the event payload and trigger identity', () => {
+    const subscription = subscriptionWithConfig({
+      filter:
+        'event.ref == "refs/heads/main" && event.repository.full_name == "shipfox/platform" && trigger.source == "github" && trigger.event == "push"',
+    });
+
+    const matches = evaluateTriggerFilter({
+      subscription,
+      source: 'github',
+      event: 'push',
+      payload: {
+        ref: 'refs/heads/main',
+        repository: {full_name: 'shipfox/platform'},
+      },
+    });
+    const misses = evaluateTriggerFilter({
+      subscription,
+      source: 'github',
+      event: 'push',
+      payload: {
+        ref: 'refs/heads/main',
+        repository: {full_name: 'shipfox/docs'},
+      },
+    });
+
+    expect(matches).toEqual({kind: 'matched'});
+    expect(misses).toEqual({kind: 'filtered'});
+  });
+
+  test('returns filter-error when the stored filter cannot be parsed', () => {
+    const subscription = subscriptionWithConfig({filter: 'event.ref =='});
+
+    const result = evaluateTriggerFilter({
+      subscription,
+      source: 'github',
+      event: 'push',
+      payload: {ref: 'refs/heads/main'},
+    });
+
+    expect(result.kind).toBe('filter-error');
+    if (result.kind !== 'filter-error') throw new Error('expected filter-error');
+    expect(result.reason).not.toBe('Invalid workflow expression');
+  });
+
+  test('returns filter-error when filter evaluation throws', () => {
+    const subscription = subscriptionWithConfig({filter: 'event.ref.size() > 1'});
+
+    const result = evaluateTriggerFilter({
+      subscription,
+      source: 'github',
+      event: 'push',
+      payload: {},
+    });
+
+    expect(result).toEqual({kind: 'filter-error', reason: 'Trigger filter evaluation failed'});
+  });
+
+  test('returns filtered when the stored filter evaluates to a non-boolean value', () => {
+    const subscription = subscriptionWithConfig({filter: 'event.ref'});
+
+    const result = evaluateTriggerFilter({
+      subscription,
+      source: 'github',
+      event: 'push',
+      payload: {ref: 'refs/heads/main'},
+    });
+
+    expect(result).toEqual({kind: 'filtered'});
+  });
+
+  test.each([
+    {name: 'blank', filter: '   '},
+    {name: 'non-string', filter: ['event.ref == "refs/heads/main"']},
+  ])('returns filter-error when the stored filter is $name', ({filter}) => {
+    const subscription = subscriptionWithConfig({filter});
+
+    const result = evaluateTriggerFilter({
+      subscription,
+      source: 'github',
+      event: 'push',
+      payload: {ref: 'refs/heads/main'},
+    });
+
+    expect(result).toEqual({
+      kind: 'filter-error',
+      reason: 'Trigger subscription filter must be a non-empty string when set',
+    });
+  });
+});
+
+describe('evaluateStoredFilter', () => {
+  const invalidReason = 'Stored filter must be a non-empty string when set';
+  const evaluationFailedReason = 'Stored filter evaluation failed';
+
+  function evaluate(value: unknown, context: Record<string, unknown>) {
+    return evaluateStoredFilter({value, context, invalidReason, evaluationFailedReason});
+  }
+
+  test('returns matched when filter is missing', () => {
+    const result = evaluate(undefined, {event: {ref: 'refs/heads/main'}});
+
+    expect(result).toEqual({kind: 'matched'});
+  });
+
+  test('evaluates against the provided context', () => {
+    const value = 'event.issue.number == jobs.build.outputs.pr_number';
+
+    const matches = evaluate(value, {
+      event: {issue: {number: 42}},
+      jobs: {build: {outputs: {pr_number: 42}}},
+    });
+    const misses = evaluate(value, {
+      event: {issue: {number: 7}},
+      jobs: {build: {outputs: {pr_number: 42}}},
+    });
+
+    expect(matches).toEqual({kind: 'matched'});
+    expect(misses).toEqual({kind: 'filtered'});
+  });
+
+  test('returns filter-error when the filter cannot be parsed', () => {
+    const result = evaluate('event.ref ==', {event: {ref: 'refs/heads/main'}});
+
+    expect(result.kind).toBe('filter-error');
+    if (result.kind !== 'filter-error') throw new Error('expected filter-error');
+    expect(result.reason).not.toBe('Invalid workflow expression');
+  });
+
+  test('returns filter-error when evaluation throws', () => {
+    const result = evaluate('jobs.build.outputs.pr_number == 42', {
+      event: {issue: {number: 42}},
+    });
+
+    expect(result).toEqual({kind: 'filter-error', reason: evaluationFailedReason});
+  });
+
+  test('returns filtered when the stored filter evaluates to a non-boolean value', () => {
+    const result = evaluate('event.ref', {event: {ref: 'refs/heads/main'}});
+
+    expect(result).toEqual({kind: 'filtered'});
+  });
+
+  test.each([
+    {name: 'blank', filter: '   '},
+    {name: 'non-string', filter: ['event.ref == "refs/heads/main"']},
+  ])('returns filter-error when the stored filter is $name', ({filter}) => {
+    const result = evaluate(filter, {event: {ref: 'refs/heads/main'}});
+
+    expect(result).toEqual({kind: 'filter-error', reason: invalidReason});
+  });
+});

package/src/core/config.ts

@@ -0,0 +1,86 @@
+import {
+  createWorkflowExpression,
+  evaluateWorkflowPredicateFailClosed,
+  InvalidWorkflowExpressionError,
+  type WorkflowExpression,
+} from '@shipfox/expression';
+import type {TriggerSubscription} from './entities/subscription.js';
+
+// Narrow the jsonb projection at the read boundary: the parser writes the right shapes,
+// but the column is unconstrained and these values reach run inputs.
+
+export function readConfigInputs(
+  subscription: TriggerSubscription,
+): Record<string, unknown> | undefined {
+  const value = subscription.config.with;
+  if (value === null || value === undefined) return undefined;
+  if (typeof value !== 'object' || Array.isArray(value)) return undefined;
+  return value as Record<string, unknown>;
+}
+
+export type TriggerFilterEvaluation =
+  | {kind: 'matched'}
+  | {kind: 'filtered'}
+  | {kind: 'filter-error'; reason: string};
+
+export type StoredFilterEvaluation = TriggerFilterEvaluation;
+
+export interface EvaluateStoredFilterParams {
+  value: unknown;
+  context: Record<string, unknown>;
+  invalidReason: string;
+  evaluationFailedReason: string;
+}
+
+export function evaluateStoredFilter(params: EvaluateStoredFilterParams): StoredFilterEvaluation {
+  const {value} = params;
+  if (value === null || value === undefined) return {kind: 'matched'};
+  if (typeof value !== 'string' || value.trim() === '') {
+    return {
+      kind: 'filter-error',
+      reason: params.invalidReason,
+    };
+  }
+
+  let expression: WorkflowExpression;
+  try {
+    expression = createWorkflowExpression({source: value, check: {mode: 'syntax'}});
+  } catch (error) {
+    return {kind: 'filter-error', reason: reasonFrom(error)};
+  }
+
+  const result = evaluateWorkflowPredicateFailClosed(expression, params.context);
+
+  if (result.evaluationFailed) {
+    return {kind: 'filter-error', reason: params.evaluationFailedReason};
+  }
+
+  return result.value ? {kind: 'matched'} : {kind: 'filtered'};
+}
+
+export interface EvaluateTriggerFilterParams {
+  subscription: TriggerSubscription;
+  source: string;
+  event: string;
+  payload: unknown;
+}
+
+export function evaluateTriggerFilter(
+  params: EvaluateTriggerFilterParams,
+): TriggerFilterEvaluation {
+  return evaluateStoredFilter({
+    value: params.subscription.config.filter,
+    context: {
+      event: params.payload,
+      trigger: {source: params.source, event: params.event},
+    },
+    invalidReason: 'Trigger subscription filter must be a non-empty string when set',
+    evaluationFailedReason: 'Trigger filter evaluation failed',
+  });
+}
+
+function reasonFrom(error: unknown): string {
+  if (error instanceof InvalidWorkflowExpressionError) return error.reason;
+  if (error instanceof Error) return error.message;
+  return String(error);
+}

package/src/core/dispatch-integration-event.history-failure.test.ts

@@ -0,0 +1,66 @@
+import {triggerSubscriptionFactory} from '#test/index.js';
+
+const runWorkflow = vi.fn();
+const deliverEventToListener = vi.fn();
+const insertReceivedEvent = vi.fn();
+
+vi.mock('@shipfox/api-workflows', () => ({
+  runWorkflow: (...args: unknown[]) => runWorkflow(...args),
+  deliverEventToListener: (...args: unknown[]) => deliverEventToListener(...args),
+  isPermanentRunWorkflowError: () => false,
+}));
+
+vi.mock('#db/event-history.js', () => ({
+  insertReceivedEvent: (...args: unknown[]) => insertReceivedEvent(...args),
+  markReceivedEventDiscarded: vi.fn(),
+  markReceivedEventRouted: vi.fn(),
+  markReceivedEventFailed: vi.fn(),
+  markReceivedEventErrored: vi.fn(),
+  upsertTriggeredDecision: vi.fn(),
+  upsertDispatchErrorDecision: vi.fn(),
+  upsertFilterErrorDecision: vi.fn(),
+  upsertListenerTriggeredDecision: vi.fn(),
+  upsertListenerDispatchErrorDecision: vi.fn(),
+  upsertListenerFilterErrorDecision: vi.fn(),
+}));
+
+// Import after mocks so the code under test sees the spies.
+const {dispatchIntegrationEvent} = await import('./dispatch-integration-event.js');
+
+describe('dispatchIntegrationEvent resilience to history-write failure', () => {
+  beforeEach(() => {
+    runWorkflow.mockReset();
+    deliverEventToListener.mockReset();
+    deliverEventToListener.mockResolvedValue({buffered: true, skipped: false});
+    insertReceivedEvent.mockReset();
+    insertReceivedEvent.mockRejectedValue(new Error('history db down'));
+  });
+
+  test('still fires runWorkflow and does not throw when history recording fails', async () => {
+    runWorkflow.mockResolvedValue({id: crypto.randomUUID(), name: 'Build'});
+    const workspaceId = crypto.randomUUID();
+    await triggerSubscriptionFactory.create({
+      workspaceId,
+      source: 'github',
+      event: 'push',
+      config: {},
+    });
+
+    await expect(
+      dispatchIntegrationEvent({
+        eventRef: crypto.randomUUID(),
+        workspaceId,
+        provider: 'github',
+        source: 'github',
+        event: 'push',
+        connectionId: crypto.randomUUID(),
+        connectionName: 'Acme Production',
+        deliveryId: crypto.randomUUID(),
+        receivedAt: new Date(),
+        payload: {ref: 'main'},
+      }),
+    ).resolves.toBeUndefined();
+
+    expect(runWorkflow).toHaveBeenCalledTimes(1);
+  });
+});