@shipfox/api-triggers 5.0.0 → 7.0.1

package/src/core/fire-manual.test.ts

@@ -1,3 +1,5 @@
+import {workflowsInterModuleContract} from '@shipfox/api-workflows-dto/inter-module';
+import {createInterModuleKnownError} from '@shipfox/inter-module';
 import {eq} from 'drizzle-orm';
 import {db} from '#db/db.js';
 import {triggersDecisions} from '#db/schema/decisions.js';
@@ -7,27 +9,10 @@ import {TriggerSubscriptionNotManualError} from './errors.js';
 
 const runWorkflow = vi.fn();
 
-// Keep real-enough permanent-error classes + the classifier so the manual path's
-// permanent/transient branching is exercised without loading the workflows module graph.
-vi.mock('@shipfox/api-workflows', () => {
-  class DefinitionNotFoundError extends Error {
-    constructor(definitionId: string) {
-      super(`Definition not found: ${definitionId}`);
-      this.name = 'DefinitionNotFoundError';
-    }
-  }
-  return {
-    runWorkflow: (...args: unknown[]) => runWorkflow(...args),
-    DefinitionNotFoundError,
-    isPermanentRunWorkflowError: (error: unknown) => error instanceof DefinitionNotFoundError,
-  };
-});
-
-import {DefinitionNotFoundError} from '@shipfox/api-workflows';
-
-// Import after mocks so the function under test sees the spy.
 const {fireManualSubscription} = await import('./fire-manual.js');
 
+const workflows = {startRunFromTrigger: (...args: unknown[]) => runWorkflow(...args)} as never;
+
 function eventsForWorkspace(workspaceId: string) {
   return db()
     .select()
@@ -57,12 +42,15 @@ describe('fireManualSubscription (trigger history)', () => {
     runWorkflow.mockResolvedValue(run);
 
     const result = await fireManualSubscription({
+      workflows,
       subscriptionId: subscription.id,
       callerWorkspaceId: subscription.workspaceId,
       userId: crypto.randomUUID(),
     });
 
     expect(result).toEqual(run);
+    const [payload] = runWorkflow.mock.calls[0] as [Record<string, unknown>];
+    expect(payload).not.toHaveProperty('inputs');
     const [event] = await db()
       .select()
       .from(triggersReceivedEvents)
@@ -88,6 +76,7 @@ describe('fireManualSubscription (trigger history)', () => {
 
     await expect(
       fireManualSubscription({
+        workflows,
         subscriptionId: subscription.id,
         callerWorkspaceId: subscription.workspaceId,
         userId: crypto.randomUUID(),
@@ -114,15 +103,22 @@ describe('fireManualSubscription (trigger history)', () => {
       event: 'fire',
       config: {},
     });
-    runWorkflow.mockRejectedValue(new DefinitionNotFoundError('def-gone'));
+    runWorkflow.mockRejectedValue(
+      createInterModuleKnownError(
+        workflowsInterModuleContract.methods.startRunFromTrigger,
+        'definition-not-found',
+        {definitionId: crypto.randomUUID()},
+      ),
+    );
 
     await expect(
       fireManualSubscription({
+        workflows,
         subscriptionId: subscription.id,
         callerWorkspaceId: subscription.workspaceId,
         userId: crypto.randomUUID(),
       }),
-    ).rejects.toThrow('Definition not found');
+    ).rejects.toThrow('definition-not-found');
 
     const events = await eventsForWorkspace(subscription.workspaceId);
     expect(events).toHaveLength(1);
@@ -133,7 +129,7 @@ describe('fireManualSubscription (trigger history)', () => {
     expect(event.processedAt).toBeInstanceOf(Date);
     const decisions = await decisionsForEvent(event.id);
     expect(decisions[0]?.decision).toBe('dispatch-error');
-    expect(decisions[0]?.reason).toContain('Definition not found');
+    expect(decisions[0]?.reason).toContain('definition-not-found');
   });
 
   test('does not record a received event when the subscription is not a manual trigger', async () => {
@@ -145,6 +141,7 @@ describe('fireManualSubscription (trigger history)', () => {
 
     await expect(
       fireManualSubscription({
+        workflows,
         subscriptionId: subscription.id,
         callerWorkspaceId: subscription.workspaceId,
         userId: crypto.randomUUID(),

package/src/core/fire-manual.ts

@@ -1,5 +1,4 @@
 import {randomUUID} from 'node:crypto';
-import {isPermanentRunWorkflowError, runWorkflow, type WorkflowRun} from '@shipfox/api-workflows';
 import {getTriggerSubscriptionById} from '#db/subscriptions.js';
 import {
   eventOutcomeCount,
@@ -13,8 +12,10 @@ import {
   TriggerWorkspaceMismatchError,
 } from './errors.js';
 import {beginTriggerHistory, toReason} from './record-trigger-history.js';
+import {isPermanentStartRunError, type WorkflowsModuleClient} from './workflows-client.js';
 
 export interface FireManualSubscriptionParams {
+  workflows: WorkflowsModuleClient;
   subscriptionId: string;
   callerWorkspaceId: string;
   userId: string;
@@ -23,7 +24,7 @@ export interface FireManualSubscriptionParams {
 
 export async function fireManualSubscription(
   params: FireManualSubscriptionParams,
-): Promise<WorkflowRun> {
+): Promise<{id: string; name: string}> {
   const subscription = await getTriggerSubscriptionById(params.subscriptionId);
   if (!subscription) throw new TriggerSubscriptionNotFoundError(params.subscriptionId);
   if (subscription.source !== 'manual') {
@@ -55,9 +56,10 @@ export async function fireManualSubscription(
 
   eventReceivedCount.add(1, {provider: 'manual'});
 
-  let run: WorkflowRun;
+  const inputs = params.inputs ?? readConfigInputs(subscription);
+  let run: {id: string; name: string};
   try {
-    run = await runWorkflow({
+    run = await params.workflows.startRunFromTrigger({
       workspaceId: subscription.workspaceId,
       projectId: subscription.projectId,
       definitionId: subscription.workflowDefinitionId,
@@ -68,12 +70,13 @@ export async function fireManualSubscription(
         subscriptionId: subscription.id,
         userId: params.userId,
       },
-      inputs: params.inputs ?? readConfigInputs(subscription),
+      ...(inputs === undefined ? {} : {inputs}),
+      idempotencyKey: randomUUID(),
     });
   } catch (error) {
     const failure = await beginTriggerHistory({...historyBase, eventRef: randomUUID()});
     await failure.dispatchErrored(subscription, toReason(error));
-    if (isPermanentRunWorkflowError(error)) {
+    if (isPermanentStartRunError(error)) {
       eventOutcomeCount.add(1, {provider: 'manual', outcome: 'errored'});
       await failure.allErrored(1);
     } else {

package/src/core/record-trigger-history.test.ts

@@ -5,11 +5,6 @@ const insertReceivedEvent = vi.fn();
 const markReceivedEventRouted = vi.fn();
 const upsertTriggeredDecision = vi.fn();
 
-vi.mock('@shipfox/api-workflows', () => ({
-  runWorkflow: (...args: unknown[]) => runWorkflow(...args),
-  isPermanentRunWorkflowError: () => false,
-}));
-
 vi.mock('#db/event-history.js', () => ({
   insertReceivedEvent: (...args: unknown[]) => insertReceivedEvent(...args),
   markReceivedEventDiscarded: vi.fn(),
@@ -28,6 +23,8 @@ vi.mock('#db/event-history.js', () => ({
 const {beginTriggerHistory, toReason} = await import('./record-trigger-history.js');
 const {fireManualSubscription} = await import('./fire-manual.js');
 
+const workflows = {startRunFromTrigger: (...args: unknown[]) => runWorkflow(...args)} as never;
+
 describe('trigger history is best-effort and never blocks triggering', () => {
   beforeEach(() => {
     runWorkflow.mockReset();
@@ -80,6 +77,7 @@ describe('trigger history is best-effort and never blocks triggering', () => {
     });
 
     const result = await fireManualSubscription({
+      workflows,
       subscriptionId: subscription.id,
       callerWorkspaceId: subscription.workspaceId,
       userId: crypto.randomUUID(),

package/src/core/route-event-to-job-listeners.test.ts

@@ -8,10 +8,6 @@ const listenerFilterErrored = vi.fn();
 const listenerDispatchErrored = vi.fn();
 const loggerWarn = vi.fn();
 
-vi.mock('@shipfox/api-workflows', () => ({
-  deliverEventToListener: (...args: unknown[]) => deliverEventToListener(...args),
-}));
-
 vi.mock('@shipfox/node-opentelemetry', () => ({
   logger: () => ({warn: loggerWarn}),
 }));
@@ -33,6 +29,10 @@ vi.mock('#db/job-listener-subscriptions.js', async (importOriginal) => {
 
 const {routeEventToJobListeners} = await import('./route-event-to-job-listeners.js');
 
+const workflows = {
+  deliverEventToJobListener: (...args: unknown[]) => deliverEventToListener(...args),
+} as never;
+
 interface RouteOverrides {
   eventRef?: string;
   workspaceId?: string;
@@ -43,6 +43,7 @@ interface RouteOverrides {
 
 function route(overrides: RouteOverrides = {}) {
   return routeEventToJobListeners({
+    workflows,
     history: buildHistory(),
     eventRef: overrides.eventRef ?? crypto.randomUUID(),
     workspaceId: overrides.workspaceId ?? crypto.randomUUID(),

package/src/core/route-event-to-job-listeners.ts

@@ -1,11 +1,12 @@
-import {deliverEventToListener, type JobListenerEventDisposition} from '@shipfox/api-workflows';
 import {logger} from '@shipfox/node-opentelemetry';
 import {findMatchingJobListenerSubscriptions} from '#db/job-listener-subscriptions.js';
 import {evaluateStoredFilter, type StoredFilterEvaluation} from './config.js';
 import type {JobListenerSubscription} from './entities/job-listener-subscription.js';
 import {type TriggerHistoryRecorder, toReason} from './record-trigger-history.js';
+import type {WorkflowsModuleClient} from './workflows-client.js';
 
 export interface RouteEventToJobListenersParams {
+  workflows: WorkflowsModuleClient;
   history: TriggerHistoryRecorder;
   eventRef: string;
   workspaceId: string;
@@ -70,7 +71,7 @@ export async function routeEventToJobListeners(
   for (const subscription of effectiveMatchByJobId.values()) {
     const disposition = listenerDisposition(subscription);
     try {
-      const result = await deliverEventToListener({
+      const result = await params.workflows.deliverEventToJobListener({
         jobId: subscription.jobId,
         disposition,
         eventRef: params.eventRef,
@@ -79,7 +80,7 @@ export async function routeEventToJobListeners(
         event: params.event,
         provider: params.provider,
         payload: params.payload,
-        receivedAt: params.receivedAt,
+        receivedAt: params.receivedAt.toISOString(),
       });
       if (!result.skipped) {
         acceptedJobCount += 1;
@@ -153,7 +154,7 @@ function readFilterSnapshot(
   };
 }
 
-function listenerDisposition(subscription: JobListenerSubscription): JobListenerEventDisposition {
+function listenerDisposition(subscription: JobListenerSubscription): 'fire' | 'resolve' {
   return subscription.kind === 'until' ? 'resolve' : 'fire';
 }
 

package/src/core/workflows-client.test.ts

@@ -0,0 +1,73 @@
+import {
+  type WorkflowsModuleClient,
+  workflowsInterModuleContract,
+} from '@shipfox/api-workflows-dto/inter-module';
+import {
+  createInterModuleClient,
+  createInterModuleKnownError,
+  defineInterModulePresentation,
+} from '@shipfox/inter-module';
+import {createFakeInterModuleClients} from '@shipfox/node-module/inter-module/testing';
+import {isPermanentStartRunError} from './workflows-client.js';
+
+const input = {
+  workspaceId: '00000000-0000-4000-8000-000000000001',
+  projectId: '00000000-0000-4000-8000-000000000002',
+  definitionId: '00000000-0000-4000-8000-000000000003',
+  triggerPayload: {
+    provider: 'github',
+    source: 'github',
+    event: 'push',
+    deliveryId: 'delivery-1',
+    data: {ref: 'refs/heads/main'},
+  },
+  idempotencyKey: 'subscription-1:event-1',
+};
+
+function localWorkflowsClient(): WorkflowsModuleClient {
+  return createFakeInterModuleClients({
+    workflows: defineInterModulePresentation(workflowsInterModuleContract, {
+      startRunFromTrigger: ({definitionId}) => {
+        if (definitionId.endsWith('0003')) return {id: definitionId, name: 'Build'};
+        throw createInterModuleKnownError(
+          workflowsInterModuleContract.methods.startRunFromTrigger,
+          'definition-not-found',
+          {definitionId},
+        );
+      },
+      deliverEventToJobListener: () => ({buffered: true, skipped: false}),
+      getStepLogContext: () => ({harness: 'pi' as const}),
+      getLeasedAgentToolContext: () => ({
+        workspaceId: '00000000-0000-4000-8000-000000000006',
+        integrations: [],
+      }),
+    }),
+  }).workflows;
+}
+
+function serializedWorkflowsClient(local: WorkflowsModuleClient): WorkflowsModuleClient {
+  return createInterModuleClient(workflowsInterModuleContract, async (call) => {
+    const copiedInput = JSON.parse(JSON.stringify(call.input)) as never;
+    const client = local as unknown as Record<string, (input: never) => Promise<unknown>>;
+    return await client[call.method]?.(copiedInput);
+  }) as WorkflowsModuleClient;
+}
+
+async function runConsumerSuite(client: WorkflowsModuleClient): Promise<void> {
+  await expect(client.startRunFromTrigger(input)).resolves.toEqual({
+    id: input.definitionId,
+    name: 'Build',
+  });
+
+  const result = client.startRunFromTrigger({...input, definitionId: crypto.randomUUID()});
+  await expect(result).rejects.toSatisfy(isPermanentStartRunError);
+}
+
+describe('WorkflowsModuleClient consumer parity', () => {
+  test('keeps local and serialized clients equivalent for trigger consumers', async () => {
+    const local = localWorkflowsClient();
+
+    await runConsumerSuite(local);
+    await runConsumerSuite(serializedWorkflowsClient(local));
+  });
+});

package/src/core/workflows-client.ts

@@ -0,0 +1,32 @@
+import {
+  type WorkflowsModuleClient,
+  workflowsInterModuleContract,
+} from '@shipfox/api-workflows-dto/inter-module';
+import {isInterModuleKnownError} from '@shipfox/inter-module';
+
+export type {WorkflowsModuleClient};
+
+/**
+ * Workflows declares only failures that can never succeed on retry for trigger
+ * run creation. Every other outcome is opaque and must remain retryable because
+ * it may have committed before the caller stopped waiting.
+ */
+export function isPermanentStartRunError(error: unknown): boolean {
+  return isInterModuleKnownError(workflowsInterModuleContract.methods.startRunFromTrigger, error);
+}
+
+export function isInterpolationUnresolvableError(
+  error: unknown,
+): error is Extract<ReturnType<typeof startRunKnownError>, {code: 'interpolation-unresolvable'}> {
+  return (
+    isInterModuleKnownError(workflowsInterModuleContract.methods.startRunFromTrigger, error) &&
+    error.code === 'interpolation-unresolvable'
+  );
+}
+
+function startRunKnownError(error: unknown) {
+  if (!isInterModuleKnownError(workflowsInterModuleContract.methods.startRunFromTrigger, error)) {
+    return undefined;
+  }
+  return error;
+}

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

@@ -131,3 +131,12 @@ export async function findMatchingJobListenerSubscriptions(
     );
   return rows.map(toJobListenerSubscription);
 }
+
+export async function hasJobListenerSubscriptions(jobId: string): Promise<boolean> {
+  const [subscription] = await db()
+    .select({id: jobListenerSubscriptions.id})
+    .from(jobListenerSubscriptions)
+    .where(eq(jobListenerSubscriptions.jobId, jobId))
+    .limit(1);
+  return subscription !== undefined;
+}

package/src/index.ts

@@ -14,14 +14,16 @@ import {
   WORKFLOWS_JOB_TERMINATED,
   type WorkflowsEventMapDto,
 } from '@shipfox/api-workflows-dto';
+import type {WorkflowsModuleClient} from '@shipfox/api-workflows-dto/inter-module';
 import {type ShipfoxModule, subscriberFactory} from '@shipfox/node-module';
 import {db, migrationsPath, triggersOutbox} from '#db/index.js';
 import {registerTriggersServiceMetrics} from '#metrics/index.js';
-import {routes} from '#presentation/index.js';
+import {triggersE2eRoutes} from '#presentation/e2e-routes.js';
+import {createTriggerRoutes} from '#presentation/index.js';
 import {
+  createOnIntegrationEventReceived,
   onDefinitionDeleted,
   onDefinitionResolved,
-  onIntegrationEventReceived,
   onJobActivated,
   onJobTerminated,
 } from '#presentation/subscribers/index.js';
@@ -66,43 +68,50 @@ const subscriber = subscriberFactory<
   DefinitionsEventMap & IntegrationsEventMap & WorkflowsEventMapDto
 >();
 
-export const triggersModule: ShipfoxModule = {
-  name: 'triggers',
-  database: {db, migrationsPath},
-  routes,
-  metrics: registerTriggersServiceMetrics,
-  publishers: [{name: 'triggers', table: triggersOutbox, db}],
-  subscribers: [
-    subscriber(DEFINITION_RESOLVED, onDefinitionResolved),
-    subscriber(DEFINITION_DELETED, onDefinitionDeleted),
-    subscriber(INTEGRATION_EVENT_RECEIVED, onIntegrationEventReceived),
-    subscriber(WORKFLOWS_JOB_ACTIVATED, onJobActivated),
-    subscriber(WORKFLOWS_JOB_TERMINATED, onJobTerminated),
-  ],
-  workers: [
-    {
-      taskQueue: TRIGGERS_MAINTENANCE_TASK_QUEUE,
-      workflowsPath: temporalWorkflowsPath,
-      activities: createTriggersMaintenanceActivities,
-      workflows: [
-        {
-          name: 'pruneTriggerEventsCron',
-          id: 'triggers-prune-trigger-events',
-          cronSchedule: '0 * * * *',
-        },
-      ],
-    },
-    {
-      taskQueue: TRIGGERS_CRON_TASK_QUEUE,
-      workflowsPath: temporalWorkflowsPath,
-      activities: createTriggersCronActivities,
-      workflows: [
-        {
-          name: 'cronTickCron',
-          id: 'triggers-cron-tick',
-          cronSchedule: '* * * * *',
-        },
-      ],
-    },
-  ],
-};
+export interface CreateTriggersModuleOptions {
+  workflows: WorkflowsModuleClient;
+}
+
+export function createTriggersModule({workflows}: CreateTriggersModuleOptions): ShipfoxModule {
+  return {
+    name: 'triggers',
+    database: {db, migrationsPath},
+    routes: createTriggerRoutes(workflows),
+    e2eRoutes: [triggersE2eRoutes],
+    metrics: registerTriggersServiceMetrics,
+    publishers: [{name: 'triggers', table: triggersOutbox, db}],
+    subscribers: [
+      subscriber(DEFINITION_RESOLVED, onDefinitionResolved),
+      subscriber(DEFINITION_DELETED, onDefinitionDeleted),
+      subscriber(INTEGRATION_EVENT_RECEIVED, createOnIntegrationEventReceived(workflows)),
+      subscriber(WORKFLOWS_JOB_ACTIVATED, onJobActivated),
+      subscriber(WORKFLOWS_JOB_TERMINATED, onJobTerminated),
+    ],
+    workers: [
+      {
+        taskQueue: TRIGGERS_MAINTENANCE_TASK_QUEUE,
+        workflowsPath: temporalWorkflowsPath,
+        activities: createTriggersMaintenanceActivities,
+        workflows: [
+          {
+            name: 'pruneTriggerEventsCron',
+            id: 'triggers-prune-trigger-events',
+            cronSchedule: '0 * * * *',
+          },
+        ],
+      },
+      {
+        taskQueue: TRIGGERS_CRON_TASK_QUEUE,
+        workflowsPath: temporalWorkflowsPath,
+        activities: () => createTriggersCronActivities(workflows),
+        workflows: [
+          {
+            name: 'cronTickCron',
+            id: 'triggers-cron-tick',
+            cronSchedule: '* * * * *',
+          },
+        ],
+      },
+    ],
+  };
+}

package/src/presentation/e2e-routes.test.ts

@@ -0,0 +1,44 @@
+import {closeApp, createApp} from '@shipfox/node-fastify';
+import {projectJobListenerSubscriptions} from '#db/job-listener-subscriptions.js';
+import {triggersE2eRoutes} from './e2e-routes.js';
+
+describe('triggers E2E routes', () => {
+  afterEach(async () => {
+    await closeApp();
+  });
+
+  test('reports a listener without projected subscriptions as not ready', async () => {
+    const jobId = crypto.randomUUID();
+    const app = await createApp({routes: [triggersE2eRoutes], swagger: false});
+
+    const response = await app.inject({
+      method: 'GET',
+      url: `/triggers/listeners/${jobId}/readiness`,
+    });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.json()).toEqual({ready: false});
+  });
+
+  test('reports a listener with projected subscriptions as ready', async () => {
+    const workspaceId = crypto.randomUUID();
+    const workflowRunId = crypto.randomUUID();
+    const jobId = crypto.randomUUID();
+    await projectJobListenerSubscriptions({
+      workspaceId,
+      workflowRunId,
+      jobId,
+      on: [{source: 'listener-source', event: 'received'}],
+      until: null,
+    });
+    const app = await createApp({routes: [triggersE2eRoutes], swagger: false});
+
+    const response = await app.inject({
+      method: 'GET',
+      url: `/triggers/listeners/${jobId}/readiness`,
+    });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.json()).toEqual({ready: true});
+  });
+});

package/src/presentation/e2e-routes.ts

@@ -0,0 +1,24 @@
+import {defineRoute, type RouteGroup} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {hasJobListenerSubscriptions} from '#db/job-listener-subscriptions.js';
+
+const listenerReadinessParamsSchema = z.object({jobId: z.string().uuid()});
+const listenerReadinessResponseSchema = z.object({ready: z.boolean()});
+
+const listenerReadinessRoute = defineRoute({
+  method: 'GET',
+  path: '/listeners/:jobId/readiness',
+  description: 'Report whether trigger subscriptions for a listener job are ready in E2E tests.',
+  schema: {
+    params: listenerReadinessParamsSchema,
+    response: {200: listenerReadinessResponseSchema},
+  },
+  handler: async (request) => ({
+    ready: await hasJobListenerSubscriptions(request.params.jobId),
+  }),
+});
+
+export const triggersE2eRoutes: RouteGroup = {
+  prefix: '/triggers',
+  routes: [listenerReadinessRoute],
+};

package/src/presentation/index.ts

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

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

@@ -1,5 +1,9 @@
 import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
-import type {WorkflowRun} from '@shipfox/api-workflows';
+import {
+  type WorkflowsModuleClient,
+  workflowsInterModuleContract,
+} from '@shipfox/api-workflows-dto/inter-module';
+import {createInterModuleKnownError} from '@shipfox/inter-module';
 import type {FastifyInstance} from 'fastify';
 import Fastify from 'fastify';
 import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
@@ -7,33 +11,13 @@ 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 {createFireManualTriggerRoute} = await import('./fire-manual.js');
 
-const {fireManualTriggerRoute} = await import('./fire-manual.js');
+const workflows = {} as WorkflowsModuleClient;
 
 describe('POST /:definitionId/fire-manual', () => {
   let app: FastifyInstance;
@@ -51,7 +35,7 @@ describe('POST /:definitionId/fire-manual', () => {
       );
       done();
     });
-    app.post('/:definitionId/fire-manual', fireManualTriggerRoute);
+    app.post('/:definitionId/fire-manual', createFireManualTriggerRoute(workflows));
     await app.ready();
   });
 
@@ -65,7 +49,7 @@ describe('POST /:definitionId/fire-manual', () => {
     const definitionId = crypto.randomUUID();
     const runId = crypto.randomUUID();
     await triggerSubscriptionFactory.create({workspaceId, workflowDefinitionId: definitionId});
-    fireManualSubscriptionMock.mockResolvedValue({id: runId} satisfies Pick<WorkflowRun, 'id'>);
+    fireManualSubscriptionMock.mockResolvedValue({id: runId, name: 'Manual run'});
 
     const res = await app.inject({
       method: 'POST',
@@ -81,11 +65,11 @@ describe('POST /:definitionId/fire-manual', () => {
     const definitionId = crypto.randomUUID();
     await triggerSubscriptionFactory.create({workspaceId, workflowDefinitionId: definitionId});
     fireManualSubscriptionMock.mockRejectedValue(
-      new InterpolationUnresolvableError(definitionId, {
-        field: 'env',
-        source: 'event.ref',
-        envKey: 'REF',
-      }),
+      createInterModuleKnownError(
+        workflowsInterModuleContract.methods.startRunFromTrigger,
+        'interpolation-unresolvable',
+        {definitionId, field: 'env', source: 'event.ref', envKey: 'REF'},
+      ),
     );
 
     const res = await app.inject({