@shipfox/api-workspaces 7.0.1 → 9.0.1

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

@@ -0,0 +1,71 @@
+import {workspacesInterModuleContract} from '@shipfox/api-workspaces-dto/inter-module';
+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 {createWorkspacesInterModulePresentation} from './inter-module.js';
+
+function createClient() {
+  const transport = createInMemoryInterModuleTransport();
+  const client = transport.createClient(workspacesInterModuleContract);
+  transport.register(createWorkspacesInterModulePresentation());
+  transport.seal();
+  return client;
+}
+
+describe('Workspaces inter-module presentation', () => {
+  test('resolves the workspace creator through the transport', async () => {
+    const client = createClient();
+    const creatorUserId = crypto.randomUUID();
+    const workspace = await createWorkspaceForUser({
+      name: 'Creator Workspace',
+      userId: creatorUserId,
+    });
+    await createMembership({workspaceId: workspace.id, userId: crypto.randomUUID()});
+
+    const result = await client.getWorkspaceCreator({workspaceId: workspace.id});
+
+    expect(result).toEqual({creatorUserId});
+  });
+
+  test('keeps attributing the workspace to its creator after the creator leaves', async () => {
+    const client = createClient();
+    const creatorUserId = crypto.randomUUID();
+    const workspace = await createWorkspaceForUser({
+      name: 'Outlasted Creator Workspace',
+      userId: creatorUserId,
+    });
+    const remainingUserId = crypto.randomUUID();
+    await createMembership({workspaceId: workspace.id, userId: remainingUserId});
+
+    await removeMembership({userId: creatorUserId, workspaceId: workspace.id});
+    const result = await client.getWorkspaceCreator({workspaceId: workspace.id});
+
+    expect(result).toEqual({creatorUserId});
+  });
+
+  test('returns null when a workspace has no known creator', async () => {
+    const client = createClient();
+    const workspace = await createWorkspace({name: 'Unattributed Workspace'});
+
+    const result = await client.getWorkspaceCreator({workspaceId: workspace.id});
+
+    expect(result).toEqual({creatorUserId: null});
+  });
+
+  test('maps a missing workspace to the published known error', async () => {
+    const client = createClient();
+    const workspaceId = crypto.randomUUID();
+
+    const error = await client.getWorkspaceCreator({workspaceId}).catch((caught) => caught);
+
+    expect(
+      isInterModuleKnownError(workspacesInterModuleContract.methods.getWorkspaceCreator, error),
+    ).toBe(true);
+    if (isInterModuleKnownError(workspacesInterModuleContract.methods.getWorkspaceCreator, error)) {
+      expect(error.code).toBe('workspace-not-found');
+      expect(error.details).toEqual({workspaceId});
+    }
+  });
+});

package/src/presentation/inter-module.ts

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

package/test/factories/workspace.ts

@@ -12,6 +12,7 @@ export const workspaceFactory = Factory.define<Workspace>(({sequence, onCreate})
     name: `Test Workspace ${sequence}`,
     status: 'active',
     settings: {},
+    createdBy: null,
     createdAt: new Date(),
     updatedAt: new Date(),
   };

package/test/globalSetup.ts

@@ -8,7 +8,7 @@ export async function setup() {
   createPostgresClient();
 
   await runMigrations(db(), migrationsPath, '__drizzle_migrations_workspaces');
-  await db().execute(sql`TRUNCATE workspaces_outbox, workspaces CASCADE`);
+  await db().execute(sql`TRUNCATE workspaces_outbox, workspaces_workspaces CASCADE`);
 
   closeDb();
   await closePostgresClient();