@shipfox/api-workspaces 11.0.0 → 12.2.0

package/src/presentation/routes/workspaces/slug-availability.test.ts

@@ -0,0 +1,159 @@
+import {sql} from 'drizzle-orm';
+import {
+  hashWorkspacesRateLimitIdentifier,
+  WORKSPACE_SLUG_AVAILABILITY_RATE_LIMIT,
+} from '#core/rate-limit.js';
+import {createWorkspaceForUser} from '#core/workspaces.js';
+import {db} from '#db/db.js';
+import {workspacesRateLimits} from '#db/schema/rate-limits.js';
+import {createWorkspacesTestApp, signupVerifyLogin} from '#test/routes.js';
+
+let ipSequence = 1;
+
+function uniqueIp(): string {
+  ipSequence += 1;
+  return `203.0.113.${ipSequence}`;
+}
+
+function windowStartFor(now: Date, windowSeconds: number): Date {
+  const windowMs = windowSeconds * 1000;
+  return new Date(Math.floor(now.getTime() / windowMs) * windowMs);
+}
+
+describe('GET /workspaces/slug-availability', () => {
+  test('returns true for an available slug and false for a taken slug', async () => {
+    const app = await createWorkspacesTestApp({fastifyOptions: {trustProxy: true}});
+    const user = await signupVerifyLogin(app, 'workspace-slug-availability');
+    const takenSlug = `taken-${crypto.randomUUID().slice(0, 8)}`;
+    await createWorkspaceForUser({
+      name: 'Taken Workspace',
+      slug: takenSlug,
+      userId: crypto.randomUUID(),
+    });
+
+    const headers = {
+      authorization: `Bearer ${user.token}`,
+      'x-forwarded-for': uniqueIp(),
+    };
+    const available = await app.inject({
+      method: 'GET',
+      url: `/workspaces/slug-availability?slug=available-${crypto.randomUUID().slice(0, 8)}`,
+      headers,
+    });
+    const taken = await app.inject({
+      method: 'GET',
+      url: `/workspaces/slug-availability?slug=${takenSlug}`,
+      headers: {...headers, 'x-forwarded-for': uniqueIp()},
+    });
+
+    expect(available.statusCode).toBe(200);
+    expect(available.json()).toEqual({available: true});
+    expect(taken.statusCode).toBe(200);
+    expect(taken.json()).toEqual({available: false});
+
+    await app.close();
+  });
+
+  test('rejects malformed slugs instead of reporting them as taken', async () => {
+    const app = await createWorkspacesTestApp({fastifyOptions: {trustProxy: true}});
+    const user = await signupVerifyLogin(app, 'workspace-slug-invalid');
+
+    const res = await app.inject({
+      method: 'GET',
+      url: '/workspaces/slug-availability?slug=Not%20A%20Slug',
+      headers: {
+        authorization: `Bearer ${user.token}`,
+        'x-forwarded-for': uniqueIp(),
+      },
+    });
+
+    expect(res.statusCode).toBe(400);
+
+    await app.close();
+  });
+
+  test('rejects unauthenticated callers', async () => {
+    const app = await createWorkspacesTestApp({fastifyOptions: {trustProxy: true}});
+
+    const res = await app.inject({
+      method: 'GET',
+      url: '/workspaces/slug-availability?slug=available',
+    });
+
+    expect(res.statusCode).toBe(401);
+
+    await app.close();
+  });
+
+  test('rate-limits repeated availability checks by source IP', async () => {
+    const app = await createWorkspacesTestApp({fastifyOptions: {trustProxy: true}});
+    const user = await signupVerifyLogin(app, 'workspace-slug-rate-limit');
+    const headers = {
+      authorization: `Bearer ${user.token}`,
+      'x-forwarded-for': uniqueIp(),
+    };
+    const url = `/workspaces/slug-availability?slug=rate-limit-${crypto.randomUUID().slice(0, 8)}`;
+    let lastResponse = await app.inject({method: 'GET', url, headers});
+
+    for (let attempt = 1; attempt <= WORKSPACE_SLUG_AVAILABILITY_RATE_LIMIT.limit; attempt += 1) {
+      lastResponse = await app.inject({method: 'GET', url, headers});
+    }
+
+    expect(lastResponse.statusCode).toBe(429);
+    expect(lastResponse.json()).toMatchObject({
+      code: 'rate-limited',
+      details: {retry_after_seconds: expect.any(Number)},
+    });
+    expect(lastResponse.headers['retry-after']).toEqual(expect.any(String));
+
+    await app.close();
+  });
+
+  test('fails closed when limiter storage is unavailable', async () => {
+    const app = await createWorkspacesTestApp({fastifyOptions: {trustProxy: true}});
+    const user = await signupVerifyLogin(app, 'workspace-slug-rate-limit-unavailable');
+    const ip = uniqueIp();
+    const now = new Date();
+    const windowStart = windowStartFor(now, WORKSPACE_SLUG_AVAILABILITY_RATE_LIMIT.windowSeconds);
+    const identifierHmac = hashWorkspacesRateLimitIdentifier({
+      action: 'slug-availability',
+      scope: 'ip',
+      identifier: ip,
+    });
+
+    await db()
+      .insert(workspacesRateLimits)
+      .values({
+        action: 'slug-availability',
+        scope: 'ip',
+        identifierHmac,
+        windowStart,
+        count: 1,
+        expiresAt: new Date(
+          windowStart.getTime() + WORKSPACE_SLUG_AVAILABILITY_RATE_LIMIT.windowSeconds * 1000,
+        ),
+      });
+
+    await db().transaction(async (tx) => {
+      await tx.execute(sql`
+        SELECT 1
+        FROM workspaces_rate_limits
+        WHERE identifier_hmac = ${identifierHmac}
+        FOR UPDATE
+      `);
+      const res = await app.inject({
+        method: 'GET',
+        url: `/workspaces/slug-availability?slug=unavailable-${crypto.randomUUID().slice(0, 8)}`,
+        headers: {
+          authorization: `Bearer ${user.token}`,
+          'x-forwarded-for': ip,
+        },
+      });
+
+      expect(res.statusCode).toBe(503);
+      expect(res.json()).toEqual({code: 'workspace-rate-limit-unavailable'});
+    });
+
+    await app.close();
+  });
+});

package/src/presentation/routes/workspaces/slug-availability.ts

@@ -0,0 +1,30 @@
+import {AUTH_USER, getUserContext} from '@shipfox/api-auth-context';
+import {
+  workspaceSlugAvailabilityQuerySchema,
+  workspaceSlugAvailabilityResponseSchema,
+} from '@shipfox/api-workspaces-dto';
+import {ClientError, defineRoute} from '@shipfox/node-fastify';
+import {checkWorkspaceSlugAvailability} from '#core/index.js';
+import {createWorkspaceSlugAvailabilityRateLimitPreHandler} from '../rate-limit.js';
+
+export const workspaceSlugAvailabilityRoute = defineRoute({
+  method: 'GET',
+  path: '/slug-availability',
+  description: 'Check whether a workspace slug is available.',
+  auth: AUTH_USER,
+  schema: {
+    querystring: workspaceSlugAvailabilityQuerySchema,
+    response: {
+      200: workspaceSlugAvailabilityResponseSchema,
+    },
+  },
+  preHandler: createWorkspaceSlugAvailabilityRateLimitPreHandler(),
+  handler: async (request) => {
+    const client = getUserContext(request);
+    if (!client) {
+      throw new ClientError('Authentication required', 'unauthorized', {status: 401});
+    }
+
+    return {available: await checkWorkspaceSlugAvailability(request.query.slug)};
+  },
+});

package/src/presentation/routes/workspaces/update.test.ts

@@ -0,0 +1,114 @@
+import {WORKSPACES_WORKSPACE_UPDATED} from '@shipfox/api-workspaces-dto';
+import {sql} from 'drizzle-orm';
+import {createWorkspaceForUser} from '#core/workspaces.js';
+import {db} from '#db/db.js';
+import {workspacesOutbox} from '#db/schema/outbox.js';
+import {createWorkspacesTestApp, signupVerifyLogin} from '#test/routes.js';
+
+describe('PATCH /workspaces/:workspaceId', () => {
+  test('updates workspace details and writes the updated event', async () => {
+    const app = await createWorkspacesTestApp();
+    const owner = await signupVerifyLogin(app, 'workspace-update-owner');
+    const workspace = await createWorkspaceForUser({
+      name: 'Before',
+      slug: `before-${crypto.randomUUID().slice(0, 8)}`,
+      userId: owner.userId,
+      userEmail: owner.email,
+    });
+
+    const res = await app.inject({
+      method: 'PATCH',
+      url: `/workspaces/${workspace.id}`,
+      headers: {authorization: `Bearer ${owner.token}`},
+      payload: {name: 'After', slug: 'after'},
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toMatchObject({id: workspace.id, name: 'After', slug: 'after'});
+
+    const [event] = await db()
+      .select()
+      .from(workspacesOutbox)
+      .where(sql`${workspacesOutbox.payload}->>'workspaceId' = ${workspace.id}`)
+      .orderBy(sql`${workspacesOutbox.createdAt} DESC`)
+      .limit(1);
+    expect(event).toMatchObject({
+      eventType: WORKSPACES_WORKSPACE_UPDATED,
+      payload: {workspaceId: workspace.id, name: 'After', slug: 'after'},
+    });
+  });
+
+  test('rejects an empty body instead of writing a no-op updated event', async () => {
+    const app = await createWorkspacesTestApp();
+    const owner = await signupVerifyLogin(app, 'workspace-update-empty');
+    const workspace = await createWorkspaceForUser({
+      name: 'Untouched',
+      slug: `untouched-${crypto.randomUUID().slice(0, 8)}`,
+      userId: owner.userId,
+      userEmail: owner.email,
+    });
+
+    const res = await app.inject({
+      method: 'PATCH',
+      url: `/workspaces/${workspace.id}`,
+      headers: {authorization: `Bearer ${owner.token}`},
+      payload: {},
+    });
+
+    expect(res.statusCode).toBe(400);
+  });
+
+  test('returns slug-conflict for a taken slug', async () => {
+    const app = await createWorkspacesTestApp();
+    const owner = await signupVerifyLogin(app, 'workspace-update-conflict');
+    await createWorkspaceForUser({
+      name: 'Taken',
+      slug: 'taken',
+      userId: crypto.randomUUID(),
+    });
+    const workspace = await createWorkspaceForUser({
+      name: 'Available',
+      slug: `available-${crypto.randomUUID().slice(0, 8)}`,
+      userId: owner.userId,
+      userEmail: owner.email,
+    });
+
+    const res = await app.inject({
+      method: 'PATCH',
+      url: `/workspaces/${workspace.id}`,
+      headers: {authorization: `Bearer ${owner.token}`},
+      payload: {slug: 'taken'},
+    });
+
+    expect(res.statusCode).toBe(409);
+    expect(res.json().code).toBe('slug-conflict');
+  });
+
+  test('frees the old slug for immediate reuse', async () => {
+    const app = await createWorkspacesTestApp();
+    const owner = await signupVerifyLogin(app, 'workspace-update-reuse');
+    const oldSlug = `old-${crypto.randomUUID().slice(0, 8)}`;
+    const workspace = await createWorkspaceForUser({
+      name: 'Renamed',
+      slug: oldSlug,
+      userId: owner.userId,
+      userEmail: owner.email,
+    });
+
+    const renamed = await app.inject({
+      method: 'PATCH',
+      url: `/workspaces/${workspace.id}`,
+      headers: {authorization: `Bearer ${owner.token}`},
+      payload: {slug: 'renamed'},
+    });
+
+    expect(renamed.statusCode).toBe(200);
+    await expect(
+      createWorkspaceForUser({
+        name: 'Reused',
+        slug: oldSlug,
+        userId: crypto.randomUUID(),
+      }),
+    ).resolves.toMatchObject({slug: oldSlug});
+  });
+});

package/src/presentation/routes/workspaces/update.ts

@@ -0,0 +1,41 @@
+import {AUTH_USER, requireWorkspaceAccess} from '@shipfox/api-auth-context';
+import {updateWorkspaceBodySchema, workspaceResponseSchema} from '@shipfox/api-workspaces-dto';
+import {ClientError, defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {WorkspaceNotFoundError, WorkspaceSlugConflictError} from '#core/errors.js';
+import {updateWorkspaceDetails} from '#core/index.js';
+import {toWorkspaceDto} from '#presentation/dto/index.js';
+
+export const updateWorkspaceRoute = defineRoute({
+  method: 'PATCH',
+  path: '/:workspaceId',
+  description: 'Update workspace details.',
+  auth: AUTH_USER,
+  schema: {
+    params: z.object({workspaceId: z.string().uuid()}),
+    body: updateWorkspaceBodySchema,
+    response: {
+      200: workspaceResponseSchema,
+    },
+  },
+  errorHandler: (error) => {
+    if (error instanceof WorkspaceNotFoundError) {
+      throw new ClientError('Workspace not found', 'not-found', {status: 404});
+    }
+    if (error instanceof WorkspaceSlugConflictError) {
+      throw new ClientError('Workspace slug is already taken', 'slug-conflict', {status: 409});
+    }
+    throw error;
+  },
+  handler: async (request) => {
+    requireWorkspaceAccess({request, workspaceId: request.params.workspaceId});
+
+    const workspace = await updateWorkspaceDetails({
+      workspaceId: request.params.workspaceId,
+      name: request.body.name,
+      slug: request.body.slug,
+    });
+
+    return toWorkspaceDto(workspace);
+  },
+});

package/test/env.ts

@@ -5,4 +5,5 @@ process.env.POSTGRES_PASSWORD ??= 'password';
 process.env.POSTGRES_DATABASE = 'api_test';
 process.env.POSTGRES_MAX_CONNECTIONS ??= '5';
 process.env.WORKSPACE_JWT_SECRET = 'test-secret';
+process.env.AUTH_ROOT_KEY = 'MDEyMzQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWY=';
 process.env.TZ = 'UTC';

package/test/factories/workspace.ts

@@ -1,15 +1,17 @@
+import {withSlugSuffix} from '@shipfox/api-common-dto';
 import {Factory} from 'fishery';
 import type {Workspace} from '#core/entities/workspace.js';
 import {createWorkspace} from '#db/workspaces.js';
 
 export const workspaceFactory = Factory.define<Workspace>(({sequence, onCreate}) => {
   onCreate((workspace) => {
-    return createWorkspace({name: workspace.name});
+    return createWorkspace({name: workspace.name, slug: workspace.slug});
   });
 
   return {
     id: crypto.randomUUID(),
     name: `Test Workspace ${sequence}`,
+    slug: withSlugSuffix(`test-workspace-${crypto.randomUUID().slice(0, 8)}`, sequence + 1),
     status: 'active',
     settings: {},
     createdBy: null,

package/test/globalSetup.ts

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

package/test/routes.ts

@@ -1,8 +1,9 @@
 import type {OutgoingHttpHeaders} from 'node:http';
 import {AUTH_USER, buildUserContext, setUserContext} from '@shipfox/api-auth-context';
+import {withSlugSuffix} from '@shipfox/api-common-dto';
 import {WORKSPACES_INVITATION_SEND_REQUESTED} from '@shipfox/api-workspaces-dto';
-import type {AuthMethod} from '@shipfox/node-fastify';
-import {createApp, type FastifyInstance} from '@shipfox/node-fastify';
+import type {AppConfig, AuthMethod} from '@shipfox/node-fastify';
+import {ClientError, createApp, type FastifyInstance} from '@shipfox/node-fastify';
 import type {Mailer, MailMessage} from '@shipfox/node-mailer';
 import {hashOpaqueToken} from '@shipfox/node-tokens';
 import {and, desc, eq, sql} from 'drizzle-orm';
@@ -44,6 +45,7 @@ vi.mock('#config.js', () => ({
 
 const TOKEN_RE = /token=([\w\-_=]+)/;
 const BEARER_RE = /^Bearer /u;
+let workspaceSlugSequence = 1;
 
 export const ROUTE_TEST_SECRET = testConfig.secret;
 
@@ -51,6 +53,9 @@ const fakeUserAuth: AuthMethod = {
   name: AUTH_USER,
   authenticate: async (request) => {
     const raw = request.headers.authorization?.replace(BEARER_RE, '');
+    if (!raw) {
+      throw new ClientError('Authentication required', 'unauthorized', {status: 401});
+    }
     if (raw?.startsWith('claim:')) {
       const [, userId, email, workspaceId, status] = raw.split(':');
       if (!userId || !email || !workspaceId) throw new Error('Invalid test user claim token');
@@ -143,8 +148,11 @@ export async function latestInvitationLinkTo(email: string): Promise<string> {
   return payload?.inviteLink ?? '';
 }
 
-export async function createWorkspacesTestApp(): Promise<FastifyInstance> {
+export async function createWorkspacesTestApp(
+  options: Pick<AppConfig, 'fastifyOptions'> = {},
+): Promise<FastifyInstance> {
   return await createApp({
+    ...options,
     auth: [fakeUserAuth],
     routes: workspacesRoutes,
     swagger: false,
@@ -217,7 +225,13 @@ export async function createWorkspace(
     method: 'POST',
     url: '/workspaces',
     headers: {authorization: `Bearer ${token}`},
-    payload: {name},
+    payload: {
+      name,
+      slug: withSlugSuffix(
+        `route-workspace-${crypto.randomUUID().slice(0, 8)}`,
+        workspaceSlugSequence++,
+      ),
+    },
   });
 
   expect(res.statusCode).toBe(201);