@shipfox/api-triggers 9.2.0 → 10.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-triggers",
   "license": "MIT",
-  "version": "9.2.0",
+  "version": "10.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -22,22 +22,22 @@
     "cron-parser": "^5.6.1",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@shipfox/api-auth-context": "9.2.0",
-    "@shipfox/api-definitions-dto": "9.0.2",
+    "@shipfox/api-auth-context": "10.0.0",
+    "@shipfox/api-definitions-dto": "10.0.0",
     "@shipfox/api-integration-core-dto": "9.0.2",
     "@shipfox/api-triggers-dto": "9.0.2",
-    "@shipfox/api-workflows-dto": "9.0.2",
+    "@shipfox/api-workflows-dto": "10.0.0",
     "@shipfox/config": "1.2.4",
-    "@shipfox/expression": "1.1.5",
+    "@shipfox/expression": "1.2.0",
     "@shipfox/inter-module": "0.2.2",
     "@shipfox/node-drizzle": "0.3.4",
     "@shipfox/node-error-monitoring": "0.3.0",
-    "@shipfox/node-fastify": "0.3.3",
-    "@shipfox/node-module": "1.0.2",
-    "@shipfox/node-opentelemetry": "0.6.2",
+    "@shipfox/node-fastify": "0.4.0",
+    "@shipfox/node-module": "1.0.4",
+    "@shipfox/node-opentelemetry": "0.6.3",
     "@shipfox/node-outbox": "0.2.6",
     "@shipfox/node-postgres": "0.4.4",
-    "@shipfox/node-temporal": "0.4.3",
+    "@shipfox/node-temporal": "0.4.4",
     "@shipfox/workflow-document": "2.1.3"
   },
   "imports": {

package/src/core/dispatch-integration-event.ts

@@ -29,8 +29,9 @@ export interface DispatchIntegrationEventParams {
 // nothing about github, gitlab, etc.
 //
 // Continue-on-error: every matched subscription and listener is attempted so one broken
-// subscription cannot starve its siblings. A permanent failure (deleted definition, project
-// mismatch) is recorded and skipped; a transient one is recorded and re-thrown so the outbox
+// subscription cannot starve its siblings. A permanent admission failure (deleted definition,
+// project mismatch, suspended workspace) is recorded and skipped; a transient one is recorded
+// and re-thrown so the outbox
 // replays the whole event and converges (succeeded siblings dedup on the idempotency key). The
 // event reaches a terminal outcome only when no transient error remains: `routed` if any run
 // was created or any listening job matched, `discarded` if nothing matched, otherwise `errored`.

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

@@ -1,3 +1,5 @@
+import {workflowsInterModuleContract} from '@shipfox/api-workflows-dto/inter-module';
+import {createInterModuleKnownError} from '@shipfox/inter-module';
 import {jobListenerSubscriptionFactory} from '#test/index.js';
 import type {TriggerHistoryRecorder} from './record-trigger-history.js';
 
@@ -195,6 +197,34 @@ describe('routeEventToJobListeners', () => {
     });
   });
 
+  it.each([
+    'workspace-not-found',
+    'workspace-suspended',
+    'workspace-deleted',
+  ] as const)('does not retry a %s workspace listener delivery', async (code) => {
+    const workspaceId = crypto.randomUUID();
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      source: 'github',
+      event: 'pull_request_review',
+    });
+    const error = createInterModuleKnownError(
+      workflowsInterModuleContract.methods.deliverEventToJobListener,
+      code,
+      {workspaceId},
+    );
+    deliverEventToListener.mockRejectedValueOnce(error);
+
+    const result = await route({workspaceId});
+
+    expect(listenerDispatchErrored).toHaveBeenCalledTimes(1);
+    expect(result).toMatchObject({
+      engagedCount: 1,
+      acceptedJobCount: 0,
+      transientErrored: false,
+    });
+  });
+
   it('delivers only when a listener filter matches the payload and snapshot', async () => {
     const workspaceId = crypto.randomUUID();
     const jobId = crypto.randomUUID();

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

@@ -3,7 +3,10 @@ import {findMatchingJobListenerSubscriptions} from '#db/job-listener-subscriptio
 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';
+import {
+  isPermanentDeliverEventToJobListenerError,
+  type WorkflowsModuleClient,
+} from './workflows-client.js';
 
 export interface RouteEventToJobListenersParams {
   workflows: WorkflowsModuleClient;
@@ -90,7 +93,7 @@ export async function routeEventToJobListeners(
     } catch (error) {
       dispatchErrorCount += 1;
       await params.history.listenerDispatchErrored(subscription, toReason(error));
-      if (!sawTransientError) {
+      if (!isPermanentDeliverEventToJobListenerError(error) && !sawTransientError) {
         sawTransientError = true;
         firstTransientError = error;
       }

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

@@ -8,7 +8,10 @@ import {
   defineInterModulePresentation,
 } from '@shipfox/inter-module';
 import {createFakeInterModuleClients} from '@shipfox/node-module/inter-module/testing';
-import {isPermanentStartRunError} from './workflows-client.js';
+import {
+  isPermanentDeliverEventToJobListenerError,
+  isPermanentStartRunError,
+} from './workflows-client.js';
 
 const input = {
   workspaceId: '00000000-0000-4000-8000-000000000001',
@@ -24,6 +27,20 @@ const input = {
   idempotencyKey: 'subscription-1:event-1',
 };
 
+const listenerInput = {
+  jobId: '00000000-0000-4000-8000-000000000006',
+  disposition: 'fire' as const,
+  eventRef: 'event-1',
+  deliveryId: 'delivery-1',
+  source: 'github',
+  event: 'push',
+  provider: 'github',
+  payload: {action: 'opened'},
+  receivedAt: '2026-07-26T00:00:00.000Z',
+};
+
+const listenerErrorInput = {...listenerInput, jobId: '00000000-0000-4000-8000-000000000007'};
+
 function localWorkflowsClient(): WorkflowsModuleClient {
   return createFakeInterModuleClients({
     workflows: defineInterModulePresentation(workflowsInterModuleContract, {
@@ -35,7 +52,16 @@ function localWorkflowsClient(): WorkflowsModuleClient {
           {definitionId},
         );
       },
-      deliverEventToJobListener: () => ({buffered: true, skipped: false}),
+      deliverEventToJobListener: ({jobId}) => {
+        if (jobId === listenerErrorInput.jobId) {
+          throw createInterModuleKnownError(
+            workflowsInterModuleContract.methods.deliverEventToJobListener,
+            'workspace-not-found',
+            {workspaceId: input.workspaceId},
+          );
+        }
+        return {buffered: true, skipped: false};
+      },
       getStepLogContext: () => ({harness: 'pi' as const}),
       getLeasedAgentToolContext: () => ({
         workspaceId: '00000000-0000-4000-8000-000000000006',
@@ -61,6 +87,15 @@ async function runConsumerSuite(client: WorkflowsModuleClient): Promise<void> {
 
   const result = client.startRunFromTrigger({...input, definitionId: crypto.randomUUID()});
   await expect(result).rejects.toSatisfy(isPermanentStartRunError);
+
+  await expect(client.deliverEventToJobListener(listenerInput)).resolves.toEqual({
+    buffered: true,
+    skipped: false,
+  });
+  await expect(client.deliverEventToJobListener(listenerErrorInput)).rejects.toMatchObject({
+    code: 'workspace-not-found',
+    details: {workspaceId: input.workspaceId},
+  });
 }
 
 describe('WorkflowsModuleClient consumer parity', () => {
@@ -70,4 +105,18 @@ describe('WorkflowsModuleClient consumer parity', () => {
     await runConsumerSuite(local);
     await runConsumerSuite(serializedWorkflowsClient(local));
   });
+
+  test.each([
+    'workspace-not-found',
+    'workspace-suspended',
+    'workspace-deleted',
+  ] as const)('treats a %s listener delivery as permanent', (code) => {
+    const error = createInterModuleKnownError(
+      workflowsInterModuleContract.methods.deliverEventToJobListener,
+      code,
+      {workspaceId: input.workspaceId},
+    );
+
+    expect(isPermanentDeliverEventToJobListenerError(error)).toBe(true);
+  });
 });

package/src/core/workflows-client.ts

@@ -6,15 +6,44 @@ import {isInterModuleKnownError} from '@shipfox/inter-module';
 
 export type {WorkflowsModuleClient};
 
+type StartRunKnownError = NonNullable<ReturnType<typeof startRunKnownError>>;
+
 /**
  * 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.
+ * run creation, including workspace admission failures. 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 {
+export function isPermanentStartRunError(error: unknown): error is StartRunKnownError {
   return isInterModuleKnownError(workflowsInterModuleContract.methods.startRunFromTrigger, error);
 }
 
+/** Known listener admission failures cannot succeed by replaying the same event. */
+export function isPermanentDeliverEventToJobListenerError(error: unknown): boolean {
+  return isInterModuleKnownError(
+    workflowsInterModuleContract.methods.deliverEventToJobListener,
+    error,
+  );
+}
+
+export function isWorkspaceSuspendedError(
+  error: unknown,
+): error is Extract<StartRunKnownError, {code: 'workspace-suspended'}> {
+  return isPermanentStartRunError(error) && error.code === 'workspace-suspended';
+}
+
+export function isWorkspaceNotFoundError(
+  error: unknown,
+): error is Extract<StartRunKnownError, {code: 'workspace-not-found'}> {
+  return isPermanentStartRunError(error) && error.code === 'workspace-not-found';
+}
+
+export function isWorkspaceDeletedError(
+  error: unknown,
+): error is Extract<StartRunKnownError, {code: 'workspace-deleted'}> {
+  return isPermanentStartRunError(error) && error.code === 'workspace-deleted';
+}
+
 export function isInterpolationUnresolvableError(
   error: unknown,
 ): error is Extract<ReturnType<typeof startRunKnownError>, {code: 'interpolation-unresolvable'}> {

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

@@ -89,6 +89,72 @@ describe('POST /:definitionId/fire-manual', () => {
     });
   });
 
+  test('maps suspended workspace to 409', async () => {
+    const definitionId = crypto.randomUUID();
+    await triggerSubscriptionFactory.create({workspaceId, workflowDefinitionId: definitionId});
+    fireManualSubscriptionMock.mockRejectedValue(
+      createInterModuleKnownError(
+        workflowsInterModuleContract.methods.startRunFromTrigger,
+        'workspace-suspended',
+        {workspaceId},
+      ),
+    );
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/${definitionId}/fire-manual`,
+      payload: {},
+    });
+
+    expect(res.statusCode).toBe(409);
+    expect(res.json()).toMatchObject({
+      code: 'workspace-suspended',
+      message: 'Workspace is suspended',
+    });
+  });
+
+  test('maps missing workspace to 404', async () => {
+    const definitionId = crypto.randomUUID();
+    await triggerSubscriptionFactory.create({workspaceId, workflowDefinitionId: definitionId});
+    fireManualSubscriptionMock.mockRejectedValue(
+      createInterModuleKnownError(
+        workflowsInterModuleContract.methods.startRunFromTrigger,
+        'workspace-not-found',
+        {workspaceId},
+      ),
+    );
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/${definitionId}/fire-manual`,
+      payload: {},
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json()).toMatchObject({code: 'workspace-not-found', message: 'Workspace not found'});
+  });
+
+  test('maps deleted workspace to 404', async () => {
+    const definitionId = crypto.randomUUID();
+    await triggerSubscriptionFactory.create({workspaceId, workflowDefinitionId: definitionId});
+    fireManualSubscriptionMock.mockRejectedValue(
+      createInterModuleKnownError(
+        workflowsInterModuleContract.methods.startRunFromTrigger,
+        'workspace-deleted',
+        {workspaceId},
+      ),
+    );
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/${definitionId}/fire-manual`,
+      payload: {},
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json()).toMatchObject({code: 'workspace-deleted', message: 'Workspace is deleted'});
+  });
+
   test('returns 404 when the manual trigger is unavailable', async () => {
     const res = await app.inject({
       method: 'POST',

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

@@ -8,7 +8,12 @@ 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 {
+  isInterpolationUnresolvableError,
+  isWorkspaceDeletedError,
+  isWorkspaceNotFoundError,
+  isWorkspaceSuspendedError,
+} from '#core/workflows-client.js';
 import {getManualSubscriptionByDefinitionId} from '#db/subscriptions.js';
 
 export function createFireManualTriggerRoute(workflows: WorkflowsModuleClient) {
@@ -37,6 +42,24 @@ export function createFireManualTriggerRoute(workflows: WorkflowsModuleClient) {
       if (error instanceof ManualTriggerNotFoundError) {
         throw new ClientError(error.message, 'manual-trigger-not-found', {status: 404});
       }
+      if (isWorkspaceSuspendedError(error)) {
+        throw new ClientError('Workspace is suspended', 'workspace-suspended', {
+          status: 409,
+          cause: error,
+        });
+      }
+      if (isWorkspaceDeletedError(error)) {
+        throw new ClientError('Workspace is deleted', 'workspace-deleted', {
+          status: 404,
+          cause: error,
+        });
+      }
+      if (isWorkspaceNotFoundError(error)) {
+        throw new ClientError('Workspace not found', 'workspace-not-found', {
+          status: 404,
+          cause: error,
+        });
+      }
       if (isInterpolationUnresolvableError(error)) {
         throw new ClientError(
           'Workflow interpolation cannot be resolved',