@shipfox/api-workspaces 9.1.0 → 9.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-workspaces",
   "license": "MIT",
-  "version": "9.1.0",
+  "version": "9.3.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -24,17 +24,17 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@shipfox/api-common-dto": "9.0.2",
-    "@shipfox/api-auth-context": "9.0.3",
-    "@shipfox/api-workspaces-dto": "9.0.2",
+    "@shipfox/api-common-dto": "9.2.0",
+    "@shipfox/api-auth-context": "9.3.0",
+    "@shipfox/api-workspaces-dto": "9.3.0",
     "@shipfox/config": "1.2.4",
     "@shipfox/inter-module": "0.2.2",
     "@shipfox/node-drizzle": "0.3.4",
-    "@shipfox/node-fastify": "0.3.3",
+    "@shipfox/node-fastify": "0.3.4",
     "@shipfox/node-email": "0.3.4",
-    "@shipfox/node-mailer": "0.2.3",
-    "@shipfox/node-module": "1.0.2",
-    "@shipfox/node-opentelemetry": "0.6.2",
+    "@shipfox/node-mailer": "0.2.4",
+    "@shipfox/node-module": "1.0.3",
+    "@shipfox/node-opentelemetry": "0.6.3",
     "@shipfox/node-outbox": "0.2.6",
     "@shipfox/node-postgres": "0.4.4",
     "@shipfox/node-tokens": "0.3.2"

package/src/core/workspaces.test.ts

@@ -3,9 +3,14 @@ import {sql} from 'drizzle-orm';
 import {db} from '#db/db.js';
 import {findMembership} from '#db/memberships.js';
 import {workspacesOutbox} from '#db/schema/outbox.js';
+import {updateWorkspace} from '#db/workspaces.js';
 import {userFactory} from '#test/index.js';
 import {MembershipRequiredError, WorkspaceNotFoundError} from './errors.js';
-import {createWorkspaceForUser, requireWorkspaceMembership} from './workspaces.js';
+import {
+  createWorkspaceForUser,
+  getWorkspaceOperatingState,
+  requireWorkspaceMembership,
+} from './workspaces.js';
 
 describe('workspaces core', () => {
   test('createWorkspaceForUser creates a workspace and membership for the user', async () => {
@@ -67,6 +72,19 @@ describe('workspaces core', () => {
     expect(result.role).toBe('admin');
   });
 
+  test('getWorkspaceOperatingState returns the current status without workspace details', async () => {
+    const workspace = await createWorkspaceForUser({
+      name: 'Operating State Workspace',
+      userId: crypto.randomUUID(),
+    });
+
+    expect(await getWorkspaceOperatingState({workspaceId: workspace.id})).toBe('active');
+
+    await updateWorkspace({id: workspace.id, status: 'suspended'});
+
+    expect(await getWorkspaceOperatingState({workspaceId: workspace.id})).toBe('suspended');
+  });
+
   test('requireWorkspaceMembership rejects when memberships do not include the workspace', async () => {
     const owner = userFactory.build();
     const outsider = userFactory.build();

package/src/core/workspaces.ts

@@ -106,6 +106,13 @@ export async function getWorkspaceCreator(params: {workspaceId: string}): Promis
   return workspace.createdBy;
 }
 
+export async function getWorkspaceOperatingState(params: {
+  workspaceId: string;
+}): Promise<Workspace['status']> {
+  const workspace = await getWorkspace(params);
+  return workspace.status;
+}
+
 export async function listUserWorkspaceMemberships(params: {
   userId: string;
 }): Promise<MembershipWithWorkspace[]> {

package/src/presentation/inter-module.test.ts

@@ -3,7 +3,7 @@ import {isInterModuleKnownError} from '@shipfox/inter-module';
 import {createInMemoryInterModuleTransport} from '@shipfox/node-module/inter-module';
 import {createWorkspaceForUser} from '#core/workspaces.js';
 import {createMembership, removeMembership} from '#db/memberships.js';
-import {createWorkspace} from '#db/workspaces.js';
+import {createWorkspace, updateWorkspace} from '#db/workspaces.js';
 import {createWorkspacesInterModulePresentation} from './inter-module.js';
 
 function createClient() {
@@ -54,6 +54,21 @@ describe('Workspaces inter-module presentation', () => {
     expect(result).toEqual({creatorUserId: null});
   });
 
+  test('returns only the current workspace operating state', async () => {
+    const client = createClient();
+    const workspace = await createWorkspace({name: 'Operating State Workspace'});
+
+    expect(await client.getWorkspaceOperatingState({workspaceId: workspace.id})).toEqual({
+      status: 'active',
+    });
+
+    await updateWorkspace({id: workspace.id, status: 'suspended'});
+
+    expect(await client.getWorkspaceOperatingState({workspaceId: workspace.id})).toEqual({
+      status: 'suspended',
+    });
+  });
+
   test('maps a missing workspace to the published known error', async () => {
     const client = createClient();
     const workspaceId = crypto.randomUUID();
@@ -68,4 +83,27 @@ describe('Workspaces inter-module presentation', () => {
       expect(error.details).toEqual({workspaceId});
     }
   });
+
+  test('maps a missing operating-state workspace to the published known error', async () => {
+    const client = createClient();
+    const workspaceId = crypto.randomUUID();
+
+    const error = await client.getWorkspaceOperatingState({workspaceId}).catch((caught) => caught);
+
+    expect(
+      isInterModuleKnownError(
+        workspacesInterModuleContract.methods.getWorkspaceOperatingState,
+        error,
+      ),
+    ).toBe(true);
+    if (
+      isInterModuleKnownError(
+        workspacesInterModuleContract.methods.getWorkspaceOperatingState,
+        error,
+      )
+    ) {
+      expect(error.code).toBe('workspace-not-found');
+      expect(error.details).toEqual({workspaceId});
+    }
+  });
 });

package/src/presentation/inter-module.ts

@@ -14,7 +14,11 @@ import {
   WorkspaceNotFoundError,
 } from '#core/errors.js';
 import {acceptWorkspaceInvitation, peekInvitationByRawToken} from '#core/invitations.js';
-import {getWorkspaceCreator, requireWorkspaceMembership} from '#core/workspaces.js';
+import {
+  getWorkspaceCreator,
+  getWorkspaceOperatingState,
+  requireWorkspaceMembership,
+} from '#core/workspaces.js';
 import {listMembershipsByUser} from '#db/memberships.js';
 
 export function createWorkspacesInterModulePresentation(): InterModulePresentation<
@@ -41,6 +45,20 @@ export function createWorkspacesInterModulePresentation(): InterModulePresentati
         throw error;
       }
     },
+    getWorkspaceOperatingState: async (input) => {
+      try {
+        return {status: await getWorkspaceOperatingState(input)};
+      } catch (error) {
+        if (error instanceof WorkspaceNotFoundError) {
+          throw createInterModuleKnownError(
+            workspacesInterModuleContract.methods.getWorkspaceOperatingState,
+            'workspace-not-found',
+            {workspaceId: input.workspaceId},
+          );
+        }
+        throw error;
+      }
+    },
     preflightInvitationAcceptance: async (input) => {
       try {
         const invitation = await peekInvitationByRawToken({token: input.token});