@shipfox/api-triggers 13.0.0 → 14.0.0

package/src/db/event-history.ts

@@ -275,5 +275,88 @@ function listenerDecisionIdentity(params: {
 }
 
 function listenerSubscriptionName(subscription: JobListenerSubscription): string {
-  return `listener ${subscription.kind}[${subscription.matcherOrdinal}] ${subscription.source}/${subscription.event}`;
+  // A NULL event is a source subscription; `*` keeps the audit name unambiguous.
+  return `listener ${subscription.kind}[${subscription.matcherOrdinal}] ${subscription.source}/${subscription.event ?? '*'}`;
+}
+
+export interface UpsertDevTriggeredDecisionParams {
+  receivedEventId: string;
+  triggerKey: string;
+  workflowDefinitionId: string;
+  run: {id: string; name: string};
+}
+
+// A dev journal entry has exactly one decision. Its partial unique index uses
+// received_event_id because NULL subscription ids do not conflict in the
+// regular subscription identity index.
+export async function upsertDevTriggeredDecision(
+  params: UpsertDevTriggeredDecisionParams,
+): Promise<void> {
+  await upsertDevDecision(params, {
+    decision: 'triggered',
+    runId: params.run.id,
+    runName: params.run.name,
+    reason: null,
+  });
+}
+
+export interface UpsertDevFilterErrorDecisionParams {
+  receivedEventId: string;
+  triggerKey: string;
+  workflowDefinitionId: string;
+  reason: string;
+}
+
+// Refusals before run creation (filter false or evaluation error on replay).
+export async function upsertDevFilterErrorDecision(
+  params: UpsertDevFilterErrorDecisionParams,
+): Promise<void> {
+  await upsertDevDecision(
+    params,
+    {
+      decision: 'filter-error',
+      runId: null,
+      runName: null,
+      reason: params.reason,
+    },
+    {preserveTriggered: true},
+  );
+}
+
+type DevDecisionValues = {
+  decision: 'triggered' | 'filter-error';
+  runId: string | null;
+  runName: string | null;
+  reason: string | null;
+};
+
+async function upsertDevDecision(
+  params: {
+    receivedEventId: string;
+    triggerKey: string;
+    workflowDefinitionId: string;
+  },
+  values: DevDecisionValues,
+  options: {preserveTriggered?: boolean} = {},
+): Promise<void> {
+  await db()
+    .insert(triggersDecisions)
+    .values({
+      receivedEventId: params.receivedEventId,
+      subscriptionKind: 'dev',
+      subscriptionId: null,
+      subscriptionName: params.triggerKey,
+      workflowDefinitionId: params.workflowDefinitionId,
+      projectId: null,
+      decision: values.decision,
+      runId: values.runId,
+      runName: values.runName,
+      reason: values.reason,
+    })
+    .onConflictDoUpdate({
+      target: triggersDecisions.receivedEventId,
+      targetWhere: sql`"subscription_kind" = 'dev'`,
+      set: values,
+      ...(options.preserveTriggered ? {setWhere: ne(triggersDecisions.decision, 'triggered')} : {}),
+    });
 }

package/src/db/event-queries.ts

@@ -1,9 +1,11 @@
 import {paginateTimestampIdRows, timestampIdCursorWhere} from '@shipfox/node-drizzle';
-import {and, asc, count, desc, eq, gte, inArray, lte, type SQL} from 'drizzle-orm';
+import {and, asc, count, desc, eq, gte, inArray, isNotNull, lte, type SQL} from 'drizzle-orm';
 import type {PgColumn} from 'drizzle-orm/pg-core';
 import type {TriggerDecision} from '#core/entities/decision.js';
 import type {
+  TriggerEventOrigin,
   TriggerEventOutcome,
+  TriggerEventReplay,
   TriggerReceivedEvent,
   TriggerReceivedEventSummary,
 } from '#core/entities/received-event.js';
@@ -24,7 +26,9 @@ export interface TriggerEventCursor {
 export interface TriggerEventListFilters {
   source?: string[] | undefined;
   event?: string[] | undefined;
+  origins?: TriggerEventOrigin[] | undefined;
   outcomes?: TriggerEventOutcome[] | undefined;
+  replayable?: boolean | undefined;
   from?: Date | undefined;
   to?: Date | undefined;
 }
@@ -53,8 +57,16 @@ function listConditions(params: ListTriggerEventsParams): SQL[] {
   if (filters?.source?.length)
     conditions.push(inArray(triggersReceivedEvents.source, filters.source));
   if (filters?.event?.length) conditions.push(inArray(triggersReceivedEvents.event, filters.event));
+  if (filters?.origins?.length)
+    conditions.push(inArray(triggersReceivedEvents.origin, filters.origins));
   if (filters?.outcomes?.length)
     conditions.push(inArray(triggersReceivedEvents.outcome, filters.outcomes));
+  // `replayable` is the picker's convenience filter: integration events with a
+  // stored payload are the only ones a dev run can replay.
+  if (filters?.replayable) {
+    conditions.push(eq(triggersReceivedEvents.origin, 'integration'));
+    conditions.push(isNotNull(triggersReceivedEvents.payload));
+  }
   if (filters?.from) conditions.push(gte(triggersReceivedEvents.receivedAt, filters.from));
   if (filters?.to) conditions.push(lte(triggersReceivedEvents.receivedAt, filters.to));
   return conditions;
@@ -97,6 +109,7 @@ export interface TriggerEventFacet {
 export interface ListTriggerEventFacetsResult {
   sources: TriggerEventFacet[];
   events: TriggerEventFacet[];
+  origins: TriggerEventFacet[];
 }
 
 // Distinct filter values for a workspace, capped so one noisy integration can't flood
@@ -119,11 +132,51 @@ async function listFacet(workspaceId: string, column: PgColumn): Promise<Trigger
 export async function listTriggerEventFacets(params: {
   workspaceId: string;
 }): Promise<ListTriggerEventFacetsResult> {
-  const [sources, events] = await Promise.all([
+  const [sources, events, origins] = await Promise.all([
     listFacet(params.workspaceId, triggersReceivedEvents.source),
     listFacet(params.workspaceId, triggersReceivedEvents.event),
+    listFacet(params.workspaceId, triggersReceivedEvents.origin),
   ]);
-  return {sources, events};
+  return {sources, events, origins};
+}
+
+// The workspace predicate mirrors the route's workspace gate: replay links are
+// deliberately FK-less, so the back-direction lookup must not surface a replay
+// row that another workspace's writer pointed at this event id.
+export async function listReplaysOfTriggerEvent(
+  eventId: string,
+  workspaceId: string,
+): Promise<TriggerEventReplay[]> {
+  const rows = await db()
+    .select({
+      id: triggersReceivedEvents.id,
+      receivedAt: triggersReceivedEvents.receivedAt,
+      outcome: triggersReceivedEvents.outcome,
+      runId: triggersDecisions.runId,
+    })
+    .from(triggersReceivedEvents)
+    .leftJoin(
+      triggersDecisions,
+      and(
+        eq(triggersDecisions.receivedEventId, triggersReceivedEvents.id),
+        eq(triggersDecisions.subscriptionKind, 'dev'),
+      ),
+    )
+    .where(
+      and(
+        eq(triggersReceivedEvents.replayOfEventId, eventId),
+        eq(triggersReceivedEvents.workspaceId, workspaceId),
+        eq(triggersReceivedEvents.origin, 'dev'),
+      ),
+    )
+    .orderBy(desc(triggersReceivedEvents.receivedAt), desc(triggersReceivedEvents.id));
+
+  return rows.map((row) => ({
+    id: row.id,
+    receivedAt: row.receivedAt,
+    outcome: row.outcome,
+    runId: row.runId,
+  }));
 }
 
 // `received_event_id` is a globally-unique uuid, so the parent-event lookup is the

package/src/db/index.ts

@@ -16,6 +16,7 @@ export {
   type ListTriggerEventsParams,
   type ListTriggerEventsResult,
   listDecisionsByReceivedEventId,
+  listReplaysOfTriggerEvent,
   listTriggerEventFacets,
   listTriggerEvents,
   type TriggerEventCursor,

package/src/db/job-listener-subscriptions.test.ts

@@ -5,7 +5,10 @@ import {jobListenerSubscriptions} from '#db/schema/job-listener-subscriptions.js
 import {onJobActivated} from '#presentation/subscribers/on-job-activated.js';
 import {onJobTerminated} from '#presentation/subscribers/on-job-terminated.js';
 import {jobListenerSubscriptionFactory} from '#test/index.js';
-import {findMatchingJobListenerSubscriptions} from './job-listener-subscriptions.js';
+import {
+  findMatchingJobListenerSubscriptions,
+  projectJobListenerSubscriptions,
+} from './job-listener-subscriptions.js';
 
 function buildActivatedPayload(
   overrides: Partial<WorkflowsJobActivatedEventDto> = {},
@@ -53,6 +56,60 @@ describe('job listener subscriptions', () => {
     });
   });
 
+  it('stores NULL for activated matchers with no event', async () => {
+    const jobId = crypto.randomUUID();
+    const workflowRunId = crypto.randomUUID();
+    const workspaceId = crypto.randomUUID();
+
+    await projectJobListenerSubscriptions({
+      workspaceId,
+      workflowRunId,
+      jobId,
+      on: [{source: 'github'}],
+      until: [{source: 'github'}],
+    });
+
+    const rows = await listJobSubscriptions(jobId);
+    expect(rows).toHaveLength(2);
+    expect(rows.map((row) => row.event)).toEqual([null, null]);
+  });
+
+  it.each(['', '   '])('rejects a blank matcher event %j', async (event) => {
+    const jobId = crypto.randomUUID();
+
+    await expect(
+      projectJobListenerSubscriptions({
+        workspaceId: crypto.randomUUID(),
+        workflowRunId: crypto.randomUUID(),
+        jobId,
+        on: [{source: 'github', event}],
+        until: null,
+      }),
+    ).rejects.toThrow('A github subscription event cannot be blank');
+  });
+
+  it('clears an exact matcher event to NULL when the matcher drops its event', async () => {
+    const jobId = crypto.randomUUID();
+    const workflowRunId = crypto.randomUUID();
+    const workspaceId = crypto.randomUUID();
+    const base = {workspaceId, workflowRunId, jobId};
+
+    await projectJobListenerSubscriptions({
+      ...base,
+      on: [{source: 'github', event: 'push'}],
+      until: null,
+    });
+    await projectJobListenerSubscriptions({
+      ...base,
+      on: [{source: 'github'}],
+      until: null,
+    });
+
+    const rows = await listJobSubscriptions(jobId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.event).toBeNull();
+  });
+
   it('does not project subscriptions for one-shot jobs', async () => {
     const payload = buildActivatedPayload({mode: 'one_shot'});
 
@@ -254,6 +311,81 @@ describe('job listener subscriptions', () => {
     expect(rows.map((row) => row.id)).toEqual([matching.id]);
   });
 
+  it('matches any event from the source for NULL-event on and until rows', async () => {
+    const workspaceId = crypto.randomUUID();
+    const jobId = crypto.randomUUID();
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      jobId,
+      kind: 'on',
+      matcherOrdinal: 0,
+      source: 'github',
+      event: null,
+    });
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      jobId,
+      kind: 'until',
+      matcherOrdinal: 0,
+      source: 'github',
+      event: null,
+    });
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      jobId,
+      kind: 'on',
+      matcherOrdinal: 1,
+      source: 'sentry',
+      event: null,
+    });
+
+    const rows = await findMatchingJobListenerSubscriptions({
+      workspaceId,
+      source: 'github',
+      event: 'push',
+    });
+
+    expect(rows.map((row) => [row.kind, row.matcherOrdinal]).sort()).toEqual([
+      ['on', 0],
+      ['until', 0],
+    ]);
+  });
+
+  it('keeps exact-event rows matching only their own event alongside NULL rows', async () => {
+    const workspaceId = crypto.randomUUID();
+    const jobId = crypto.randomUUID();
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      jobId,
+      kind: 'on',
+      matcherOrdinal: 0,
+      source: 'github',
+      event: null,
+    });
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      jobId,
+      kind: 'on',
+      matcherOrdinal: 1,
+      source: 'github',
+      event: 'push',
+    });
+
+    const pushRows = await findMatchingJobListenerSubscriptions({
+      workspaceId,
+      source: 'github',
+      event: 'push',
+    });
+    const prRows = await findMatchingJobListenerSubscriptions({
+      workspaceId,
+      source: 'github',
+      event: 'pull_request',
+    });
+
+    expect(pushRows.map((row) => row.matcherOrdinal).sort()).toEqual([0, 1]);
+    expect(prRows.map((row) => row.matcherOrdinal)).toEqual([0]);
+  });
+
   it('returns no subscriptions for a negative match', async () => {
     const workspaceId = crypto.randomUUID();
     await jobListenerSubscriptionFactory.create({

package/src/db/job-listener-subscriptions.ts

@@ -8,12 +8,13 @@ import {
   jobListenerSubscriptions,
   toJobListenerSubscription,
 } from './schema/job-listener-subscriptions.js';
+import {normalizeSubscriptionEvent, subscriptionEventCondition} from './subscription-event.js';
 
 type Tx = Parameters<Parameters<ReturnType<typeof db>['transaction']>[0]>[0];
 
 export interface ListenerMatcher {
   source: string;
-  event: string;
+  event?: string | undefined;
   inputs?: Readonly<Record<string, unknown>> | undefined;
   filter?: string | undefined;
   filter_snapshot?: Readonly<Record<string, unknown>> | undefined;
@@ -57,7 +58,7 @@ export async function projectJobListenerSubscriptions(
             kind,
             matcherOrdinal,
             source: matcher.source,
-            event: matcher.event,
+            event: normalizeSubscriptionEvent({source: matcher.source, event: matcher.event}),
             config,
           })
           .onConflictDoUpdate({
@@ -70,7 +71,7 @@ export async function projectJobListenerSubscriptions(
               workspaceId: params.workspaceId,
               workflowRunId: params.workflowRunId,
               source: matcher.source,
-              event: matcher.event,
+              event: normalizeSubscriptionEvent({source: matcher.source, event: matcher.event}),
               config,
             },
           });
@@ -130,7 +131,7 @@ export async function findMatchingJobListenerSubscriptions(
       and(
         eq(jobListenerSubscriptions.workspaceId, params.workspaceId),
         eq(jobListenerSubscriptions.source, params.source),
-        eq(jobListenerSubscriptions.event, params.event),
+        subscriptionEventCondition(jobListenerSubscriptions.event, params.event),
       ),
     );
   return rows.map(toJobListenerSubscription);

package/src/db/schema/decisions.test.ts

@@ -201,6 +201,92 @@ describe('triggers_decisions schema', () => {
     await expect(duplicate).rejects.toThrow();
   });
 
+  test('stores a dev decision with a null subscription id', async () => {
+    const receivedEventId = await insertEvent();
+    const [inserted] = await db()
+      .insert(triggersDecisions)
+      .values({
+        receivedEventId,
+        subscriptionKind: 'dev',
+        subscriptionId: null,
+        subscriptionName: 'on_issue',
+        workflowDefinitionId: crypto.randomUUID(),
+        decision: 'triggered',
+        runId: crypto.randomUUID(),
+        runName: 'Dev run',
+      })
+      .returning({id: triggersDecisions.id});
+    if (!inserted) throw new Error('insert returned no rows');
+    const [row] = await db()
+      .select()
+      .from(triggersDecisions)
+      .where(eq(triggersDecisions.id, inserted.id));
+    if (!row) throw new Error('select returned no rows');
+
+    expect(row.subscriptionKind).toBe('dev');
+    expect(row.subscriptionId).toBeNull();
+    expect(row.subscriptionName).toBe('on_issue');
+    expect(row.runId).not.toBeNull();
+    expect(row.runName).toBe('Dev run');
+    expect(toTriggerDecision(row)).toMatchObject({
+      subscriptionKind: 'dev',
+      subscriptionId: null,
+      decision: 'triggered',
+    });
+  });
+
+  test('the dev decision index rejects a second decision for the same event', async () => {
+    const receivedEventId = await insertEvent();
+    await db().insert(triggersDecisions).values({
+      receivedEventId,
+      subscriptionKind: 'dev',
+      subscriptionId: null,
+      subscriptionName: 'on_issue',
+      workflowDefinitionId: crypto.randomUUID(),
+      decision: 'triggered',
+      runId: crypto.randomUUID(),
+      runName: 'Dev run',
+    });
+    await expect(
+      db().insert(triggersDecisions).values({
+        receivedEventId,
+        subscriptionKind: 'dev',
+        subscriptionId: null,
+        subscriptionName: 'on_issue',
+        workflowDefinitionId: crypto.randomUUID(),
+        decision: 'filter-error',
+        reason: 'filter is false',
+      }),
+    ).rejects.toThrow();
+  });
+
+  test('enforces subscription ids by decision kind', async () => {
+    const receivedEventId = await insertEvent();
+
+    await expect(
+      db().insert(triggersDecisions).values({
+        receivedEventId,
+        subscriptionKind: 'trigger',
+        subscriptionId: null,
+        subscriptionName: 'Deploy production',
+        workflowDefinitionId: crypto.randomUUID(),
+        projectId: crypto.randomUUID(),
+        decision: 'triggered',
+      }),
+    ).rejects.toThrow();
+
+    await expect(
+      db().insert(triggersDecisions).values({
+        receivedEventId,
+        subscriptionKind: 'dev',
+        subscriptionId: crypto.randomUUID(),
+        subscriptionName: 'on_issue',
+        workflowDefinitionId: crypto.randomUUID(),
+        decision: 'triggered',
+      }),
+    ).rejects.toThrow();
+  });
+
   test('allows trigger and listener decisions with the same subscription id', async () => {
     const receivedEventId = await insertEvent();
     const subscriptionId = crypto.randomUUID();
@@ -234,11 +320,14 @@ describe('triggers_decisions schema', () => {
   });
 
   test('declares a database check for valid subscription kinds', () => {
-    const subscriptionKindCheck = getTableConfig(triggersDecisions).checks.find(
-      (check) => check.name === 'triggers_decisions_subscription_kind_ck',
-    );
+    const checkNames = getTableConfig(triggersDecisions).checks.map((check) => check.name);
 
-    expect(subscriptionKindCheck).toBeDefined();
+    expect(checkNames).toEqual(
+      expect.arrayContaining([
+        'triggers_decisions_subscription_kind_ck',
+        'triggers_decisions_subscription_id_ck',
+      ]),
+    );
   });
 
   test('maps listener identity fields', async () => {

package/src/db/schema/decisions.ts

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

package/src/db/schema/job-listener-subscriptions.ts

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

package/src/db/schema/received-events.test.ts

@@ -17,6 +17,7 @@ describe('toTriggerReceivedEvent', () => {
       provider: 'github',
       source: 'github',
       event: 'push',
+      replayOfEventId: '019e98ab-b90f-7265-b13c-8b441c991380',
       deliveryId: 'delivery-1',
       connectionId: '019e98ab-b90f-7265-b13c-8b441c991382',
       connectionName: 'Acme Production',
@@ -38,6 +39,7 @@ describe('toTriggerReceivedEvent', () => {
       provider: 'github',
       source: 'github',
       event: 'push',
+      replayOfEventId: '019e98ab-b90f-7265-b13c-8b441c991380',
       deliveryId: 'delivery-1',
       connectionId: row.connectionId,
       connectionName: 'Acme Production',
@@ -59,6 +61,7 @@ describe('toTriggerReceivedEvent', () => {
       provider: null,
       source: 'manual',
       event: 'fire',
+      replayOfEventId: null,
       deliveryId: null,
       connectionId: null,
       connectionName: null,
@@ -77,6 +80,7 @@ describe('toTriggerReceivedEvent', () => {
     expect(result.connectionName).toBeNull();
     expect(result.payload).toBeNull();
     expect(result.processedAt).toBeNull();
+    expect(result.replayOfEventId).toBeNull();
   });
 });
 
@@ -132,4 +136,45 @@ describe('triggers_received_events schema', () => {
 
     await expect(duplicate).rejects.toThrow();
   });
+
+  test('stores a dev origin with a replay_of_event_id link', async () => {
+    const source = await db()
+      .insert(triggersReceivedEvents)
+      .values({
+        eventRef: crypto.randomUUID(),
+        origin: 'integration',
+        workspaceId: crypto.randomUUID(),
+        source: 'github',
+        event: 'push',
+        receivedAt: new Date(),
+      })
+      .returning({id: triggersReceivedEvents.id});
+    if (!source[0]) throw new Error('insert returned no rows');
+
+    const values: TriggerReceivedEventInsertDb = {
+      eventRef: crypto.randomUUID(),
+      origin: 'dev',
+      workspaceId: crypto.randomUUID(),
+      source: 'github',
+      event: 'push',
+      replayOfEventId: source[0].id,
+      payload: {ref: 'refs/heads/main'},
+      receivedAt: new Date(),
+    };
+    const [inserted] = await db()
+      .insert(triggersReceivedEvents)
+      .values(values)
+      .returning({id: triggersReceivedEvents.id});
+    if (!inserted) throw new Error('insert returned no rows');
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, inserted.id));
+
+    expect(row?.origin).toBe('dev');
+    expect(row?.replayOfEventId).toBe(source[0].id);
+    expect(toTriggerReceivedEvent(row as TriggerReceivedEventDb).replayOfEventId).toBe(
+      source[0].id,
+    );
+  });
 });

package/src/db/schema/received-events.ts

@@ -1,4 +1,5 @@
 import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {sql} from 'drizzle-orm';
 import {index, integer, jsonb, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
 import {
   type TriggerReceivedEvent,
@@ -21,6 +22,9 @@ export const triggersReceivedEvents = pgTable(
     provider: text('provider'),
     source: text('source').notNull(),
     event: text('event').notNull(),
+    // Source event this entry replays (dev runs only); no foreign key: the
+    // source row may be pruned while its replay link must stay.
+    replayOfEventId: uuid('replay_of_event_id'),
     deliveryId: text('delivery_id'),
     connectionId: uuid('connection_id'),
     connectionName: text('connection_name'),
@@ -38,9 +42,14 @@ export const triggersReceivedEvents = pgTable(
       table.receivedAt.desc(),
     ),
     index('triggers_received_events_prune_idx').on(table.createdAt),
-    // Back the workspace-scoped facet group-by (distinct source / event values).
+    // Back the workspace-scoped facet group-by (distinct source / event / origin values).
     index('triggers_received_events_workspace_source_idx').on(table.workspaceId, table.source),
     index('triggers_received_events_workspace_event_idx').on(table.workspaceId, table.event),
+    index('triggers_received_events_workspace_origin_idx').on(table.workspaceId, table.origin),
+    // Back the replay link direction: which events replayed a given source event.
+    index('triggers_received_events_replay_of_event_id_idx')
+      .on(table.replayOfEventId)
+      .where(sql`${table.replayOfEventId} IS NOT NULL`),
   ],
 );
 
@@ -56,6 +65,7 @@ export function toTriggerReceivedEvent(row: TriggerReceivedEventDb): TriggerRece
     provider: row.provider,
     source: row.source,
     event: row.event,
+    replayOfEventId: row.replayOfEventId,
     deliveryId: row.deliveryId,
     connectionId: row.connectionId,
     connectionName: row.connectionName,
@@ -76,6 +86,7 @@ export const triggerReceivedEventSummaryColumns = {
   provider: triggersReceivedEvents.provider,
   source: triggersReceivedEvents.source,
   event: triggersReceivedEvents.event,
+  replayOfEventId: triggersReceivedEvents.replayOfEventId,
   deliveryId: triggersReceivedEvents.deliveryId,
   connectionId: triggersReceivedEvents.connectionId,
   connectionName: triggersReceivedEvents.connectionName,