@shipfox/api-workflows 9.2.0 → 9.3.0

package/src/presentation/routes/rerun-run.test.ts

@@ -1,5 +1,10 @@
 import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
 import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
+import {
+  type WorkspacesInterModuleClient,
+  workspacesInterModuleContract,
+} from '@shipfox/api-workspaces-dto/inter-module';
+import {createInterModuleKnownError} from '@shipfox/inter-module';
 import {ClientError} from '@shipfox/node-fastify';
 import type {FastifyInstance} from 'fastify';
 import Fastify from 'fastify';
@@ -20,6 +25,8 @@ const projects = {
   getProjectById,
   requireProjectForWorkspace: vi.fn(),
 } as unknown as ProjectsModuleClient;
+const getWorkspaceOperatingState = vi.fn();
+const workspaces = {getWorkspaceOperatingState} as unknown as WorkspacesInterModuleClient;
 
 describe('POST /api/workflows/runs/:id/rerun', () => {
   let app: FastifyInstance;
@@ -41,7 +48,7 @@ describe('POST /api/workflows/runs/:id/rerun', () => {
       );
       done();
     });
-    app.post('/api/workflows/runs/:id/rerun', rerunRunRoute(projects));
+    app.post('/api/workflows/runs/:id/rerun', rerunRunRoute(projects, workspaces));
     await app.ready();
   });
 
@@ -60,6 +67,7 @@ describe('POST /api/workflows/runs/:id/rerun', () => {
         },
       }),
     );
+    getWorkspaceOperatingState.mockResolvedValue({status: 'active'});
   });
 
   async function createTerminalRun(status: 'succeeded' | 'failed' = 'failed') {
@@ -135,6 +143,55 @@ describe('POST /api/workflows/runs/:id/rerun', () => {
     expect(res.json().code).toBe('no-failed-jobs');
   });
 
+  test('returns workspace-suspended before creating a new attempt', async () => {
+    const source = await createTerminalRun('failed');
+    getWorkspaceOperatingState.mockResolvedValueOnce({status: 'suspended'});
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/api/workflows/runs/${source.id}/rerun`,
+      payload: {mode: 'all'},
+    });
+
+    expect(res.statusCode).toBe(409);
+    expect(res.json().code).toBe('workspace-suspended');
+    expect(getWorkspaceOperatingState).toHaveBeenCalledWith({workspaceId});
+  });
+
+  test('returns workspace-deleted before creating a new attempt', async () => {
+    const source = await createTerminalRun('failed');
+    getWorkspaceOperatingState.mockResolvedValueOnce({status: 'deleted'});
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/api/workflows/runs/${source.id}/rerun`,
+      payload: {mode: 'all'},
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('workspace-deleted');
+  });
+
+  test('returns workspace-not-found before creating a new attempt', async () => {
+    const source = await createTerminalRun('failed');
+    getWorkspaceOperatingState.mockRejectedValueOnce(
+      createInterModuleKnownError(
+        workspacesInterModuleContract.methods.getWorkspaceOperatingState,
+        'workspace-not-found',
+        {workspaceId},
+      ),
+    );
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/api/workflows/runs/${source.id}/rerun`,
+      payload: {mode: 'all'},
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('workspace-not-found');
+  });
+
   test('returns 409 when the source run is not terminal', async () => {
     const source = await createWorkflowRun({
       workspaceId,

package/src/presentation/routes/rerun-run.ts

@@ -1,14 +1,26 @@
 import {requireUserContext} from '@shipfox/api-auth-context';
 import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
 import {rerunWorkflowRunBodySchema, workflowRunResponseSchema} from '@shipfox/api-workflows-dto';
+import type {WorkspacesInterModuleClient} from '@shipfox/api-workspaces-dto/inter-module';
 import {ClientError, defineRoute} from '@shipfox/node-fastify';
 import {z} from 'zod';
-import {NoFailedJobsError, RunNotTerminalError, SourceRunNotFoundError} from '#core/errors.js';
+import {
+  NoFailedJobsError,
+  RunNotTerminalError,
+  SourceRunNotFoundError,
+  WorkspaceDeletedError,
+  WorkspaceNotFoundError,
+  WorkspaceSuspendedError,
+} from '#core/errors.js';
+import {assertWorkspaceAdmitsNewJobs} from '#core/workspace-admission.js';
 import {createRerunWorkflowRun} from '#db/index.js';
 import {toRunDto} from '#presentation/dto/index.js';
 import {requireAccessibleRun} from './require-accessible-run.js';
 
-export function rerunRunRoute(projects: ProjectsModuleClient) {
+export function rerunRunRoute(
+  projects: ProjectsModuleClient,
+  workspaces: WorkspacesInterModuleClient,
+) {
   return defineRoute({
     method: 'POST',
     path: '/:id/rerun',
@@ -32,12 +44,32 @@ export function rerunRunRoute(projects: ProjectsModuleClient) {
       if (error instanceof NoFailedJobsError) {
         throw new ClientError('Run has no failed jobs', 'no-failed-jobs', {status: 409});
       }
+      if (error instanceof WorkspaceSuspendedError) {
+        throw new ClientError('Workspace is suspended', 'workspace-suspended', {
+          status: 409,
+          cause: error,
+        });
+      }
+      if (error instanceof WorkspaceDeletedError) {
+        throw new ClientError('Workspace is deleted', 'workspace-deleted', {
+          status: 404,
+          cause: error,
+        });
+      }
+      if (error instanceof WorkspaceNotFoundError) {
+        throw new ClientError('Workspace not found', 'workspace-not-found', {
+          status: 404,
+          cause: error,
+        });
+      }
       throw error;
     },
     handler: async (request) => {
       const {id} = request.params;
       const sourceRun = await requireAccessibleRun({request, id, projects});
 
+      await assertWorkspaceAdmitsNewJobs(workspaces, sourceRun.workspaceId);
+
       const actor = requireUserContext(request);
       const run = await createRerunWorkflowRun({
         workflowRunId: sourceRun.id,