@shipfox/api-triggers 2.0.0

package/src/metrics/instance.ts

@@ -0,0 +1,33 @@
+import {instanceMetrics} from '@shipfox/node-opentelemetry';
+
+const meter = instanceMetrics.getMeter('triggers');
+
+export const eventReceivedCount = meter.createCounter<{
+  provider: string;
+}>('triggers_event_received', {
+  description: 'Trigger events received by provider (e.g. github, gitea, sentry, manual)',
+});
+
+export const subscriptionTriggeredCount = meter.createCounter<{
+  provider: string;
+}>('triggers_subscription_triggered', {
+  description: 'Subscriptions that resulted in a workflow run, by provider',
+});
+
+export const eventOutcomeCount = meter.createCounter<{
+  provider: string;
+  outcome: 'discarded' | 'routed' | 'failed' | 'errored';
+}>('triggers_event_outcome', {
+  description: 'Final outcomes of trigger events by provider and outcome',
+});
+
+export const cronFiredCount = meter.createCounter<{outcome: 'fired' | 'errored'}>(
+  'triggers_cron_fired',
+  {description: 'Cron schedule slots consumed by the tick, by fire outcome'},
+);
+
+export const cronFireLag = meter.createHistogram<Record<string, never>>('triggers_cron_fire_lag', {
+  description: 'Delay between a cron scheduled slot and when the tick actually fired it',
+  unit: 'ms',
+  advice: {explicitBucketBoundaries: [0, 100, 500, 1000, 5000, 15000, 60000, 300000]},
+});

package/src/metrics/service.ts

@@ -0,0 +1,18 @@
+import {getServiceMetricsProvider} from '@shipfox/node-opentelemetry';
+import {countDueCronSchedules} from '#db/cron-schedules.js';
+
+export function registerTriggersServiceMetrics(): void {
+  const meter = getServiceMetricsProvider().getMeter('triggers');
+
+  const cronBacklog = meter.createObservableGauge('triggers_cron_backlog', {
+    description:
+      'Cron schedules past their next fire time and still pending a fire (including any a drain is mid-flight on). A sustained nonzero value means the minute tick is falling behind; raise TRIGGER_CRON_FANOUT, TRIGGER_CRON_CLAIM_BATCH, or pod count.',
+  });
+
+  meter.addBatchObservableCallback(
+    async (observer) => {
+      observer.observe(cronBacklog, await countDueCronSchedules());
+    },
+    [cronBacklog],
+  );
+}

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

@@ -0,0 +1,144 @@
+import type {TriggerDecision} from '#core/entities/decision.js';
+import type {
+  TriggerReceivedEvent,
+  TriggerReceivedEventSummary,
+} from '#core/entities/received-event.js';
+import {
+  toTriggerDecisionDto,
+  toTriggerEventDto,
+  toTriggerEventListItemDto,
+} from './trigger-events.js';
+
+const baseSummary: TriggerReceivedEventSummary = {
+  id: '11111111-1111-1111-1111-111111111111',
+  eventRef: 'event-ref',
+  origin: 'manual',
+  workspaceId: '22222222-2222-2222-2222-222222222222',
+  provider: null,
+  source: 'manual',
+  event: 'fire',
+  deliveryId: null,
+  connectionId: null,
+  connectionName: null,
+  outcome: 'discarded',
+  matchedCount: 0,
+  receivedAt: new Date('2026-05-07T00:00:00.000Z'),
+  processedAt: null,
+  createdAt: new Date('2026-05-07T00:00:01.000Z'),
+};
+
+describe('trigger-events mappers', () => {
+  test('toTriggerEventListItemDto maps null fields, formats ISO dates, and omits payload', () => {
+    const dto = toTriggerEventListItemDto(baseSummary);
+
+    expect(dto).toEqual({
+      id: baseSummary.id,
+      event_ref: 'event-ref',
+      origin: 'manual',
+      workspace_id: baseSummary.workspaceId,
+      provider: null,
+      source: 'manual',
+      event: 'fire',
+      delivery_id: null,
+      connection_id: null,
+      outcome: 'discarded',
+      matched_count: 0,
+      received_at: '2026-05-07T00:00:00.000Z',
+      processed_at: null,
+      created_at: '2026-05-07T00:00:01.000Z',
+    });
+    expect(dto).not.toHaveProperty('payload');
+  });
+
+  test('toTriggerEventDto carries the payload (including null)', () => {
+    const withPayload: TriggerReceivedEvent = {...baseSummary, payload: {ref: 'main'}};
+    const withoutPayload: TriggerReceivedEvent = {...baseSummary, payload: null};
+
+    expect(toTriggerEventDto(withPayload).payload).toEqual({ref: 'main'});
+    expect(toTriggerEventDto(withoutPayload).payload).toBeNull();
+  });
+
+  test('toTriggerEventDto carries the connection name (including null)', () => {
+    const named: TriggerReceivedEvent = {
+      ...baseSummary,
+      connectionName: 'Acme Production',
+      payload: null,
+    };
+    const unnamed: TriggerReceivedEvent = {...baseSummary, connectionName: null, payload: null};
+
+    expect(toTriggerEventDto(named).connection_name).toBe('Acme Production');
+    expect(toTriggerEventDto(unnamed).connection_name).toBeNull();
+  });
+
+  test('toTriggerDecisionDto maps null run/reason fields', () => {
+    const decision: TriggerDecision = {
+      id: '33333333-3333-3333-3333-333333333333',
+      receivedEventId: '11111111-1111-1111-1111-111111111111',
+      subscriptionKind: 'trigger',
+      subscriptionId: '44444444-4444-4444-4444-444444444444',
+      subscriptionName: 'Deploy production',
+      workflowDefinitionId: '55555555-5555-5555-5555-555555555555',
+      projectId: '66666666-6666-6666-6666-666666666666',
+      workflowRunId: null,
+      jobId: null,
+      matcherKind: null,
+      matcherOrdinal: null,
+      decision: 'dispatch-error',
+      runId: null,
+      runName: null,
+      reason: 'boom',
+      createdAt: new Date('2026-05-07T00:00:02.000Z'),
+    };
+
+    expect(toTriggerDecisionDto(decision)).toEqual({
+      id: decision.id,
+      received_event_id: decision.receivedEventId,
+      subscription_kind: 'trigger',
+      subscription_id: decision.subscriptionId,
+      subscription_name: 'Deploy production',
+      workflow_definition_id: decision.workflowDefinitionId,
+      project_id: decision.projectId,
+      workflow_run_id: null,
+      job_id: null,
+      matcher_kind: null,
+      matcher_ordinal: null,
+      decision: 'dispatch-error',
+      run_id: null,
+      run_name: null,
+      reason: 'boom',
+      created_at: '2026-05-07T00:00:02.000Z',
+    });
+  });
+
+  test('toTriggerDecisionDto maps listener identity fields', () => {
+    const decision: TriggerDecision = {
+      id: '33333333-3333-3333-3333-333333333333',
+      receivedEventId: '11111111-1111-1111-1111-111111111111',
+      subscriptionKind: 'listener',
+      subscriptionId: '44444444-4444-4444-4444-444444444444',
+      subscriptionName: 'listener until[0] github/pull_request.closed',
+      workflowDefinitionId: null,
+      projectId: null,
+      workflowRunId: '55555555-5555-5555-5555-555555555555',
+      jobId: '66666666-6666-6666-6666-666666666666',
+      matcherKind: 'until',
+      matcherOrdinal: 0,
+      decision: 'triggered',
+      runId: null,
+      runName: null,
+      reason: null,
+      createdAt: new Date('2026-05-07T00:00:02.000Z'),
+    };
+
+    expect(toTriggerDecisionDto(decision)).toMatchObject({
+      subscription_kind: 'listener',
+      workflow_definition_id: null,
+      project_id: null,
+      workflow_run_id: decision.workflowRunId,
+      job_id: decision.jobId,
+      matcher_kind: 'until',
+      matcher_ordinal: 0,
+      decision: 'triggered',
+    });
+  });
+});

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

@@ -0,0 +1,60 @@
+import type {
+  TriggerDecisionDto,
+  TriggerEventDto,
+  TriggerEventListItemDto,
+} from '@shipfox/api-triggers-dto';
+import type {TriggerDecision} from '#core/entities/decision.js';
+import type {
+  TriggerReceivedEvent,
+  TriggerReceivedEventSummary,
+} from '#core/entities/received-event.js';
+
+export function toTriggerEventListItemDto(
+  event: TriggerReceivedEventSummary,
+): TriggerEventListItemDto {
+  return {
+    id: event.id,
+    event_ref: event.eventRef,
+    origin: event.origin,
+    workspace_id: event.workspaceId,
+    provider: event.provider,
+    source: event.source,
+    event: event.event,
+    delivery_id: event.deliveryId,
+    connection_id: event.connectionId,
+    outcome: event.outcome,
+    matched_count: event.matchedCount,
+    received_at: event.receivedAt.toISOString(),
+    processed_at: event.processedAt?.toISOString() ?? null,
+    created_at: event.createdAt.toISOString(),
+  };
+}
+
+export function toTriggerEventDto(event: TriggerReceivedEvent): TriggerEventDto {
+  return {
+    ...toTriggerEventListItemDto(event),
+    connection_name: event.connectionName,
+    payload: event.payload,
+  };
+}
+
+export function toTriggerDecisionDto(decision: TriggerDecision): TriggerDecisionDto {
+  return {
+    id: decision.id,
+    received_event_id: decision.receivedEventId,
+    subscription_kind: decision.subscriptionKind,
+    subscription_id: decision.subscriptionId,
+    subscription_name: decision.subscriptionName,
+    workflow_definition_id: decision.workflowDefinitionId,
+    project_id: decision.projectId,
+    workflow_run_id: decision.workflowRunId,
+    job_id: decision.jobId,
+    matcher_kind: decision.matcherKind,
+    matcher_ordinal: decision.matcherOrdinal,
+    decision: decision.decision,
+    run_id: decision.runId,
+    run_name: decision.runName,
+    reason: decision.reason,
+    created_at: decision.createdAt.toISOString(),
+  };
+}

package/src/presentation/index.ts

@@ -0,0 +1,6 @@
+export {triggerRoutes as routes} from './routes/index.js';
+export {
+  onDefinitionDeleted,
+  onDefinitionResolved,
+  onIntegrationEventReceived,
+} from './subscribers/index.js';

package/src/presentation/routes/fire-manual.test.ts

@@ -0,0 +1,118 @@
+import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
+import type {WorkflowRun} from '@shipfox/api-workflows';
+import type {FastifyInstance} from 'fastify';
+import Fastify from 'fastify';
+import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
+import {triggerSubscriptionFactory} from '#test/index.js';
+
+const fireManualSubscriptionMock = vi.hoisted(() => vi.fn());
+
+vi.mock('@shipfox/api-workflows', () => {
+  class InterpolationUnresolvableError extends Error {
+    readonly field: string;
+    readonly source: string;
+    readonly envKey?: string;
+
+    constructor(
+      definitionId: string,
+      params: {readonly field: string; readonly source: string; readonly envKey?: string},
+    ) {
+      super(`Workflow interpolation cannot be resolved for definition ${definitionId}`);
+      this.name = 'InterpolationUnresolvableError';
+      this.field = params.field;
+      this.source = params.source;
+      if (params.envKey !== undefined) this.envKey = params.envKey;
+    }
+  }
+  return {InterpolationUnresolvableError};
+});
+
+vi.mock('#core/fire-manual.js', () => ({
+  fireManualSubscription: fireManualSubscriptionMock,
+}));
+
+import {InterpolationUnresolvableError} from '@shipfox/api-workflows';
+
+const {fireManualTriggerRoute} = await import('./fire-manual.js');
+
+describe('POST /:definitionId/fire-manual', () => {
+  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.post('/:definitionId/fire-manual', fireManualTriggerRoute);
+    await app.ready();
+  });
+
+  beforeEach(() => {
+    workspaceId = crypto.randomUUID();
+    memberships = [{workspaceId, role: 'admin'}];
+    fireManualSubscriptionMock.mockReset();
+  });
+
+  test('returns 201 with the created run id', async () => {
+    const definitionId = crypto.randomUUID();
+    const runId = crypto.randomUUID();
+    await triggerSubscriptionFactory.create({workspaceId, workflowDefinitionId: definitionId});
+    fireManualSubscriptionMock.mockResolvedValue({id: runId} satisfies Pick<WorkflowRun, 'id'>);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/${definitionId}/fire-manual`,
+      payload: {},
+    });
+
+    expect(res.statusCode).toBe(201);
+    expect(res.json()).toEqual({workflow_run_id: runId});
+  });
+
+  test('maps unresolvable workflow interpolation to 422', async () => {
+    const definitionId = crypto.randomUUID();
+    await triggerSubscriptionFactory.create({workspaceId, workflowDefinitionId: definitionId});
+    fireManualSubscriptionMock.mockRejectedValue(
+      new InterpolationUnresolvableError(definitionId, {
+        field: 'env',
+        source: 'event.ref',
+        envKey: 'REF',
+      }),
+    );
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/${definitionId}/fire-manual`,
+      payload: {},
+    });
+
+    expect(res.statusCode).toBe(422);
+    expect(res.json()).toMatchObject({
+      code: 'workflow-interpolation-unresolvable',
+      details: {
+        field: 'env',
+        source: 'event.ref',
+        env_key: 'REF',
+      },
+    });
+  });
+
+  test('returns 404 when the manual trigger is unavailable', async () => {
+    const res = await app.inject({
+      method: 'POST',
+      url: `/${crypto.randomUUID()}/fire-manual`,
+      payload: {},
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('manual-trigger-not-found');
+  });
+});

package/src/presentation/routes/fire-manual.ts

@@ -0,0 +1,70 @@
+import {requireUserContext} from '@shipfox/api-auth-context';
+import {
+  fireManualTriggerBodySchema,
+  fireManualTriggerResponseSchema,
+} from '@shipfox/api-triggers-dto';
+import {InterpolationUnresolvableError} from '@shipfox/api-workflows';
+import {ClientError, defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {ManualTriggerNotFoundError} from '#core/errors.js';
+import {fireManualSubscription} from '#core/fire-manual.js';
+import {getManualSubscriptionByDefinitionId} from '#db/subscriptions.js';
+
+export const fireManualTriggerRoute = defineRoute({
+  method: 'POST',
+  path: '/:definitionId/fire-manual',
+  description: 'Fire the manual trigger of a workflow definition, creating a workflow run.',
+  schema: {
+    params: z.object({
+      definitionId: z.string().uuid(),
+    }),
+    body: fireManualTriggerBodySchema,
+    response: {
+      201: fireManualTriggerResponseSchema,
+      422: z.object({
+        code: z.string(),
+        details: z.object({
+          field: z.string(),
+          source: z.string(),
+          env_key: z.string().optional(),
+        }),
+      }),
+    },
+  },
+  errorHandler: (error) => {
+    if (error instanceof ManualTriggerNotFoundError) {
+      throw new ClientError(error.message, 'manual-trigger-not-found', {status: 404});
+    }
+    if (error instanceof InterpolationUnresolvableError) {
+      throw new ClientError(error.message, 'workflow-interpolation-unresolvable', {
+        status: 422,
+        details: {
+          field: error.field,
+          source: error.source,
+          ...(error.envKey === undefined ? {} : {env_key: error.envKey}),
+        },
+      });
+    }
+    throw error;
+  },
+  handler: async (request, reply) => {
+    const {definitionId} = request.params;
+    const userContext = requireUserContext(request);
+
+    const subscription = await getManualSubscriptionByDefinitionId(definitionId);
+    // 404 covers both "no such manual trigger" and "not your workspace" to avoid leaking existence.
+    if (!subscription || !userContext.canAccess(subscription.workspaceId)) {
+      throw new ManualTriggerNotFoundError(definitionId);
+    }
+
+    const run = await fireManualSubscription({
+      subscriptionId: subscription.id,
+      callerWorkspaceId: subscription.workspaceId,
+      userId: userContext.userId,
+      inputs: request.body.inputs,
+    });
+
+    reply.status(201);
+    return {workflow_run_id: run.id};
+  },
+});

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

@@ -0,0 +1,184 @@
+import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
+import type {FastifyInstance} from 'fastify';
+import Fastify from 'fastify';
+import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
+import {db} from '#db/db.js';
+import {type TriggerDecisionInsertDb, triggersDecisions} from '#db/schema/decisions.js';
+import {decisionFactory, receivedEventFactory} from '#test/index.js';
+import {getTriggerEventRoute} from './get-trigger-event.js';
+
+describe('GET /trigger-events/:id', () => {
+  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/:id', getTriggerEventRoute);
+    await app.ready();
+  });
+
+  beforeEach(() => {
+    workspaceId = crypto.randomUUID();
+    memberships = [{workspaceId, role: 'admin'}];
+  });
+
+  test('returns the event with its decisions and full payload', async () => {
+    const event = await receivedEventFactory.create({
+      workspaceId,
+      outcome: 'routed',
+      matchedCount: 2,
+      payload: {ref: 'refs/heads/main', headCommitSha: 'abc123'},
+    });
+    const triggered = await decisionFactory.create({
+      receivedEventId: event.id,
+      decision: 'triggered',
+      subscriptionName: 'Deploy production',
+      runName: 'deploy',
+    });
+    const errored = await decisionFactory.create({
+      receivedEventId: event.id,
+      decision: 'dispatch-error',
+      subscriptionName: 'Lint checks',
+      runId: null,
+      runName: null,
+      reason: 'boom',
+    });
+
+    const res = await app.inject({method: 'GET', url: `/trigger-events/${event.id}`});
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json();
+    expect(body.id).toBe(event.id);
+    expect(body.matched_count).toBe(2);
+    expect(body.payload).toEqual({ref: 'refs/heads/main', headCommitSha: 'abc123'});
+    expect(body.decisions.map((decision: {id: string}) => decision.id)).toEqual([
+      triggered.id,
+      errored.id,
+    ]);
+    expect(
+      body.decisions.map((decision: {subscription_name: string}) => decision.subscription_name),
+    ).toEqual(['Deploy production', 'Lint checks']);
+    expect(body.decisions[1].decision).toBe('dispatch-error');
+    expect(body.decisions[1].run_id).toBeNull();
+    expect(body.decisions[1].reason).toBe('boom');
+  });
+
+  test('normalizes legacy errored decisions before serializing the response', async () => {
+    const event = await receivedEventFactory.create({
+      workspaceId,
+      outcome: 'errored',
+      matchedCount: 1,
+    });
+    const legacyDecision = {
+      receivedEventId: event.id,
+      subscriptionKind: 'trigger',
+      subscriptionId: crypto.randomUUID(),
+      subscriptionName: 'Deploy production',
+      workflowDefinitionId: crypto.randomUUID(),
+      projectId: crypto.randomUUID(),
+      decision: 'errored',
+      runId: null,
+      runName: null,
+      reason: 'legacy failure',
+    } as unknown as TriggerDecisionInsertDb;
+    await db().insert(triggersDecisions).values(legacyDecision);
+
+    const res = await app.inject({method: 'GET', url: `/trigger-events/${event.id}`});
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().decisions).toMatchObject([
+      {decision: 'dispatch-error', reason: 'legacy failure'},
+    ]);
+  });
+
+  test('returns mixed trigger and listener decisions', async () => {
+    const event = await receivedEventFactory.create({
+      workspaceId,
+      outcome: 'routed',
+      matchedCount: 2,
+    });
+    await decisionFactory.create({
+      receivedEventId: event.id,
+      subscriptionKind: 'trigger',
+      decision: 'triggered',
+      subscriptionName: 'Deploy production',
+    });
+    const listener = await decisionFactory.create({
+      receivedEventId: event.id,
+      subscriptionKind: 'listener',
+      subscriptionName: 'listener until[0] github/pull_request.closed',
+      workflowDefinitionId: null,
+      projectId: null,
+      workflowRunId: crypto.randomUUID(),
+      jobId: crypto.randomUUID(),
+      matcherKind: 'until',
+      matcherOrdinal: 0,
+      decision: 'triggered',
+      runId: null,
+      runName: null,
+    });
+
+    const res = await app.inject({method: 'GET', url: `/trigger-events/${event.id}`});
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().decisions).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          subscription_kind: 'listener',
+          subscription_id: listener.subscriptionId,
+          workflow_definition_id: null,
+          project_id: null,
+          workflow_run_id: listener.workflowRunId,
+          job_id: listener.jobId,
+          matcher_kind: 'until',
+          matcher_ordinal: 0,
+        }),
+      ]),
+    );
+  });
+
+  test('returns an empty decisions list for a discarded event', async () => {
+    const event = await receivedEventFactory.create({
+      workspaceId,
+      outcome: 'discarded',
+      matchedCount: 0,
+    });
+
+    const res = await app.inject({method: 'GET', url: `/trigger-events/${event.id}`});
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().decisions).toEqual([]);
+  });
+
+  test('returns 404 for an unknown event id', async () => {
+    const res = await app.inject({method: 'GET', url: `/trigger-events/${crypto.randomUUID()}`});
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('not-found');
+  });
+
+  test('returns 404 for an event in another workspace', async () => {
+    const event = await receivedEventFactory.create({workspaceId: crypto.randomUUID()});
+
+    const res = await app.inject({method: 'GET', url: `/trigger-events/${event.id}`});
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('not-found');
+  });
+
+  test('rejects a non-uuid id', async () => {
+    const res = await app.inject({method: 'GET', url: '/trigger-events/not-a-uuid'});
+
+    expect(res.statusCode).toBe(400);
+  });
+});

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

@@ -0,0 +1,37 @@
+import {requireUserContext} 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';
+
+export const getTriggerEventRoute = defineRoute({
+  method: 'GET',
+  path: '/:id',
+  description: 'Get a trigger event by ID with its routing decisions.',
+  schema: {
+    params: z.object({
+      id: z.string().uuid(),
+    }),
+    response: {
+      200: triggerEventDetailResponseSchema,
+    },
+  },
+  handler: async (request) => {
+    const {id} = request.params;
+    const userContext = requireUserContext(request);
+
+    const event = await getTriggerEventById(id);
+    // 404 covers both "no such event" and "not your workspace" to avoid leaking existence.
+    if (!event || !userContext.canAccess(event.workspaceId)) {
+      throw new ClientError('Trigger event not found', 'not-found', {status: 404});
+    }
+
+    const decisions = await listDecisionsByReceivedEventId(event.id);
+
+    return {
+      ...toTriggerEventDto(event),
+      decisions: decisions.map(toTriggerDecisionDto),
+    };
+  },
+});