@shipfox/api-triggers 4.0.0 → 6.0.0

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

@@ -3,68 +3,76 @@ import {
   fireManualTriggerBodySchema,
   fireManualTriggerResponseSchema,
 } from '@shipfox/api-triggers-dto';
-import {InterpolationUnresolvableError} from '@shipfox/api-workflows';
+import type {WorkflowsModuleClient} from '@shipfox/api-workflows-dto/inter-module';
 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 {isInterpolationUnresolvableError} from '#core/workflows-client.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(),
-        }),
+export function createFireManualTriggerRoute(workflows: WorkflowsModuleClient) {
+  return 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);
+    errorHandler: (error) => {
+      if (error instanceof ManualTriggerNotFoundError) {
+        throw new ClientError(error.message, 'manual-trigger-not-found', {status: 404});
+      }
+      if (isInterpolationUnresolvableError(error)) {
+        throw new ClientError(
+          'Workflow interpolation cannot be resolved',
+          'workflow-interpolation-unresolvable',
+          {
+            status: 422,
+            details: {
+              field: error.details.field,
+              source: error.details.source,
+              ...(error.details.envKey === undefined ? {} : {env_key: error.details.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 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,
-    });
+      const run = await fireManualSubscription({
+        workflows,
+        subscriptionId: subscription.id,
+        callerWorkspaceId: subscription.workspaceId,
+        userId: userContext.userId,
+        inputs: request.body.inputs,
+      });
 
-    reply.status(201);
-    return {workflow_run_id: run.id};
-  },
-});
+      reply.status(201);
+      return {workflow_run_id: run.id};
+    },
+  });
+}

package/src/presentation/routes/index.ts

@@ -1,21 +1,24 @@
 import {AUTH_USER} from '@shipfox/api-auth-context';
+import type {WorkflowsModuleClient} from '@shipfox/api-workflows-dto/inter-module';
 import type {RouteGroup} from '@shipfox/node-fastify';
-import {fireManualTriggerRoute} from './fire-manual.js';
+import {createFireManualTriggerRoute} 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],
-  },
-];
+export function createTriggerRoutes(workflows: WorkflowsModuleClient): RouteGroup[] {
+  return [
+    {
+      prefix: '/workflow-definitions',
+      auth: AUTH_USER,
+      routes: [createFireManualTriggerRoute(workflows)],
+    },
+    {
+      // 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/subscribers/index.ts

@@ -1,5 +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 {createOnIntegrationEventReceived} 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-integration-event-received.test.ts

@@ -1,4 +1,5 @@
 import type {IntegrationEventReceivedEvent} from '@shipfox/api-integration-core-dto';
+import type {WorkflowsModuleClient} from '@shipfox/api-workflows-dto/inter-module';
 import type {DomainEvent} from '@shipfox/node-outbox';
 
 const dispatchIntegrationEvent = vi.fn();
@@ -7,8 +8,9 @@ vi.mock('#core/dispatch-integration-event.js', () => ({
   dispatchIntegrationEvent: (...args: unknown[]) => dispatchIntegrationEvent(...args),
 }));
 
-// Import after mocks so the subscriber sees the spy.
-const {onIntegrationEventReceived} = await import('./on-integration-event-received.js');
+const {createOnIntegrationEventReceived} = await import('./on-integration-event-received.js');
+
+const workflows = {} as WorkflowsModuleClient;
 
 describe('onIntegrationEventReceived', () => {
   beforeEach(() => {
@@ -35,9 +37,10 @@ describe('onIntegrationEventReceived', () => {
       payload: envelope,
     };
 
-    await onIntegrationEventReceived(envelope, event);
+    await createOnIntegrationEventReceived(workflows)(envelope, event);
 
     expect(dispatchIntegrationEvent).toHaveBeenCalledWith({
+      workflows,
       eventRef: event.id,
       workspaceId: envelope.workspaceId,
       provider: envelope.provider,

package/src/presentation/subscribers/on-integration-event-received.ts

@@ -1,21 +1,25 @@
 import type {IntegrationEventReceivedEvent} from '@shipfox/api-integration-core-dto';
+import type {WorkflowsModuleClient} from '@shipfox/api-workflows-dto/inter-module';
 import type {DomainEvent} from '@shipfox/node-outbox';
 import {dispatchIntegrationEvent} from '#core/dispatch-integration-event.js';
 
-export async function onIntegrationEventReceived(
-  envelope: IntegrationEventReceivedEvent,
-  event: DomainEvent<IntegrationEventReceivedEvent>,
-): Promise<void> {
-  await dispatchIntegrationEvent({
-    eventRef: event.id,
-    workspaceId: envelope.workspaceId,
-    provider: envelope.provider,
-    source: envelope.source,
-    event: envelope.event,
-    deliveryId: envelope.deliveryId,
-    connectionId: envelope.connectionId,
-    connectionName: envelope.connectionName ?? null,
-    payload: envelope.payload,
-    receivedAt: new Date(envelope.receivedAt),
-  });
+export function createOnIntegrationEventReceived(workflows: WorkflowsModuleClient) {
+  return async function onIntegrationEventReceived(
+    envelope: IntegrationEventReceivedEvent,
+    event: DomainEvent<IntegrationEventReceivedEvent>,
+  ): Promise<void> {
+    await dispatchIntegrationEvent({
+      workflows,
+      eventRef: event.id,
+      workspaceId: envelope.workspaceId,
+      provider: envelope.provider,
+      source: envelope.source,
+      event: envelope.event,
+      deliveryId: envelope.deliveryId,
+      connectionId: envelope.connectionId,
+      connectionName: envelope.connectionName ?? null,
+      payload: envelope.payload,
+      receivedAt: new Date(envelope.receivedAt),
+    });
+  };
 }

package/src/temporal/activities/drain-cron-batch.ts

@@ -1,10 +1,14 @@
+import type {WorkflowsModuleClient} from '@shipfox/api-workflows-dto/inter-module';
 import {Context} from '@temporalio/activity';
 import {config} from '#config.js';
 import {type CronDrainSummary, drainDueCronSchedules} from '#core/drain-cron-schedules.js';
 
-export async function drainCronBatchActivity(): Promise<CronDrainSummary> {
+export async function drainCronBatchActivity(
+  workflows: WorkflowsModuleClient,
+): Promise<CronDrainSummary> {
   const ctx = Context.current();
   return await drainDueCronSchedules({
+    workflows,
     batchSize: config.TRIGGER_CRON_CLAIM_BATCH,
     jitterWindowSeconds: config.TRIGGER_CRON_JITTER_WINDOW_SECONDS,
     onScheduleProcessed: () => ctx.heartbeat(),

package/src/temporal/activities/index.ts

@@ -1,3 +1,4 @@
+import type {WorkflowsModuleClient} from '@shipfox/api-workflows-dto/inter-module';
 import {drainCronBatchActivity, readCronFanoutActivity} from './drain-cron-batch.js';
 import {pruneTriggerEventsActivity} from './prune-trigger-events.js';
 
@@ -7,9 +8,9 @@ export function createTriggersMaintenanceActivities() {
   };
 }
 
-export function createTriggersCronActivities() {
+export function createTriggersCronActivities(workflows: WorkflowsModuleClient) {
   return {
-    drainCronBatchActivity,
+    drainCronBatchActivity: () => drainCronBatchActivity(workflows),
     readCronFanoutActivity,
   };
 }