@shipfox/api-triggers 2.0.0

package/src/presentation/routes/index.ts

@@ -0,0 +1,21 @@
+import {AUTH_USER} from '@shipfox/api-auth-context';
+import type {RouteGroup} from '@shipfox/node-fastify';
+import {fireManualTriggerRoute} from './fire-manual.js';
+import {getTriggerEventRoute} from './get-trigger-event.js';
+import {listTriggerEventFacetsRoute} from './list-trigger-event-facets.js';
+import {listTriggerEventsRoute} from './list-trigger-events.js';
+
+export const triggerRoutes: RouteGroup[] = [
+  {
+    prefix: '/workflow-definitions',
+    auth: AUTH_USER,
+    routes: [fireManualTriggerRoute],
+  },
+  {
+    // The static /facets path is matched ahead of the /:id detail route by Fastify's
+    // radix router, so registration order does not affect resolution.
+    prefix: '/trigger-events',
+    auth: AUTH_USER,
+    routes: [listTriggerEventFacetsRoute, listTriggerEventsRoute, getTriggerEventRoute],
+  },
+];

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

@@ -0,0 +1,116 @@
+import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
+import type {TriggerEventFacetItemDto} from '@shipfox/api-triggers-dto';
+import type {FastifyInstance} from 'fastify';
+import Fastify from 'fastify';
+import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
+import {receivedEventFactory} from '#test/index.js';
+import {listTriggerEventFacetsRoute} from './list-trigger-event-facets.js';
+
+const facets = (res: {
+  json: () => {sources: TriggerEventFacetItemDto[]; events: TriggerEventFacetItemDto[]};
+}) => res.json();
+
+describe('GET /trigger-events/facets', () => {
+  let app: FastifyInstance;
+  let workspaceId: string;
+  let memberships: Array<{workspaceId: string; role: 'admin'}>;
+
+  beforeAll(async () => {
+    app = Fastify();
+    app.setValidatorCompiler(validatorCompiler);
+    app.setSerializerCompiler(serializerCompiler);
+    app.addHook('onRequest', (request, _reply, done) => {
+      setUserContext(
+        request,
+        buildUserContext({userId: crypto.randomUUID(), email: 'user@example.com', memberships}),
+      );
+      done();
+    });
+    app.get('/trigger-events/facets', listTriggerEventFacetsRoute);
+    await app.ready();
+  });
+
+  beforeEach(() => {
+    workspaceId = crypto.randomUUID();
+    memberships = [{workspaceId, role: 'admin'}];
+  });
+
+  test('returns distinct sources and events with counts, ordered by count desc', async () => {
+    await receivedEventFactory.create({workspaceId, source: 'github', event: 'push'});
+    await receivedEventFactory.create({workspaceId, source: 'github', event: 'pull_request'});
+    await receivedEventFactory.create({workspaceId, source: 'gitea', event: 'push'});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events/facets?workspace_id=${workspaceId}`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(facets(res).sources).toEqual([
+      {value: 'github', count: 2},
+      {value: 'gitea', count: 1},
+    ]);
+    expect(facets(res).events).toEqual([
+      {value: 'push', count: 2},
+      {value: 'pull_request', count: 1},
+    ]);
+  });
+
+  test('caps each facet at the top 50 values by count', async () => {
+    await Promise.all(
+      Array.from({length: 51}, (_, index) =>
+        receivedEventFactory.create({workspaceId, source: `source-${index}`}),
+      ),
+    );
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events/facets?workspace_id=${workspaceId}`,
+    });
+
+    expect(facets(res).sources).toHaveLength(50);
+  });
+
+  test('scopes facets to the workspace', async () => {
+    await receivedEventFactory.create({workspaceId, source: 'github'});
+    await receivedEventFactory.create({source: 'gitlab'});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events/facets?workspace_id=${workspaceId}`,
+    });
+
+    expect(facets(res).sources.map((facet) => facet.value)).toEqual(['github']);
+  });
+
+  test('returns empty facets for a workspace with no events', async () => {
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events/facets?workspace_id=${workspaceId}`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual({sources: [], events: []});
+  });
+
+  test('denies a workspace the caller does not belong to', async () => {
+    const otherWorkspaceId = crypto.randomUUID();
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events/facets?workspace_id=${otherWorkspaceId}`,
+    });
+
+    expect(res.statusCode).toBe(403);
+    expect(res.json().code).toBe('forbidden');
+  });
+
+  test('rejects a non-uuid workspace_id', async () => {
+    const res = await app.inject({
+      method: 'GET',
+      url: '/trigger-events/facets?workspace_id=nope',
+    });
+
+    expect(res.statusCode).toBe(400);
+  });
+});

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

@@ -0,0 +1,29 @@
+import {requireUserContext} from '@shipfox/api-auth-context';
+import {
+  triggerEventFacetsQuerySchema,
+  triggerEventFacetsResponseSchema,
+} from '@shipfox/api-triggers-dto';
+import {ClientError, defineRoute} from '@shipfox/node-fastify';
+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.',
+  schema: {
+    querystring: triggerEventFacetsQuerySchema,
+    response: {
+      200: triggerEventFacetsResponseSchema,
+    },
+  },
+  handler: async (request) => {
+    const {workspace_id: workspaceId} = request.query;
+
+    const userContext = requireUserContext(request);
+    if (!userContext.canAccess(workspaceId)) {
+      throw new ClientError('Not a member of this workspace', 'forbidden', {status: 403});
+    }
+
+    return await listTriggerEventFacets({workspaceId});
+  },
+});

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

@@ -0,0 +1,379 @@
+import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
+import {encodeTimestampIdCursor} from '@shipfox/node-drizzle';
+import type {FastifyInstance} from 'fastify';
+import Fastify from 'fastify';
+import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
+import {receivedEventFactory} from '#test/index.js';
+import {listTriggerEventsRoute} from './list-trigger-events.js';
+
+const eventIds = (res: {json: () => {trigger_events: Array<{id: string}>}}) =>
+  res.json().trigger_events.map((event) => event.id);
+
+describe('GET /trigger-events', () => {
+  let app: FastifyInstance;
+  let workspaceId: string;
+  let memberships: Array<{workspaceId: string; role: 'admin'}>;
+
+  beforeAll(async () => {
+    app = Fastify();
+    app.setValidatorCompiler(validatorCompiler);
+    app.setSerializerCompiler(serializerCompiler);
+    app.addHook('onRequest', (request, _reply, done) => {
+      setUserContext(
+        request,
+        buildUserContext({userId: crypto.randomUUID(), email: 'user@example.com', memberships}),
+      );
+      done();
+    });
+    app.get('/trigger-events', listTriggerEventsRoute);
+    await app.ready();
+  });
+
+  beforeEach(() => {
+    workspaceId = crypto.randomUUID();
+    memberships = [{workspaceId, role: 'admin'}];
+  });
+
+  test('returns a workspace events newest first, isolated and payload-free', async () => {
+    const older = await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-07T00:00:00.000Z'),
+    });
+    const newer = await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-07T02:00:00.000Z'),
+    });
+    await receivedEventFactory.create({receivedAt: new Date('2026-05-07T03:00:00.000Z')});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(eventIds(res)).toEqual([newer.id, older.id]);
+    expect(res.json().next_cursor).toBeNull();
+    expect(res.json().trigger_events[0]).not.toHaveProperty('payload');
+  });
+
+  test('filters by source', async () => {
+    const gitea = await receivedEventFactory.create({workspaceId, source: 'gitea'});
+    await receivedEventFactory.create({workspaceId, source: 'github'});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&source=gitea`,
+    });
+
+    expect(eventIds(res)).toEqual([gitea.id]);
+  });
+
+  test('filters by repeated source keys (IN-list)', async () => {
+    const gitea = await receivedEventFactory.create({workspaceId, source: 'gitea'});
+    const github = await receivedEventFactory.create({workspaceId, source: 'github'});
+    await receivedEventFactory.create({workspaceId, source: 'manual'});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&source=gitea&source=github`,
+    });
+
+    expect(eventIds(res).sort()).toEqual([gitea.id, github.id].sort());
+  });
+
+  test('filters by comma-separated sources', async () => {
+    const gitea = await receivedEventFactory.create({workspaceId, source: 'gitea'});
+    const github = await receivedEventFactory.create({workspaceId, source: 'github'});
+    await receivedEventFactory.create({workspaceId, source: 'manual'});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&source=gitea,github`,
+    });
+
+    expect(eventIds(res).sort()).toEqual([gitea.id, github.id].sort());
+  });
+
+  test('filters by event', async () => {
+    const pullRequest = await receivedEventFactory.create({workspaceId, event: 'pull_request'});
+    await receivedEventFactory.create({workspaceId, event: 'push'});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&event=pull_request`,
+    });
+
+    expect(eventIds(res)).toEqual([pullRequest.id]);
+  });
+
+  test('filters by repeated event keys (IN-list)', async () => {
+    const pullRequest = await receivedEventFactory.create({workspaceId, event: 'pull_request'});
+    const push = await receivedEventFactory.create({workspaceId, event: 'push'});
+    await receivedEventFactory.create({workspaceId, event: 'release'});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&event=pull_request&event=push`,
+    });
+
+    expect(eventIds(res).sort()).toEqual([pullRequest.id, push.id].sort());
+  });
+
+  test('filters by comma-separated events', async () => {
+    const pullRequest = await receivedEventFactory.create({workspaceId, event: 'pull_request'});
+    const push = await receivedEventFactory.create({workspaceId, event: 'push'});
+    await receivedEventFactory.create({workspaceId, event: 'release'});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&event=pull_request,push`,
+    });
+
+    expect(eventIds(res).sort()).toEqual([pullRequest.id, push.id].sort());
+  });
+
+  test('filters by repeated outcome keys (IN-list)', async () => {
+    const {routed, discarded, failed} = await seedOutcomes(workspaceId);
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&outcome=routed&outcome=failed`,
+    });
+
+    expect(eventIds(res).sort()).toEqual([routed.id, failed.id].sort());
+    expect(eventIds(res)).not.toContain(discarded.id);
+  });
+
+  test('filters by comma-separated outcomes', async () => {
+    const {routed, discarded, failed} = await seedOutcomes(workspaceId);
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&outcome=routed,failed`,
+    });
+
+    expect(eventIds(res).sort()).toEqual([routed.id, failed.id].sort());
+    expect(eventIds(res)).not.toContain(discarded.id);
+  });
+
+  test('filters by a single outcome', async () => {
+    const {discarded} = await seedOutcomes(workspaceId);
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&outcome=discarded`,
+    });
+
+    expect(eventIds(res)).toEqual([discarded.id]);
+  });
+
+  test('filters and serializes the errored outcome', async () => {
+    const errored = await receivedEventFactory.create({workspaceId, outcome: 'errored'});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&outcome=errored`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(eventIds(res)).toEqual([errored.id]);
+  });
+
+  test('treats a blank outcome as no filter', async () => {
+    const {routed, discarded, failed} = await seedOutcomes(workspaceId);
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&outcome=`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(eventIds(res).sort()).toEqual([routed.id, discarded.id, failed.id].sort());
+  });
+
+  test('drops a trailing comma in the outcome filter', async () => {
+    const {routed, discarded, failed} = await seedOutcomes(workspaceId);
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&outcome=routed,`,
+    });
+
+    expect(eventIds(res)).toEqual([routed.id]);
+    expect(eventIds(res)).not.toContain(discarded.id);
+    expect(eventIds(res)).not.toContain(failed.id);
+  });
+
+  test('filters by received_at window', async () => {
+    await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-01T00:00:00.000Z'),
+    });
+    const inWindow = await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-10T00:00:00.000Z'),
+    });
+    await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-20T00:00:00.000Z'),
+    });
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&from=2026-05-05T00:00:00.000Z&to=2026-05-15T00:00:00.000Z`,
+    });
+
+    expect(eventIds(res)).toEqual([inWindow.id]);
+  });
+
+  test('includes events on the from and to window boundaries', async () => {
+    const onFrom = await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-05T00:00:00.000Z'),
+    });
+    const onTo = await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-15T00:00:00.000Z'),
+    });
+    await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-04T23:59:59.999Z'),
+    });
+    await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-15T00:00:00.001Z'),
+    });
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&from=2026-05-05T00:00:00.000Z&to=2026-05-15T00:00:00.000Z`,
+    });
+
+    expect(eventIds(res).sort()).toEqual([onFrom.id, onTo.id].sort());
+  });
+
+  test('paginates with a received_at + id cursor', async () => {
+    const first = await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-07T00:00:00.000Z'),
+    });
+    const second = await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-07T01:00:00.000Z'),
+    });
+    const third = await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-07T02:00:00.000Z'),
+    });
+
+    const page1 = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&limit=2`,
+    });
+
+    expect(eventIds(page1)).toEqual([third.id, second.id]);
+    expect(page1.json().next_cursor).toBe(
+      encodeTimestampIdCursor({createdAt: second.receivedAt, id: second.id}),
+    );
+
+    const page2 = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&limit=2&cursor=${page1.json().next_cursor}`,
+    });
+
+    expect(eventIds(page2)).toEqual([first.id]);
+    expect(page2.json().next_cursor).toBeNull();
+  });
+
+  test('breaks received_at ties by id without duplicating or skipping rows', async () => {
+    const tie = new Date('2026-05-07T00:00:00.000Z');
+    const a = await receivedEventFactory.create({workspaceId, receivedAt: tie});
+    const b = await receivedEventFactory.create({workspaceId, receivedAt: tie});
+    const earlier = await receivedEventFactory.create({
+      workspaceId,
+      receivedAt: new Date('2026-05-06T00:00:00.000Z'),
+    });
+
+    const page1 = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&limit=2`,
+    });
+    const page2 = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&limit=2&cursor=${page1.json().next_cursor}`,
+    });
+
+    expect(eventIds(page1)).toEqual([a.id, b.id].sort().reverse());
+    expect(eventIds(page2)).toEqual([earlier.id]);
+    expect(new Set([...eventIds(page1), ...eventIds(page2)]).size).toBe(3);
+  });
+
+  test('returns an empty page for a workspace with no events', async () => {
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual({trigger_events: [], next_cursor: null});
+  });
+
+  test('denies a workspace the caller does not belong to', async () => {
+    const otherWorkspaceId = crypto.randomUUID();
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${otherWorkspaceId}`,
+    });
+
+    expect(res.statusCode).toBe(403);
+    expect(res.json().code).toBe('forbidden');
+  });
+
+  test('rejects an invalid cursor', async () => {
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&cursor=not-a-cursor`,
+    });
+
+    expect(res.statusCode).toBe(400);
+    expect(res.json().code).toBe('invalid-cursor');
+  });
+
+  test('requires a workspace_id', async () => {
+    const res = await app.inject({method: 'GET', url: '/trigger-events'});
+
+    expect(res.statusCode).toBe(400);
+  });
+
+  test('rejects a non-uuid workspace_id', async () => {
+    const res = await app.inject({method: 'GET', url: '/trigger-events?workspace_id=nope'});
+
+    expect(res.statusCode).toBe(400);
+  });
+
+  test('rejects an unknown outcome value', async () => {
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&outcome=bogus`,
+    });
+
+    expect(res.statusCode).toBe(400);
+  });
+
+  test('rejects a reversed date window', async () => {
+    const res = await app.inject({
+      method: 'GET',
+      url: `/trigger-events?workspace_id=${workspaceId}&from=2026-05-10T00:00:00.000Z&to=2026-05-01T00:00:00.000Z`,
+    });
+
+    expect(res.statusCode).toBe(400);
+  });
+});
+
+async function seedOutcomes(workspaceId: string) {
+  const routed = await receivedEventFactory.create({workspaceId, outcome: 'routed'});
+  const discarded = await receivedEventFactory.create({workspaceId, outcome: 'discarded'});
+  const failed = await receivedEventFactory.create({workspaceId, outcome: 'failed'});
+  return {routed, discarded, failed};
+}

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

@@ -0,0 +1,68 @@
+import {requireUserContext} from '@shipfox/api-auth-context';
+import {
+  triggerEventListQuerySchema,
+  triggerEventListResponseSchema,
+} from '@shipfox/api-triggers-dto';
+import {decodeTimestampIdCursor, encodeTimestampIdCursor} from '@shipfox/node-drizzle';
+import {ClientError, defineRoute} from '@shipfox/node-fastify';
+import {listTriggerEvents} from '#db/index.js';
+import {toTriggerEventListItemDto} from '#presentation/dto/trigger-events.js';
+
+export const listTriggerEventsRoute = defineRoute({
+  method: 'GET',
+  path: '/',
+  description: 'List trigger events for a workspace, newest first.',
+  schema: {
+    querystring: triggerEventListQuerySchema,
+    response: {
+      200: triggerEventListResponseSchema,
+    },
+  },
+  handler: async (request) => {
+    const {
+      workspace_id: workspaceId,
+      source,
+      event,
+      outcome: outcomes,
+      from,
+      to,
+      limit,
+      cursor,
+    } = request.query;
+
+    const userContext = requireUserContext(request);
+    if (!userContext.canAccess(workspaceId)) {
+      throw new ClientError('Not a member of this workspace', 'forbidden', {status: 403});
+    }
+
+    const decodedCursor = decodeTimestampIdCursor(cursor);
+    if (cursor && !decodedCursor) {
+      throw new ClientError('Invalid cursor', 'invalid-cursor', {status: 400});
+    }
+
+    const result = await listTriggerEvents({
+      workspaceId,
+      limit,
+      cursor: decodedCursor
+        ? {receivedAt: decodedCursor.createdAt, id: decodedCursor.id}
+        : undefined,
+      filters: {
+        source,
+        event,
+        outcomes,
+        from: from ? new Date(from) : undefined,
+        to: to ? new Date(to) : undefined,
+      },
+    });
+
+    return {
+      trigger_events: result.events.map(toTriggerEventListItemDto),
+      next_cursor: result.nextCursor
+        ? encodeTimestampIdCursor({
+            createdAt: result.nextCursor.receivedAt,
+            id: result.nextCursor.id,
+          })
+        : null,
+    };
+  },
+});

package/src/presentation/subscribers/index.ts

@@ -0,0 +1,5 @@
+export {onDefinitionDeleted} from './on-definition-deleted.js';
+export {onDefinitionResolved} from './on-definition-resolved.js';
+export {onIntegrationEventReceived} from './on-integration-event-received.js';
+export {onJobActivated} from './on-job-activated.js';
+export {onJobTerminated} from './on-job-terminated.js';

package/src/presentation/subscribers/on-definition-deleted.test.ts

@@ -0,0 +1,42 @@
+import type {DefinitionDeletedEvent} from '@shipfox/api-definitions-dto';
+import {eq} from 'drizzle-orm';
+import {db} from '#db/db.js';
+import {triggerSubscriptions} from '#db/schema/subscriptions.js';
+import {triggerSubscriptionFactory} from '#test/index.js';
+import {onDefinitionDeleted} from './on-definition-deleted.js';
+
+function buildPayload(definitionId: string): DefinitionDeletedEvent {
+  return {definitionId, projectId: crypto.randomUUID(), workspaceId: crypto.randomUUID()};
+}
+
+function listSubscriptions(workflowDefinitionId: string) {
+  return db()
+    .select()
+    .from(triggerSubscriptions)
+    .where(eq(triggerSubscriptions.workflowDefinitionId, workflowDefinitionId));
+}
+
+describe('onDefinitionDeleted', () => {
+  it('deletes every subscription for the definition', async () => {
+    const definitionId = crypto.randomUUID();
+    await triggerSubscriptionFactory.create({workflowDefinitionId: definitionId, name: 'a'});
+    await triggerSubscriptionFactory.create({workflowDefinitionId: definitionId, name: 'b'});
+
+    await onDefinitionDeleted(buildPayload(definitionId));
+
+    const rows = await listSubscriptions(definitionId);
+    expect(rows).toHaveLength(0);
+  });
+
+  it('leaves subscriptions for other definitions untouched', async () => {
+    const deletedId = crypto.randomUUID();
+    const keptId = crypto.randomUUID();
+    await triggerSubscriptionFactory.create({workflowDefinitionId: deletedId, name: 'a'});
+    const kept = await triggerSubscriptionFactory.create({workflowDefinitionId: keptId, name: 'a'});
+
+    await onDefinitionDeleted(buildPayload(deletedId));
+
+    const rows = await listSubscriptions(keptId);
+    expect(rows.map((r) => r.id)).toEqual([kept.id]);
+  });
+});

package/src/presentation/subscribers/on-definition-deleted.ts

@@ -0,0 +1,6 @@
+import type {DefinitionDeletedEvent} from '@shipfox/api-definitions-dto';
+import {deleteSubscriptionsForDefinition} from '#db/subscriptions.js';
+
+export async function onDefinitionDeleted(payload: DefinitionDeletedEvent): Promise<void> {
+  await deleteSubscriptionsForDefinition({workflowDefinitionId: payload.definitionId});
+}