@shipfox/api-triggers 13.0.0 → 14.0.0

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

@@ -2,8 +2,16 @@ import {requireWorkspaceResourceAccess} from '@shipfox/api-auth-context';
 import {triggerEventDetailResponseSchema} from '@shipfox/api-triggers-dto';
 import {ClientError, defineRoute} from '@shipfox/node-fastify';
 import {z} from 'zod';
-import {getTriggerEventById, listDecisionsByReceivedEventId} from '#db/index.js';
-import {toTriggerDecisionDto, toTriggerEventDto} from '#presentation/dto/trigger-events.js';
+import {
+  getTriggerEventById,
+  listDecisionsByReceivedEventId,
+  listReplaysOfTriggerEvent,
+} from '#db/index.js';
+import {
+  toTriggerDecisionDto,
+  toTriggerEventDto,
+  toTriggerEventReplayDto,
+} from '#presentation/dto/trigger-events.js';
 
 export const getTriggerEventRoute = defineRoute({
   method: 'GET',
@@ -32,11 +40,15 @@ export const getTriggerEventRoute = defineRoute({
       notFoundError: new ClientError('Trigger event not found', 'not-found', {status: 404}),
     });
 
-    const decisions = await listDecisionsByReceivedEventId(event.id);
+    const [decisions, replays] = await Promise.all([
+      listDecisionsByReceivedEventId(event.id),
+      listReplaysOfTriggerEvent(event.id, event.workspaceId),
+    ]);
 
     return {
       ...toTriggerEventDto(event),
       decisions: decisions.map(toTriggerDecisionDto),
+      replays: replays.map(toTriggerEventReplayDto),
     };
   },
 });

package/src/presentation/routes/list-trigger-event-facets.test.ts

@@ -7,7 +7,11 @@ import {receivedEventFactory} from '#test/index.js';
 import {listTriggerEventFacetsRoute} from './list-trigger-event-facets.js';
 
 const facets = (res: {
-  json: () => {sources: TriggerEventFacetItemDto[]; events: TriggerEventFacetItemDto[]};
+  json: () => {
+    sources: TriggerEventFacetItemDto[];
+    events: TriggerEventFacetItemDto[];
+    origins: TriggerEventFacetItemDto[];
+  };
 }) => res.json();
 
 describe('GET /trigger-events/facets', () => {
@@ -60,6 +64,39 @@ describe('GET /trigger-events/facets', () => {
     ]);
   });
 
+  test('returns distinct origins with counts, ordered by count desc', async () => {
+    await receivedEventFactory.create({workspaceId, source: 'github', event: 'push'});
+    await receivedEventFactory.create({
+      workspaceId,
+      origin: 'dev',
+      source: 'github',
+      event: 'push',
+    });
+    await receivedEventFactory.create({
+      workspaceId,
+      origin: 'dev',
+      source: 'github',
+      event: 'push',
+    });
+    await receivedEventFactory.create({
+      workspaceId,
+      origin: 'manual',
+      source: 'manual',
+      event: 'fire',
+    });
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events/facets?workspace_id=${workspaceId}`,
+    });
+
+    expect(facets(res).origins).toEqual([
+      {value: 'dev', count: 2},
+      {value: 'integration', count: 1},
+      {value: 'manual', count: 1},
+    ]);
+  });
+
   test('caps each facet at the top 50 values by count', async () => {
     await Promise.all(
       Array.from({length: 51}, (_, index) =>
@@ -94,7 +131,7 @@ describe('GET /trigger-events/facets', () => {
     });
 
     expect(res.statusCode).toBe(200);
-    expect(res.json()).toEqual({sources: [], events: []});
+    expect(res.json()).toEqual({sources: [], events: [], origins: []});
   });
 
   test('returns workspace-suspended for a suspended membership claim', async () => {

package/src/presentation/routes/list-trigger-event-facets.ts

@@ -9,7 +9,7 @@ import {listTriggerEventFacets} from '#db/index.js';
 export const listTriggerEventFacetsRoute = defineRoute({
   method: 'GET',
   path: '/facets',
-  description: 'Distinct source and event filter values (with counts) for a workspace.',
+  description: 'Distinct source, event, and origin filter values (with counts) for a workspace.',
   schema: {
     querystring: triggerEventFacetsQuerySchema,
     response: {

package/src/presentation/routes/list-trigger-events.test.ts

@@ -171,6 +171,105 @@ describe('GET /trigger-events', () => {
     expect(eventIds(res)).toEqual([discarded.id]);
   });
 
+  test('filters by origin', async () => {
+    const integration = await receivedEventFactory.create({workspaceId, origin: 'integration'});
+    await receivedEventFactory.create({workspaceId, origin: 'manual'});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&origin=integration`,
+    });
+
+    expect(eventIds(res)).toEqual([integration.id]);
+  });
+
+  test('filters by repeated origin keys (IN-list)', async () => {
+    const dev = await receivedEventFactory.create({workspaceId, origin: 'dev'});
+    const manual = await receivedEventFactory.create({workspaceId, origin: 'manual'});
+    await receivedEventFactory.create({workspaceId, origin: 'integration'});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&origin=dev&origin=manual`,
+    });
+
+    expect(eventIds(res).sort()).toEqual([dev.id, manual.id].sort());
+  });
+
+  test('filters by comma-separated origins', async () => {
+    const dev = await receivedEventFactory.create({workspaceId, origin: 'dev'});
+    const manual = await receivedEventFactory.create({workspaceId, origin: 'manual'});
+    await receivedEventFactory.create({workspaceId, origin: 'integration'});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&origin=dev,manual`,
+    });
+
+    expect(eventIds(res).sort()).toEqual([dev.id, manual.id].sort());
+  });
+
+  test('rejects an unknown origin value', async () => {
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&origin=bogus`,
+    });
+
+    expect(res.statusCode).toBe(400);
+  });
+
+  test('filters replayable events to integration events with a stored payload', async () => {
+    const replayable = await receivedEventFactory.create({
+      workspaceId,
+      origin: 'integration',
+      payload: {ref: 'refs/heads/main'},
+    });
+    // A pruned integration event keeps its origin but lost its payload.
+    await receivedEventFactory.create({workspaceId, origin: 'integration', payload: null});
+    // A dev replay row carries a payload but is not itself replayable.
+    await receivedEventFactory.create({workspaceId, origin: 'dev', payload: {ref: 'main'}});
+    await receivedEventFactory.create({workspaceId, origin: 'manual', payload: {}});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&replayable=true`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(eventIds(res)).toEqual([replayable.id]);
+  });
+
+  test('rejects a non-true replayable value', async () => {
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&replayable=false`,
+    });
+
+    expect(res.statusCode).toBe(400);
+  });
+
+  test('exposes replay_of_event_id on list items', async () => {
+    const source = await receivedEventFactory.create({workspaceId});
+    const replay = await receivedEventFactory.create({
+      workspaceId,
+      origin: 'dev',
+      source: 'github',
+      event: 'push',
+      replayOfEventId: source.id,
+    });
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}`,
+    });
+
+    const items = res.json().trigger_events;
+    expect(items.find((item: {id: string}) => item.id === replay.id).replay_of_event_id).toBe(
+      source.id,
+    );
+    expect(items.find((item: {id: string}) => item.id === source.id).replay_of_event_id).toBeNull();
+  });
+
   test('filters and serializes the errored outcome', async () => {
     const errored = await receivedEventFactory.create({workspaceId, outcome: 'errored'});
 

package/src/presentation/routes/list-trigger-events.ts

@@ -23,7 +23,9 @@ export const listTriggerEventsRoute = defineRoute({
       workspace_id: workspaceId,
       source,
       event,
+      origin: origins,
       outcome: outcomes,
+      replayable,
       from,
       to,
       limit,
@@ -46,7 +48,9 @@ export const listTriggerEventsRoute = defineRoute({
       filters: {
         source,
         event,
+        origins,
         outcomes,
+        replayable,
         from: from ? new Date(from) : undefined,
         to: to ? new Date(to) : undefined,
       },

package/test/factories/received-event.ts

@@ -14,6 +14,7 @@ export const receivedEventFactory = Factory.define<TriggerReceivedEvent>(({seque
         provider: event.provider,
         source: event.source,
         event: event.event,
+        replayOfEventId: event.replayOfEventId,
         deliveryId: event.deliveryId,
         connectionId: event.connectionId,
         connectionName: event.connectionName,
@@ -36,6 +37,7 @@ export const receivedEventFactory = Factory.define<TriggerReceivedEvent>(({seque
     provider: 'github',
     source: 'github',
     event: 'push',
+    replayOfEventId: null,
     deliveryId: crypto.randomUUID(),
     connectionId: crypto.randomUUID(),
     connectionName: 'Acme Production',