@shipfox/api-triggers 2.0.0

package/src/db/event-history.test.ts

@@ -0,0 +1,421 @@
+import {eq} from 'drizzle-orm';
+import type {JobListenerSubscription} from '#core/entities/job-listener-subscription.js';
+import type {TriggerSubscription} from '#core/entities/subscription.js';
+import {db} from './db.js';
+import {
+  type InsertReceivedEventParams,
+  insertReceivedEvent,
+  markReceivedEventDiscarded,
+  markReceivedEventErrored,
+  markReceivedEventFailed,
+  markReceivedEventRouted,
+  upsertDispatchErrorDecision,
+  upsertFilterErrorDecision,
+  upsertListenerDispatchErrorDecision,
+  upsertListenerFilterErrorDecision,
+  upsertListenerTriggeredDecision,
+  upsertTriggeredDecision,
+} from './event-history.js';
+import {triggersDecisions} from './schema/decisions.js';
+import {triggersReceivedEvents} from './schema/received-events.js';
+
+function buildEventParams(
+  overrides: Partial<InsertReceivedEventParams> = {},
+): InsertReceivedEventParams {
+  return {
+    eventRef: crypto.randomUUID(),
+    origin: 'integration',
+    workspaceId: crypto.randomUUID(),
+    provider: 'github',
+    source: 'github',
+    event: 'push',
+    deliveryId: null,
+    connectionId: null,
+    connectionName: null,
+    payload: null,
+    receivedAt: new Date(),
+    ...overrides,
+  };
+}
+
+function buildSubscription(overrides: Partial<TriggerSubscription> = {}): TriggerSubscription {
+  return {
+    id: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    projectId: crypto.randomUUID(),
+    workflowDefinitionId: crypto.randomUUID(),
+    name: 'trigger',
+    source: 'github',
+    event: 'push',
+    config: {},
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    ...overrides,
+  };
+}
+
+function buildListenerSubscription(
+  overrides: Partial<JobListenerSubscription> = {},
+): JobListenerSubscription {
+  return {
+    id: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    workflowRunId: crypto.randomUUID(),
+    jobId: crypto.randomUUID(),
+    kind: 'on',
+    matcherOrdinal: 0,
+    source: 'github',
+    event: 'push',
+    config: {},
+    createdAt: new Date(),
+    ...overrides,
+  };
+}
+
+function decisionsFor(receivedEventId: string) {
+  return db()
+    .select()
+    .from(triggersDecisions)
+    .where(eq(triggersDecisions.receivedEventId, receivedEventId));
+}
+
+describe('insertReceivedEvent', () => {
+  it('inserts a received event and returns its id', async () => {
+    const params = buildEventParams();
+
+    const id = await insertReceivedEvent(params);
+
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, id));
+    expect(row?.eventRef).toBe(params.eventRef);
+    expect(row?.provider).toBe('github');
+    expect(row?.outcome).toBe('received');
+    expect(row?.matchedCount).toBe(0);
+  });
+
+  it('returns the existing id on event_ref conflict (replay)', async () => {
+    const params = buildEventParams();
+
+    const first = await insertReceivedEvent(params);
+    const second = await insertReceivedEvent(params);
+
+    expect(second).toBe(first);
+    const rows = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.eventRef, params.eventRef));
+    expect(rows).toHaveLength(1);
+  });
+});
+
+describe('received-event outcome transitions', () => {
+  it('marks an event routed with matched_count and processed_at', async () => {
+    const id = await insertReceivedEvent(buildEventParams());
+
+    await markReceivedEventRouted(id, 3);
+
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, id));
+    expect(row?.outcome).toBe('routed');
+    expect(row?.matchedCount).toBe(3);
+    expect(row?.processedAt).toBeInstanceOf(Date);
+  });
+
+  it('marks an event discarded with matched_count 0', async () => {
+    const id = await insertReceivedEvent(buildEventParams());
+
+    await markReceivedEventDiscarded(id);
+
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, id));
+    expect(row?.outcome).toBe('discarded');
+    expect(row?.matchedCount).toBe(0);
+    expect(row?.processedAt).toBeInstanceOf(Date);
+  });
+
+  it('does not downgrade a routed event to discarded', async () => {
+    const id = await insertReceivedEvent(buildEventParams());
+    await markReceivedEventRouted(id, 1);
+
+    await markReceivedEventDiscarded(id);
+
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, id));
+    expect(row?.outcome).toBe('routed');
+    expect(row?.matchedCount).toBe(1);
+  });
+
+  it('marks an event failed without setting processed_at (transient, retried)', async () => {
+    const id = await insertReceivedEvent(buildEventParams());
+
+    await markReceivedEventFailed(id, 2);
+
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, id));
+    expect(row?.outcome).toBe('failed');
+    expect(row?.matchedCount).toBe(2);
+    expect(row?.processedAt).toBeNull();
+  });
+
+  it('does not downgrade a routed event to failed (terminal success wins under a stale failed write)', async () => {
+    const id = await insertReceivedEvent(buildEventParams());
+    await markReceivedEventRouted(id, 2);
+
+    await markReceivedEventFailed(id, 2);
+
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, id));
+    expect(row?.outcome).toBe('routed');
+    expect(row?.processedAt).toBeInstanceOf(Date);
+  });
+
+  it('marks an event errored with processed_at when no run was created', async () => {
+    const id = await insertReceivedEvent(buildEventParams());
+
+    await markReceivedEventErrored(id, 2);
+
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, id));
+    expect(row?.outcome).toBe('errored');
+    expect(row?.matchedCount).toBe(2);
+    expect(row?.processedAt).toBeInstanceOf(Date);
+  });
+
+  it('promotes to routed instead of errored when a triggered decision exists (cross-attempt run)', async () => {
+    const id = await insertReceivedEvent(buildEventParams());
+    await upsertTriggeredDecision({
+      receivedEventId: id,
+      subscription: buildSubscription(),
+      run: {id: crypto.randomUUID(), name: 'Build and test'},
+    });
+
+    await markReceivedEventErrored(id, 2);
+
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, id));
+    expect(row?.outcome).toBe('routed');
+    expect(row?.matchedCount).toBe(2);
+    expect(row?.processedAt).toBeInstanceOf(Date);
+  });
+
+  it('does not downgrade a routed event to errored', async () => {
+    const id = await insertReceivedEvent(buildEventParams());
+    await markReceivedEventRouted(id, 1);
+
+    await markReceivedEventErrored(id, 1);
+
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, id));
+    expect(row?.outcome).toBe('routed');
+  });
+
+  it('does not downgrade an errored event to failed (a late transient write loses)', async () => {
+    const id = await insertReceivedEvent(buildEventParams());
+    await markReceivedEventErrored(id, 1);
+
+    await markReceivedEventFailed(id, 1);
+
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, id));
+    expect(row?.outcome).toBe('errored');
+    expect(row?.processedAt).toBeInstanceOf(Date);
+  });
+
+  it('promotes a transient failed event to errored on the all-permanent replay', async () => {
+    const id = await insertReceivedEvent(buildEventParams());
+    await markReceivedEventFailed(id, 2);
+
+    await markReceivedEventErrored(id, 2);
+
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, id));
+    expect(row?.outcome).toBe('errored');
+    expect(row?.matchedCount).toBe(2);
+    expect(row?.processedAt).toBeInstanceOf(Date);
+  });
+});
+
+describe('decision upserts', () => {
+  it('is idempotent on (received_event_id, subscription_id)', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const subscription = buildSubscription();
+    const renamedSubscription = buildSubscription({...subscription, name: 'renamed trigger'});
+    const run = {id: crypto.randomUUID(), name: 'Build and test'};
+
+    await upsertTriggeredDecision({receivedEventId, subscription, run});
+    await upsertTriggeredDecision({receivedEventId, subscription: renamedSubscription, run});
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.subscriptionKind).toBe('trigger');
+    expect(rows[0]?.decision).toBe('triggered');
+    expect(rows[0]?.subscriptionName).toBe(subscription.name);
+    expect(rows[0]?.runId).toBe(run.id);
+    expect(rows[0]?.runName).toBe(run.name);
+  });
+
+  it('flips a dispatch-error decision to triggered on a successful retry', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const subscription = buildSubscription();
+    const renamedSubscription = buildSubscription({...subscription, name: 'renamed trigger'});
+    const run = {id: crypto.randomUUID(), name: 'Build and test'};
+
+    await upsertDispatchErrorDecision({receivedEventId, subscription, reason: 'boom'});
+    await upsertTriggeredDecision({receivedEventId, subscription: renamedSubscription, run});
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.subscriptionKind).toBe('trigger');
+    expect(rows[0]?.decision).toBe('triggered');
+    expect(rows[0]?.subscriptionName).toBe(subscription.name);
+    expect(rows[0]?.runId).toBe(run.id);
+    expect(rows[0]?.reason).toBeNull();
+  });
+
+  it('never downgrades an existing triggered decision to dispatch-error', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const subscription = buildSubscription();
+    const renamedSubscription = buildSubscription({...subscription, name: 'renamed trigger'});
+    const run = {id: crypto.randomUUID(), name: 'Build and test'};
+
+    await upsertTriggeredDecision({receivedEventId, subscription, run});
+    await upsertDispatchErrorDecision({
+      receivedEventId,
+      subscription: renamedSubscription,
+      reason: 'definition deleted',
+    });
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.subscriptionKind).toBe('trigger');
+    expect(rows[0]?.decision).toBe('triggered');
+    expect(rows[0]?.subscriptionName).toBe(subscription.name);
+    expect(rows[0]?.runId).toBe(run.id);
+    expect(rows[0]?.reason).toBeNull();
+  });
+
+  it('preserves the original subscription name on dispatch-error replay', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const subscription = buildSubscription();
+    const renamedSubscription = buildSubscription({...subscription, name: 'renamed trigger'});
+
+    await upsertDispatchErrorDecision({receivedEventId, subscription, reason: 'boom'});
+    await upsertDispatchErrorDecision({
+      receivedEventId,
+      subscription: renamedSubscription,
+      reason: 'still broken',
+    });
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.subscriptionKind).toBe('trigger');
+    expect(rows[0]?.decision).toBe('dispatch-error');
+    expect(rows[0]?.subscriptionName).toBe(subscription.name);
+    expect(rows[0]?.reason).toBe('still broken');
+  });
+
+  it('records a filter-error decision', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const subscription = buildSubscription();
+
+    await upsertFilterErrorDecision({
+      receivedEventId,
+      subscription,
+      reason: 'Trigger filter evaluation failed',
+    });
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.subscriptionKind).toBe('trigger');
+    expect(rows[0]?.decision).toBe('filter-error');
+    expect(rows[0]?.reason).toBe('Trigger filter evaluation failed');
+  });
+
+  it('records a listener triggered decision with matcher identity', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const subscription = buildListenerSubscription({kind: 'until', matcherOrdinal: 2});
+
+    await upsertListenerTriggeredDecision({receivedEventId, subscription});
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      subscriptionKind: 'listener',
+      subscriptionId: subscription.id,
+      subscriptionName: 'listener until[2] github/push',
+      workflowDefinitionId: null,
+      projectId: null,
+      workflowRunId: subscription.workflowRunId,
+      jobId: subscription.jobId,
+      matcherKind: 'until',
+      matcherOrdinal: 2,
+      decision: 'triggered',
+      reason: null,
+    });
+  });
+
+  it('flips a listener dispatch-error decision to triggered on a successful retry', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const subscription = buildListenerSubscription();
+
+    await upsertListenerDispatchErrorDecision({receivedEventId, subscription, reason: 'boom'});
+    await upsertListenerTriggeredDecision({receivedEventId, subscription});
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.decision).toBe('triggered');
+    expect(rows[0]?.reason).toBeNull();
+  });
+
+  it('never downgrades an existing listener triggered decision to dispatch-error', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const subscription = buildListenerSubscription();
+
+    await upsertListenerTriggeredDecision({receivedEventId, subscription});
+    await upsertListenerDispatchErrorDecision({receivedEventId, subscription, reason: 'boom'});
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.decision).toBe('triggered');
+    expect(rows[0]?.reason).toBeNull();
+  });
+
+  it('records a listener filter-error decision', async () => {
+    const receivedEventId = await insertReceivedEvent(buildEventParams());
+    const subscription = buildListenerSubscription();
+
+    await upsertListenerFilterErrorDecision({
+      receivedEventId,
+      subscription,
+      reason: 'Listener filter evaluation failed',
+    });
+
+    const rows = await decisionsFor(receivedEventId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.subscriptionKind).toBe('listener');
+    expect(rows[0]?.decision).toBe('filter-error');
+    expect(rows[0]?.reason).toBe('Listener filter evaluation failed');
+  });
+});

package/src/db/event-history.ts

@@ -0,0 +1,279 @@
+import {and, eq, ne, notInArray, sql} from 'drizzle-orm';
+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';
+import {db} from './db.js';
+import {triggersDecisions} from './schema/decisions.js';
+import {triggersReceivedEvents} from './schema/received-events.js';
+
+export interface InsertReceivedEventParams {
+  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;
+}
+
+// `event_ref` is unique and delivery is at-least-once, so the same event can
+// arrive twice; either path returns the row id used to attach decisions.
+export async function insertReceivedEvent(params: InsertReceivedEventParams): Promise<string> {
+  const [inserted] = await db()
+    .insert(triggersReceivedEvents)
+    .values({
+      eventRef: params.eventRef,
+      origin: params.origin,
+      workspaceId: params.workspaceId,
+      provider: params.provider,
+      source: params.source,
+      event: params.event,
+      deliveryId: params.deliveryId,
+      connectionId: params.connectionId,
+      connectionName: params.connectionName,
+      payload: params.payload,
+      receivedAt: params.receivedAt,
+    })
+    .onConflictDoNothing({target: triggersReceivedEvents.eventRef})
+    .returning({id: triggersReceivedEvents.id});
+  if (inserted) return inserted.id;
+
+  const [existing] = await db()
+    .select({id: triggersReceivedEvents.id})
+    .from(triggersReceivedEvents)
+    .where(eq(triggersReceivedEvents.eventRef, params.eventRef));
+  if (!existing) {
+    throw new Error(`received_events row missing after conflict for event_ref ${params.eventRef}`);
+  }
+  return existing.id;
+}
+
+export async function markReceivedEventDiscarded(id: string): Promise<void> {
+  await db()
+    .update(triggersReceivedEvents)
+    .set({outcome: 'discarded', matchedCount: 0, processedAt: new Date()})
+    .where(
+      and(
+        eq(triggersReceivedEvents.id, id),
+        notInArray(triggersReceivedEvents.outcome, ['routed', 'errored']),
+      ),
+    );
+}
+
+export async function markReceivedEventRouted(id: string, matchedCount: number): Promise<void> {
+  await db()
+    .update(triggersReceivedEvents)
+    .set({outcome: 'routed', matchedCount, processedAt: new Date()})
+    .where(eq(triggersReceivedEvents.id, id));
+}
+
+// No processedAt: `failed` is transient. Under at-least-once dispatch, a late
+// failure must not clobber a sibling invocation's terminal outcome.
+export async function markReceivedEventFailed(id: string, matchedCount: number): Promise<void> {
+  await db()
+    .update(triggersReceivedEvents)
+    .set({outcome: 'failed', matchedCount})
+    .where(
+      and(
+        eq(triggersReceivedEvents.id, id),
+        notInArray(triggersReceivedEvents.outcome, ['routed', 'discarded', 'errored']),
+      ),
+    );
+}
+
+// Terminal outcome for a fan-out that produced no new run this pass. The CASE is a
+// cross-attempt safety net: under at-least-once delivery a prior attempt may already have
+// created a run (its decision row is `triggered`, which is never downgraded), so promote the
+// event to `routed` rather than falsely record `errored`. Guarded so it never downgrades a
+// terminal success.
+export async function markReceivedEventErrored(id: string, matchedCount: number): Promise<void> {
+  await db()
+    .update(triggersReceivedEvents)
+    .set({
+      outcome: sql`CASE WHEN EXISTS (
+        SELECT 1
+        FROM ${triggersDecisions}
+        WHERE ${triggersDecisions.receivedEventId} = ${triggersReceivedEvents.id}
+          AND ${triggersDecisions.decision} = 'triggered'
+      ) THEN 'routed' ELSE 'errored' END`,
+      matchedCount,
+      processedAt: new Date(),
+    })
+    .where(
+      and(
+        eq(triggersReceivedEvents.id, id),
+        notInArray(triggersReceivedEvents.outcome, ['routed', 'discarded']),
+      ),
+    );
+}
+
+export interface UpsertTriggeredDecisionParams {
+  receivedEventId: string;
+  subscription: TriggerSubscription;
+  run: {id: string; name: string};
+}
+
+export async function upsertTriggeredDecision(
+  params: UpsertTriggeredDecisionParams,
+): Promise<void> {
+  await db()
+    .insert(triggersDecisions)
+    .values({
+      receivedEventId: params.receivedEventId,
+      subscriptionKind: 'trigger',
+      subscriptionId: params.subscription.id,
+      subscriptionName: params.subscription.name,
+      workflowDefinitionId: params.subscription.workflowDefinitionId,
+      projectId: params.subscription.projectId,
+      decision: 'triggered',
+      runId: params.run.id,
+      runName: params.run.name,
+      reason: null,
+    })
+    .onConflictDoUpdate({
+      target: [
+        triggersDecisions.receivedEventId,
+        triggersDecisions.subscriptionKind,
+        triggersDecisions.subscriptionId,
+      ],
+      set: {decision: 'triggered', runId: params.run.id, runName: params.run.name, reason: null},
+    });
+}
+
+export interface UpsertFailedDecisionParams {
+  receivedEventId: string;
+  subscription: TriggerSubscription;
+  reason: string;
+}
+
+export async function upsertFilterErrorDecision(params: UpsertFailedDecisionParams): Promise<void> {
+  await upsertFailedDecision(params, 'filter-error');
+}
+
+// A created run is ground truth. A later retry failure must not erase it.
+export async function upsertDispatchErrorDecision(
+  params: UpsertFailedDecisionParams,
+): Promise<void> {
+  await upsertFailedDecision(params, 'dispatch-error');
+}
+
+async function upsertFailedDecision(
+  params: UpsertFailedDecisionParams,
+  decision: 'filter-error' | 'dispatch-error',
+): Promise<void> {
+  await db()
+    .insert(triggersDecisions)
+    .values({
+      receivedEventId: params.receivedEventId,
+      subscriptionKind: 'trigger',
+      subscriptionId: params.subscription.id,
+      subscriptionName: params.subscription.name,
+      workflowDefinitionId: params.subscription.workflowDefinitionId,
+      projectId: params.subscription.projectId,
+      decision,
+      reason: params.reason,
+    })
+    .onConflictDoUpdate({
+      target: [
+        triggersDecisions.receivedEventId,
+        triggersDecisions.subscriptionKind,
+        triggersDecisions.subscriptionId,
+      ],
+      set: {decision, reason: params.reason, runId: null, runName: null},
+      setWhere: ne(triggersDecisions.decision, 'triggered'),
+    });
+}
+
+export interface UpsertListenerTriggeredDecisionParams {
+  receivedEventId: string;
+  subscription: JobListenerSubscription;
+}
+
+export async function upsertListenerTriggeredDecision(
+  params: UpsertListenerTriggeredDecisionParams,
+): Promise<void> {
+  await db()
+    .insert(triggersDecisions)
+    .values({
+      ...listenerDecisionIdentity(params),
+      decision: 'triggered',
+      runId: null,
+      runName: null,
+      reason: null,
+    })
+    .onConflictDoUpdate({
+      target: [
+        triggersDecisions.receivedEventId,
+        triggersDecisions.subscriptionKind,
+        triggersDecisions.subscriptionId,
+      ],
+      set: {decision: 'triggered', runId: null, runName: null, reason: null},
+    });
+}
+
+export interface UpsertListenerFailedDecisionParams {
+  receivedEventId: string;
+  subscription: JobListenerSubscription;
+  reason: string;
+}
+
+export async function upsertListenerFilterErrorDecision(
+  params: UpsertListenerFailedDecisionParams,
+): Promise<void> {
+  await upsertListenerFailedDecision(params, 'filter-error');
+}
+
+export async function upsertListenerDispatchErrorDecision(
+  params: UpsertListenerFailedDecisionParams,
+): Promise<void> {
+  await upsertListenerFailedDecision(params, 'dispatch-error');
+}
+
+async function upsertListenerFailedDecision(
+  params: UpsertListenerFailedDecisionParams,
+  decision: 'filter-error' | 'dispatch-error',
+): Promise<void> {
+  await db()
+    .insert(triggersDecisions)
+    .values({
+      ...listenerDecisionIdentity(params),
+      decision,
+      reason: params.reason,
+    })
+    .onConflictDoUpdate({
+      target: [
+        triggersDecisions.receivedEventId,
+        triggersDecisions.subscriptionKind,
+        triggersDecisions.subscriptionId,
+      ],
+      set: {decision, reason: params.reason, runId: null, runName: null},
+      setWhere: ne(triggersDecisions.decision, 'triggered'),
+    });
+}
+
+function listenerDecisionIdentity(params: {
+  receivedEventId: string;
+  subscription: JobListenerSubscription;
+}) {
+  const {subscription} = params;
+  return {
+    receivedEventId: params.receivedEventId,
+    subscriptionKind: 'listener' as const,
+    subscriptionId: subscription.id,
+    subscriptionName: listenerSubscriptionName(subscription),
+    workflowDefinitionId: null,
+    projectId: null,
+    workflowRunId: subscription.workflowRunId,
+    jobId: subscription.jobId,
+    matcherKind: subscription.kind,
+    matcherOrdinal: subscription.matcherOrdinal,
+  };
+}
+
+function listenerSubscriptionName(subscription: JobListenerSubscription): string {
+  return `listener ${subscription.kind}[${subscription.matcherOrdinal}] ${subscription.source}/${subscription.event}`;
+}