@shipfox/api-triggers 13.0.0 → 14.0.0

package/src/db/schema/subscriptions.ts

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

package/src/db/subscription-event.ts

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

package/src/db/subscriptions.test.ts

@@ -55,6 +55,80 @@ describe('projectDefinitionTriggers', () => {
     });
   });
 
+  test('stores NULL for a trigger with no event', async () => {
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId,
+      triggers: {
+        on_any: {source: 'github'},
+      },
+    });
+
+    const rows = await db()
+      .select()
+      .from(triggerSubscriptions)
+      .where(eq(triggerSubscriptions.workflowDefinitionId, workflowDefinitionId));
+
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.source).toBe('github');
+    expect(rows[0]?.event).toBeNull();
+  });
+
+  test.each(['', '   '])('rejects a blank integration trigger event %j', async (event) => {
+    await expect(
+      projectDefinitionTriggers({
+        workspaceId,
+        projectId,
+        workflowDefinitionId,
+        triggers: {
+          invalid: {source: 'github', event},
+        },
+      }),
+    ).rejects.toThrow('A github subscription event cannot be blank');
+  });
+
+  test.each(['manual', 'cron'] as const)('rejects a blank %s trigger event', async (source) => {
+    await expect(
+      projectDefinitionTriggers({
+        workspaceId,
+        projectId,
+        workflowDefinitionId,
+        triggers: {
+          invalid: {source},
+        },
+      }),
+    ).rejects.toThrow(`A ${source} subscription requires an event`);
+  });
+
+  test('clears an exact event to NULL when a trigger drops its event across reconciliations', async () => {
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId,
+      triggers: {
+        on_push: {source: 'github', event: 'push'},
+      },
+    });
+
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId,
+      triggers: {
+        on_push: {source: 'github'},
+      },
+    });
+
+    const rows = await db()
+      .select()
+      .from(triggerSubscriptions)
+      .where(eq(triggerSubscriptions.workflowDefinitionId, workflowDefinitionId));
+
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.event).toBeNull();
+  });
+
   test('removes rows whose trigger name is no longer in the map', async () => {
     await projectDefinitionTriggers({
       workspaceId,
@@ -196,6 +270,69 @@ describe('findMatchingSubscriptions', () => {
     expect(matches[0]?.name).toBe('on_push');
   });
 
+  test('a NULL event subscription matches any event from its source and none from another source', async () => {
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId: crypto.randomUUID(),
+      triggers: {
+        on_any: {source: 'github'},
+      },
+    });
+
+    const pushMatches = await findMatchingSubscriptions({
+      workspaceId,
+      source: 'github',
+      event: 'push',
+    });
+    const prMatches = await findMatchingSubscriptions({
+      workspaceId,
+      source: 'github',
+      event: 'pull_request',
+    });
+    const otherSourceMatches = await findMatchingSubscriptions({
+      workspaceId,
+      source: 'sentry',
+      event: 'push',
+    });
+    const otherWorkspaceMatches = await findMatchingSubscriptions({
+      workspaceId: crypto.randomUUID(),
+      source: 'github',
+      event: 'push',
+    });
+
+    expect(pushMatches.map((match) => match.name)).toEqual(['on_any']);
+    expect(prMatches.map((match) => match.name)).toEqual(['on_any']);
+    expect(otherSourceMatches).toHaveLength(0);
+    expect(otherWorkspaceMatches).toHaveLength(0);
+  });
+
+  test('exact-event subscriptions are unaffected by NULL event rows', async () => {
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId: crypto.randomUUID(),
+      triggers: {
+        on_any: {source: 'github'},
+        on_push: {source: 'github', event: 'push'},
+      },
+    });
+
+    const pushMatches = await findMatchingSubscriptions({
+      workspaceId,
+      source: 'github',
+      event: 'push',
+    });
+    const prMatches = await findMatchingSubscriptions({
+      workspaceId,
+      source: 'github',
+      event: 'pull_request',
+    });
+
+    expect(pushMatches.map((match) => match.name).sort()).toEqual(['on_any', 'on_push']);
+    expect(prMatches.map((match) => match.name)).toEqual(['on_any']);
+  });
+
   test('matches connection-specific sources, not the provider id', async () => {
     await projectDefinitionTriggers({
       workspaceId,

package/src/db/subscriptions.ts

@@ -4,13 +4,18 @@ import type {TriggerSubscription} from '#core/entities/subscription.js';
 import {deleteCronScheduleForSubscription, syncCronSchedule} from './cron-schedules.js';
 import {db, type Executor, type Tx} from './db.js';
 import {toTriggerSubscription, triggerSubscriptions} from './schema/subscriptions.js';
+import {normalizeSubscriptionEvent, subscriptionEventCondition} from './subscription-event.js';
+
+interface ProjectDefinitionTrigger extends Omit<TriggerDto, 'event'> {
+  event?: string | undefined;
+}
 
 export interface ProjectDefinitionTriggersParams {
   tx?: Tx | undefined;
   workspaceId: string;
   projectId: string;
   workflowDefinitionId: string;
-  triggers: Record<string, TriggerDto>;
+  triggers: Record<string, ProjectDefinitionTrigger>;
 }
 
 export async function projectDefinitionTriggers(
@@ -49,7 +54,7 @@ export async function projectDefinitionTriggers(
           workflowDefinitionId: params.workflowDefinitionId,
           name,
           source: trigger.source,
-          event: trigger.event,
+          event: normalizeSubscriptionEvent({source: trigger.source, event: trigger.event}),
           config,
         })
         .onConflictDoUpdate({
@@ -58,7 +63,7 @@ export async function projectDefinitionTriggers(
             workspaceId: params.workspaceId,
             projectId: params.projectId,
             source: trigger.source,
-            event: trigger.event,
+            event: normalizeSubscriptionEvent({source: trigger.source, event: trigger.event}),
             config,
             updatedAt: new Date(),
           },
@@ -161,7 +166,7 @@ export async function findMatchingSubscriptions(
       and(
         eq(triggerSubscriptions.workspaceId, params.workspaceId),
         eq(triggerSubscriptions.source, params.source),
-        eq(triggerSubscriptions.event, params.event),
+        subscriptionEventCondition(triggerSubscriptions.event, params.event),
       ),
     );
   return rows.map(toTriggerSubscription);

package/src/presentation/dto/trigger-events.test.ts

@@ -1,3 +1,12 @@
+import {
+  triggerDecisionDtoSchema,
+  triggerDecisionSubscriptionKindSchema,
+  triggerEventDetailResponseSchema,
+  triggerEventFacetsResponseSchema,
+  triggerEventListQuerySchema,
+  triggerEventOriginSchema,
+  triggerEventReplayDtoSchema,
+} from '@shipfox/api-triggers-dto';
 import type {TriggerDecision} from '#core/entities/decision.js';
 import type {
   TriggerReceivedEvent,
@@ -7,6 +16,7 @@ import {
   toTriggerDecisionDto,
   toTriggerEventDto,
   toTriggerEventListItemDto,
+  toTriggerEventReplayDto,
 } from './trigger-events.js';
 
 const baseSummary: TriggerReceivedEventSummary = {
@@ -17,6 +27,7 @@ const baseSummary: TriggerReceivedEventSummary = {
   provider: null,
   source: 'manual',
   event: 'fire',
+  replayOfEventId: null,
   deliveryId: null,
   connectionId: null,
   connectionName: null,
@@ -39,6 +50,7 @@ describe('trigger-events mappers', () => {
       provider: null,
       source: 'manual',
       event: 'fire',
+      replay_of_event_id: null,
       delivery_id: null,
       connection_id: null,
       outcome: 'discarded',
@@ -50,6 +62,13 @@ describe('trigger-events mappers', () => {
     expect(dto).not.toHaveProperty('payload');
   });
 
+  test('toTriggerEventListItemDto maps replay_of_event_id', () => {
+    const replayOfEventId = '99999999-9999-4999-8999-999999999999';
+    const dto = toTriggerEventListItemDto({...baseSummary, replayOfEventId});
+
+    expect(dto.replay_of_event_id).toBe(replayOfEventId);
+  });
+
   test('toTriggerEventDto carries the payload (including null)', () => {
     const withPayload: TriggerReceivedEvent = {...baseSummary, payload: {ref: 'main'}};
     const withoutPayload: TriggerReceivedEvent = {...baseSummary, payload: null};
@@ -141,4 +160,178 @@ describe('trigger-events mappers', () => {
       decision: 'triggered',
     });
   });
+
+  test('toTriggerEventReplayDto maps null run ids and ISO dates', () => {
+    expect(
+      toTriggerEventReplayDto({
+        id: '99999999-9999-4999-8999-999999999999',
+        receivedAt: new Date('2026-05-07T00:00:02.000Z'),
+        outcome: 'routed',
+        runId: '77777777-7777-4777-8777-777777777777',
+      }),
+    ).toEqual({
+      id: '99999999-9999-4999-8999-999999999999',
+      received_at: '2026-05-07T00:00:02.000Z',
+      outcome: 'routed',
+      run_id: '77777777-7777-4777-8777-777777777777',
+    });
+    expect(
+      toTriggerEventReplayDto({
+        id: '99999999-9999-4999-8999-999999999999',
+        receivedAt: new Date('2026-05-07T00:00:02.000Z'),
+        outcome: 'discarded',
+        runId: null,
+      }).run_id,
+    ).toBeNull();
+  });
+});
+
+describe('trigger event DTO contract', () => {
+  const baseDecision = {
+    id: '33333333-3333-4333-8333-333333333333',
+    received_event_id: '11111111-1111-4111-8111-111111111111',
+    subscription_kind: 'trigger',
+    subscription_id: '44444444-4444-4444-4444-444444444444',
+    subscription_name: 'Deploy production',
+    workflow_definition_id: '55555555-5555-5555-8555-555555555555',
+    project_id: '66666666-6666-6666-8666-666666666666',
+    workflow_run_id: null,
+    job_id: null,
+    matcher_kind: null,
+    matcher_ordinal: null,
+    decision: 'triggered',
+    run_id: '77777777-7777-4777-8777-777777777777',
+    run_name: 'Dev run',
+    reason: null,
+    created_at: '2026-05-07T00:00:02.000Z',
+  };
+
+  test('accepts dev origins and decisions with a null subscription id', () => {
+    expect(triggerEventOriginSchema.safeParse('dev').success).toBe(true);
+    expect(triggerDecisionSubscriptionKindSchema.safeParse('dev').success).toBe(true);
+    expect(
+      triggerDecisionDtoSchema.safeParse({
+        ...baseDecision,
+        subscription_kind: 'dev',
+        subscription_id: null,
+      }).success,
+    ).toBe(true);
+  });
+
+  test('requires subscription ids for trigger and listener decisions', () => {
+    for (const subscription_kind of ['trigger', 'listener'] as const) {
+      expect(
+        triggerDecisionDtoSchema.safeParse({
+          ...baseDecision,
+          subscription_kind,
+          subscription_id: null,
+        }).success,
+      ).toBe(false);
+    }
+  });
+
+  test('requires dev decisions to omit a subscription id', () => {
+    expect(
+      triggerDecisionDtoSchema.safeParse({
+        ...baseDecision,
+        subscription_kind: 'dev',
+        subscription_id: baseDecision.subscription_id,
+      }).success,
+    ).toBe(false);
+  });
+
+  test('rejects unknown origin and decision kinds', () => {
+    expect(triggerEventOriginSchema.safeParse('unknown').success).toBe(false);
+    expect(triggerDecisionSubscriptionKindSchema.safeParse('unknown').success).toBe(false);
+  });
+
+  const baseQuery = {
+    workspace_id: '22222222-2222-4222-8222-222222222222',
+  };
+
+  test('list query accepts origin as a single, repeated, or comma-separated filter', () => {
+    expect(triggerEventListQuerySchema.parse({...baseQuery, origin: 'dev'}).origin).toEqual([
+      'dev',
+    ]);
+    expect(
+      triggerEventListQuerySchema.parse({...baseQuery, origin: ['dev', 'manual']}).origin,
+    ).toEqual(['dev', 'manual']);
+    expect(triggerEventListQuerySchema.parse({...baseQuery, origin: 'dev,manual'}).origin).toEqual([
+      'dev',
+      'manual',
+    ]);
+  });
+
+  test('list query rejects an unknown origin filter value', () => {
+    expect(triggerEventListQuerySchema.safeParse({...baseQuery, origin: 'bogus'}).success).toBe(
+      false,
+    );
+  });
+
+  test('list query accepts replayable=true only', () => {
+    expect(triggerEventListQuerySchema.parse({...baseQuery, replayable: 'true'})).toMatchObject({
+      replayable: true,
+    });
+    expect(triggerEventListQuerySchema.parse(baseQuery).replayable).toBeUndefined();
+    expect(triggerEventListQuerySchema.safeParse({...baseQuery, replayable: 'false'}).success).toBe(
+      false,
+    );
+    expect(triggerEventListQuerySchema.safeParse({...baseQuery, replayable: 'yes'}).success).toBe(
+      false,
+    );
+  });
+
+  test('detail response accepts replay_of_event_id and a replays list', () => {
+    const detail = {
+      id: '11111111-1111-4111-8111-111111111111',
+      event_ref: 'event-ref',
+      origin: 'dev',
+      workspace_id: '22222222-2222-4222-8222-222222222222',
+      provider: null,
+      source: 'github',
+      event: 'push',
+      replay_of_event_id: '99999999-9999-4999-8999-999999999999',
+      delivery_id: null,
+      connection_id: null,
+      connection_name: null,
+      outcome: 'routed',
+      matched_count: 1,
+      payload: {ref: 'refs/heads/main'},
+      received_at: '2026-05-07T00:00:00.000Z',
+      processed_at: null,
+      created_at: '2026-05-07T00:00:01.000Z',
+      decisions: [],
+      replays: [
+        {
+          id: '99999999-9999-4999-8999-999999999999',
+          received_at: '2026-05-07T00:00:02.000Z',
+          outcome: 'routed',
+          run_id: '77777777-7777-4777-8777-777777777777',
+        },
+      ],
+    };
+
+    const parsed = triggerEventDetailResponseSchema.parse(detail);
+    expect(parsed.replay_of_event_id).toBe(detail.replay_of_event_id);
+    expect(parsed.replays).toEqual(detail.replays);
+    expect(triggerEventReplayDtoSchema.safeParse(detail.replays[0]).success).toBe(true);
+    expect(
+      triggerEventReplayDtoSchema.safeParse({...detail.replays[0], run_id: null}).success,
+    ).toBe(true);
+  });
+
+  test('facets response accepts origins', () => {
+    const parsed = triggerEventFacetsResponseSchema.parse({
+      sources: [{value: 'github', count: 2}],
+      events: [{value: 'push', count: 2}],
+      origins: [
+        {value: 'integration', count: 2},
+        {value: 'dev', count: 1},
+      ],
+    });
+    expect(parsed.origins).toEqual([
+      {value: 'integration', count: 2},
+      {value: 'dev', count: 1},
+    ]);
+  });
 });

package/src/presentation/dto/trigger-events.ts

@@ -2,9 +2,11 @@ import type {
   TriggerDecisionDto,
   TriggerEventDto,
   TriggerEventListItemDto,
+  TriggerEventReplayDto,
 } from '@shipfox/api-triggers-dto';
 import type {TriggerDecision} from '#core/entities/decision.js';
 import type {
+  TriggerEventReplay,
   TriggerReceivedEvent,
   TriggerReceivedEventSummary,
 } from '#core/entities/received-event.js';
@@ -20,6 +22,7 @@ export function toTriggerEventListItemDto(
     provider: event.provider,
     source: event.source,
     event: event.event,
+    replay_of_event_id: event.replayOfEventId,
     delivery_id: event.deliveryId,
     connection_id: event.connectionId,
     outcome: event.outcome,
@@ -38,6 +41,15 @@ export function toTriggerEventDto(event: TriggerReceivedEvent): TriggerEventDto
   };
 }
 
+export function toTriggerEventReplayDto(replay: TriggerEventReplay): TriggerEventReplayDto {
+  return {
+    id: replay.id,
+    received_at: replay.receivedAt.toISOString(),
+    outcome: replay.outcome,
+    run_id: replay.runId,
+  };
+}
+
 export function toTriggerDecisionDto(decision: TriggerDecision): TriggerDecisionDto {
   return {
     id: decision.id,

package/src/presentation/routes/get-trigger-event.test.ts

@@ -151,6 +151,185 @@ describe('GET /trigger-events/:id', () => {
     );
   });
 
+  test('serializes a dev decision with a null subscription id', async () => {
+    const event = await receivedEventFactory.create({
+      workspaceId,
+      origin: 'dev',
+      source: 'dev',
+      event: 'replay',
+      outcome: 'routed',
+      matchedCount: 1,
+    });
+    await decisionFactory.create({
+      receivedEventId: event.id,
+      subscriptionKind: 'dev',
+      subscriptionId: null,
+      subscriptionName: 'on_issue',
+      workflowDefinitionId: crypto.randomUUID(),
+      projectId: null,
+      decision: 'filter-error',
+      runId: null,
+      runName: null,
+      reason: 'filter is false',
+    });
+
+    const res = await app.inject({method: 'GET', url: `/trigger-events/${event.id}`});
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toMatchObject({
+      origin: 'dev',
+      replay_of_event_id: null,
+      replays: [],
+      decisions: [
+        {
+          subscription_kind: 'dev',
+          subscription_id: null,
+          decision: 'filter-error',
+          reason: 'filter is false',
+        },
+      ],
+    });
+  });
+
+  test('returns replay_of_event_id on a dev event that replayed a source event', async () => {
+    const source = await receivedEventFactory.create({workspaceId});
+    const replay = await receivedEventFactory.create({
+      workspaceId,
+      origin: 'dev',
+      source: 'github',
+      event: 'push',
+      replayOfEventId: source.id,
+      payload: {ref: 'refs/heads/main'},
+    });
+    await decisionFactory.create({
+      receivedEventId: replay.id,
+      subscriptionKind: 'dev',
+      subscriptionId: null,
+      subscriptionName: 'on_push',
+      workflowDefinitionId: crypto.randomUUID(),
+      projectId: null,
+      decision: 'triggered',
+      runId: crypto.randomUUID(),
+      runName: 'dev-replay',
+    });
+
+    const res = await app.inject({method: 'GET', url: `/trigger-events/${replay.id}`});
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toMatchObject({
+      origin: 'dev',
+      replay_of_event_id: source.id,
+      source: 'github',
+      event: 'push',
+    });
+  });
+
+  test('returns the replays list of dev events that replayed the event', async () => {
+    const source = await receivedEventFactory.create({workspaceId});
+    const runId = crypto.randomUUID();
+    const replay = await receivedEventFactory.create({
+      workspaceId,
+      origin: 'dev',
+      source: 'github',
+      event: 'push',
+      replayOfEventId: source.id,
+      outcome: 'routed',
+      matchedCount: 1,
+      receivedAt: new Date('2026-05-07T00:00:00.000Z'),
+    });
+    await decisionFactory.create({
+      receivedEventId: replay.id,
+      subscriptionKind: 'dev',
+      subscriptionId: null,
+      subscriptionName: 'on_push',
+      workflowDefinitionId: crypto.randomUUID(),
+      projectId: null,
+      decision: 'triggered',
+      runId,
+      runName: 'dev-replay',
+    });
+
+    const res = await app.inject({method: 'GET', url: `/trigger-events/${source.id}`});
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().replays).toEqual([
+      {
+        id: replay.id,
+        received_at: '2026-05-07T00:00:00.000Z',
+        outcome: 'routed',
+        run_id: runId,
+      },
+    ]);
+  });
+
+  test('replays list carries null run ids and the outcome for refused replays', async () => {
+    const source = await receivedEventFactory.create({workspaceId});
+    const refused = await receivedEventFactory.create({
+      workspaceId,
+      origin: 'dev',
+      source: 'github',
+      event: 'push',
+      replayOfEventId: source.id,
+      outcome: 'discarded',
+      matchedCount: 0,
+      receivedAt: new Date('2026-05-07T01:00:00.000Z'),
+    });
+    await decisionFactory.create({
+      receivedEventId: refused.id,
+      subscriptionKind: 'dev',
+      subscriptionId: null,
+      subscriptionName: 'on_push',
+      workflowDefinitionId: crypto.randomUUID(),
+      projectId: null,
+      decision: 'filter-error',
+      runId: null,
+      runName: null,
+      reason: 'filter is false',
+    });
+
+    const res = await app.inject({method: 'GET', url: `/trigger-events/${source.id}`});
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().replays).toEqual([
+      {
+        id: refused.id,
+        received_at: '2026-05-07T01:00:00.000Z',
+        outcome: 'discarded',
+        run_id: null,
+      },
+    ]);
+  });
+
+  test('does not surface replays from another workspace', async () => {
+    const source = await receivedEventFactory.create({workspaceId});
+    await receivedEventFactory.create({
+      workspaceId: crypto.randomUUID(),
+      origin: 'dev',
+      source: 'github',
+      event: 'push',
+      replayOfEventId: source.id,
+    });
+
+    const res = await app.inject({method: 'GET', url: `/trigger-events/${source.id}`});
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().replays).toEqual([]);
+  });
+
+  test('does not surface non-dev events with a replay link', async () => {
+    const source = await receivedEventFactory.create({workspaceId});
+    await receivedEventFactory.create({
+      workspaceId,
+      origin: 'integration',
+      replayOfEventId: source.id,
+    });
+
+    const res = await app.inject({method: 'GET', url: `/trigger-events/${source.id}`});
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().replays).toEqual([]);
+  });
+
   test('returns an empty decisions list for a discarded event', async () => {
     const event = await receivedEventFactory.create({
       workspaceId,