@shipfox/api-projects 11.0.0 → 12.2.0

package/src/presentation/routes/projects.test.ts

@@ -15,9 +15,12 @@ import {
 import {createInterModuleKnownError} from '@shipfox/inter-module';
 import type {AuthMethod} from '@shipfox/node-fastify';
 import {closeApp, createApp} from '@shipfox/node-fastify';
+import {sql} from 'drizzle-orm';
 import type {FastifyInstance, FastifyRequest} from 'fastify';
 import type {Project} from '#core/entities/project.js';
+import {db} from '#db/db.js';
 import {createProject} from '#db/projects.js';
+import {projectsOutbox} from '#db/schema/outbox.js';
 import {createProjectRoutes} from './index.js';
 
 let authenticatedMemberships: UserContextMembership[] = [];
@@ -95,6 +98,7 @@ describe('project routes', () => {
       payload: {
         workspace_id: workspaceId,
         name: '  Platform  ',
+        slug: 'platform',
         source: {
           connection_id: sourceConnectionId,
           external_repository_id: 'gitea:gitea-owner/platform',
@@ -104,12 +108,290 @@ describe('project routes', () => {
 
     expect(res.statusCode).toBe(201);
     expect(res.json().name).toBe('Platform');
+    expect(res.json().slug).toBe('platform');
     expect(res.json().source).toEqual({
       connection_id: sourceConnectionId,
       external_repository_id: 'gitea:gitea-owner/platform',
     });
   });
 
+  test('returns a distinct conflict when a slug is taken in the workspace', async () => {
+    await app.inject({
+      method: 'POST',
+      url: '/projects',
+      headers: {authorization: 'Bearer user'},
+      payload: {
+        workspace_id: workspaceId,
+        name: 'Platform',
+        slug: 'platform',
+        source: {
+          connection_id: sourceConnectionId,
+          external_repository_id: 'gitea:gitea-owner/platform',
+        },
+      },
+    });
+    vi.mocked(integrations.resolveSourceRepository).mockResolvedValueOnce({
+      connection: {
+        id: crypto.randomUUID(),
+        provider: 'gitea',
+        slug: 'gitea_owner',
+      },
+      repository: {
+        externalRepositoryId: 'gitea:gitea-owner/other',
+        owner: 'gitea-owner',
+        name: 'other',
+        fullName: 'gitea-owner/other',
+        defaultBranch: 'main',
+        visibility: 'private',
+        cloneUrl: 'https://gitea.local/gitea-owner/other.git',
+        htmlUrl: 'https://gitea.local/gitea-owner/other',
+      },
+    });
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/projects',
+      headers: {authorization: 'Bearer user'},
+      payload: {
+        workspace_id: workspaceId,
+        name: 'Other',
+        slug: 'platform',
+        source: {
+          connection_id: crypto.randomUUID(),
+          external_repository_id: 'gitea:gitea-owner/other',
+        },
+      },
+    });
+
+    expect(res.statusCode).toBe(409);
+    expect(res.json().code).toBe('slug-conflict');
+    expect(res.json().code).not.toBe('project-already-exists');
+  });
+
+  test('allows the same slug in different workspaces', async () => {
+    const secondWorkspaceId = crypto.randomUUID();
+    authenticatedMemberships = [
+      {workspaceId, role: 'admin', workspaceStatus: 'active'},
+      {workspaceId: secondWorkspaceId, role: 'admin', workspaceStatus: 'active'},
+    ];
+    await app.inject({
+      method: 'POST',
+      url: '/projects',
+      headers: {authorization: 'Bearer user'},
+      payload: {
+        workspace_id: workspaceId,
+        name: 'Platform',
+        slug: 'platform',
+        source: {
+          connection_id: sourceConnectionId,
+          external_repository_id: 'gitea:gitea-owner/platform',
+        },
+      },
+    });
+    vi.mocked(integrations.resolveSourceRepository).mockResolvedValueOnce({
+      connection: {
+        id: crypto.randomUUID(),
+        provider: 'gitea',
+        slug: 'gitea_owner',
+      },
+      repository: {
+        externalRepositoryId: 'gitea:gitea-owner/other-workspace',
+        owner: 'gitea-owner',
+        name: 'other-workspace',
+        fullName: 'gitea-owner/other-workspace',
+        defaultBranch: 'main',
+        visibility: 'private',
+        cloneUrl: 'https://gitea.local/gitea-owner/other-workspace.git',
+        htmlUrl: 'https://gitea.local/gitea-owner/other-workspace',
+      },
+    });
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/projects',
+      headers: {authorization: 'Bearer user'},
+      payload: {
+        workspace_id: secondWorkspaceId,
+        name: 'Platform',
+        slug: 'platform',
+        source: {
+          connection_id: crypto.randomUUID(),
+          external_repository_id: 'gitea:gitea-owner/other-workspace',
+        },
+      },
+    });
+
+    expect(res.statusCode).toBe(201);
+    expect(res.json().slug).toBe('platform');
+  });
+
+  test('accepts a project slug named new', async () => {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/projects',
+      headers: {authorization: 'Bearer user'},
+      payload: {
+        workspace_id: workspaceId,
+        name: 'New Project',
+        slug: 'new',
+        source: {
+          connection_id: sourceConnectionId,
+          external_repository_id: 'gitea:gitea-owner/platform',
+        },
+      },
+    });
+
+    expect(res.statusCode).toBe(201);
+    expect(res.json().slug).toBe('new');
+  });
+
+  test('renames a project, frees the old slug, and writes an update event', async () => {
+    const createRes = await app.inject({
+      method: 'POST',
+      url: '/projects',
+      headers: {authorization: 'Bearer user'},
+      payload: {
+        workspace_id: workspaceId,
+        name: 'Platform',
+        slug: 'platform',
+        source: {
+          connection_id: sourceConnectionId,
+          external_repository_id: 'gitea:gitea-owner/platform',
+        },
+      },
+    });
+
+    const patchRes = await app.inject({
+      method: 'PATCH',
+      url: `/projects/${createRes.json().id}`,
+      headers: {authorization: 'Bearer user'},
+      payload: {name: 'Renamed Platform', slug: 'renamed-platform'},
+    });
+
+    expect(patchRes.statusCode).toBe(200);
+    expect(patchRes.json()).toMatchObject({
+      name: 'Renamed Platform',
+      slug: 'renamed-platform',
+    });
+
+    const events = await db()
+      .select()
+      .from(projectsOutbox)
+      .where(sql`${projectsOutbox.payload}->>'projectId' = ${createRes.json().id}`);
+    expect(events).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          eventType: 'projects.project.updated',
+          payload: expect.objectContaining({
+            name: 'Renamed Platform',
+            slug: 'renamed-platform',
+          }),
+        }),
+      ]),
+    );
+
+    vi.mocked(integrations.resolveSourceRepository).mockResolvedValueOnce({
+      connection: {
+        id: crypto.randomUUID(),
+        provider: 'gitea',
+        slug: 'gitea_owner',
+      },
+      repository: {
+        externalRepositoryId: 'gitea:gitea-owner/other',
+        owner: 'gitea-owner',
+        name: 'other',
+        fullName: 'gitea-owner/other',
+        defaultBranch: 'main',
+        visibility: 'private',
+        cloneUrl: 'https://gitea.local/gitea-owner/other.git',
+        htmlUrl: 'https://gitea.local/gitea-owner/other',
+      },
+    });
+    const reuseRes = await app.inject({
+      method: 'POST',
+      url: '/projects',
+      headers: {authorization: 'Bearer user'},
+      payload: {
+        workspace_id: workspaceId,
+        name: 'Other',
+        slug: 'platform',
+        source: {
+          connection_id: crypto.randomUUID(),
+          external_repository_id: 'gitea:gitea-owner/other',
+        },
+      },
+    });
+    expect(reuseRes.statusCode).toBe(201);
+  });
+
+  test('treats an empty project update as a no-op', async () => {
+    const createRes = await app.inject({
+      method: 'POST',
+      url: '/projects',
+      headers: {authorization: 'Bearer user'},
+      payload: {
+        workspace_id: workspaceId,
+        name: 'Platform',
+        slug: 'platform',
+        source: {
+          connection_id: sourceConnectionId,
+          external_repository_id: 'gitea:gitea-owner/platform',
+        },
+      },
+    });
+    const created = createRes.json();
+    const beforeEvents = await db()
+      .select()
+      .from(projectsOutbox)
+      .where(sql`${projectsOutbox.payload}->>'projectId' = ${created.id}`);
+
+    const patchRes = await app.inject({
+      method: 'PATCH',
+      url: `/projects/${created.id}`,
+      headers: {authorization: 'Bearer user'},
+      payload: {},
+    });
+
+    expect(patchRes.statusCode).toBe(200);
+    expect(patchRes.json()).toMatchObject({
+      name: 'Platform',
+      slug: 'platform',
+      updated_at: created.updated_at,
+    });
+    const afterEvents = await db()
+      .select()
+      .from(projectsOutbox)
+      .where(sql`${projectsOutbox.payload}->>'projectId' = ${created.id}`);
+    expect(afterEvents).toHaveLength(beforeEvents.length);
+  });
+
+  test('returns a slug conflict when updating to another project slug', async () => {
+    const first = await createProject({
+      workspaceId,
+      name: 'Platform',
+      slug: 'platform',
+      sourceConnectionId: crypto.randomUUID(),
+      sourceExternalRepositoryId: 'gitea:platform',
+    });
+    const second = await createProject({
+      workspaceId,
+      name: 'Other',
+      slug: 'other',
+      sourceConnectionId: crypto.randomUUID(),
+      sourceExternalRepositoryId: 'gitea:other',
+    });
+
+    const res = await app.inject({
+      method: 'PATCH',
+      url: `/projects/${second.id}`,
+      headers: {authorization: 'Bearer user'},
+      payload: {slug: first.slug},
+    });
+
+    expect(res.statusCode).toBe(409);
+    expect(res.json().code).toBe('slug-conflict');
+  });
+
   test.each([
     ['blank after trimming', '   '],
     ['with control characters', 'Plat\nform'],
@@ -122,6 +404,7 @@ describe('project routes', () => {
       payload: {
         workspace_id: workspaceId,
         name,
+        slug: 'invalid-name',
         source: {
           connection_id: sourceConnectionId,
           external_repository_id: 'gitea:gitea-owner/platform',
@@ -141,6 +424,7 @@ describe('project routes', () => {
       payload: {
         workspace_id: workspaceId,
         name: 'Platform',
+        slug: 'platform',
         source: {
           connection_id: sourceConnectionId,
           external_repository_id: 'gitea:gitea-owner/platform',
@@ -162,9 +446,14 @@ describe('project routes', () => {
     expect(res.json().projects[0].source.connection_id).toBe(sourceConnectionId);
   });
 
-  test('filters projects by `search` (case-insensitive substring on name)', async () => {
-    const names = ['Platform', 'Runner', 'Notifier'];
-    for (const [index, name] of names.entries()) {
+  test('filters projects by `search` (case-insensitive substring on name or slug)', async () => {
+    const projects = [
+      {name: 'Platform', slug: 'platform'},
+      {name: 'Runner', slug: 'runner'},
+      {name: 'Notifier', slug: 'notifier'},
+      {name: 'Cloud', slug: 'runnbox'},
+    ];
+    for (const [index, {name, slug}] of projects.entries()) {
       vi.mocked(integrations.resolveSourceRepository).mockResolvedValueOnce({
         connection: {
           id: sourceConnectionId,
@@ -189,6 +478,7 @@ describe('project routes', () => {
         payload: {
           workspace_id: workspaceId,
           name,
+          slug,
           source: {
             connection_id: sourceConnectionId,
             external_repository_id: `gitea:gitea-owner/${name.toLowerCase()}-${index}`,
@@ -205,13 +495,14 @@ describe('project routes', () => {
 
     expect(res.statusCode).toBe(200);
     const returned = res.json().projects.map((project: {name: string}) => project.name);
-    expect(returned).toEqual(['Runner']);
+    expect(returned).toEqual(['Cloud', 'Runner']);
   });
 
   test('returns 409 when the source repository already has a project', async () => {
     const payload = {
       workspace_id: workspaceId,
       name: 'Platform',
+      slug: 'platform',
       source: {
         connection_id: sourceConnectionId,
         external_repository_id: 'gitea:gitea-owner/platform',
@@ -252,6 +543,7 @@ describe('project routes', () => {
       payload: {
         workspace_id: workspaceId,
         name: 'Platform',
+        slug: 'platform',
         source: {
           connection_id: sourceConnectionId,
           external_repository_id: 'gitea:gitea-owner/platform',
@@ -320,6 +612,7 @@ describe('project routes', () => {
         await createProject({
           workspaceId,
           name,
+          slug: name.toLowerCase(),
           sourceConnectionId: crypto.randomUUID(),
           sourceExternalRepositoryId: `gitea:${name.toLowerCase()}`,
         }),
@@ -375,12 +668,14 @@ describe('project routes', () => {
     const firstProject = await createProject({
       workspaceId: firstWorkspaceId,
       name: 'GlobalAdminLookupAlpha',
+      slug: 'global-admin-lookup-alpha',
       sourceConnectionId: crypto.randomUUID(),
       sourceExternalRepositoryId: 'gitea:global-admin-lookup-alpha',
     });
     const secondProject = await createProject({
       workspaceId: secondWorkspaceId,
       name: 'GlobalAdminLookupBeta',
+      slug: 'global-admin-lookup-beta',
       sourceConnectionId: crypto.randomUUID(),
       sourceExternalRepositoryId: 'gitea:global-admin-lookup-beta',
     });
@@ -404,6 +699,7 @@ describe('project routes', () => {
     const project = await createProject({
       workspaceId,
       name: 'Platform',
+      slug: 'platform',
       sourceConnectionId: crypto.randomUUID(),
       sourceExternalRepositoryId: 'gitea:platform',
     });

package/src/presentation/routes/update-project.ts

@@ -0,0 +1,46 @@
+import {AUTH_USER, requireUserContext} from '@shipfox/api-auth-context';
+import {projectResponseSchema, updateProjectBodySchema} from '@shipfox/api-projects-dto';
+import {ClientError, defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {ProjectNotFoundError, ProjectSlugConflictError, updateProjectDetails} from '#core/index.js';
+import {requireProjectAccess} from '#presentation/auth/require-project-access.js';
+import {toProjectDto} from '#presentation/dto/index.js';
+
+const projectParamsSchema = z.object({
+  projectId: z.string().uuid(),
+});
+
+export const updateProjectRoute = defineRoute({
+  method: 'PATCH',
+  path: '/:projectId',
+  auth: AUTH_USER,
+  description: 'Update a project.',
+  schema: {
+    params: projectParamsSchema,
+    body: updateProjectBodySchema,
+    response: {
+      200: projectResponseSchema,
+    },
+  },
+  errorHandler: (error) => {
+    if (error instanceof ProjectSlugConflictError) {
+      throw new ClientError('Project slug already exists', 'slug-conflict', {status: 409});
+    }
+    if (error instanceof ProjectNotFoundError) {
+      throw new ClientError('Project not found', 'project-not-found', {status: 404});
+    }
+    throw error;
+  },
+  handler: async (request) => {
+    const {projectId} = request.params;
+    await requireProjectAccess({request, projectId});
+    const actor = requireUserContext(request);
+    const project = await updateProjectDetails({
+      actorId: actor.userId,
+      projectId,
+      name: request.body.name,
+      slug: request.body.slug,
+    });
+    return toProjectDto(project);
+  },
+});

package/src/presentation/subscribers/index.ts

@@ -1 +1,2 @@
 export {onSourceCommitPushed} from './on-source-commit-pushed.js';
+export {onSourceRepositoryUpdated} from './on-source-repository-updated.js';

package/src/presentation/subscribers/on-source-commit-pushed.test.ts

@@ -1,6 +1,7 @@
 import type {AuthInterModuleClient} from '@shipfox/api-auth-dto/inter-module';
 import {
   INTEGRATION_SOURCE_COMMIT_PUSHED,
+  INTEGRATION_SOURCE_REPOSITORY_UPDATED,
   type IntegrationSourceCommitPushedEvent,
   type SourcePushPayload,
 } from '@shipfox/api-integration-core-dto';
@@ -150,5 +151,6 @@ describe('onSourceCommitPushed', () => {
     const events = module.subscribers?.map((subscriber) => subscriber.event);
 
     expect(events).toContain(INTEGRATION_SOURCE_COMMIT_PUSHED);
+    expect(events).toContain(INTEGRATION_SOURCE_REPOSITORY_UPDATED);
   });
 });

package/src/presentation/subscribers/on-source-repository-updated.test.ts

@@ -0,0 +1,108 @@
+import {
+  INTEGRATION_SOURCE_REPOSITORY_UPDATED,
+  type IntegrationSourceRepositoryUpdatedEvent,
+} from '@shipfox/api-integration-core-dto';
+import type {DomainEvent} from '@shipfox/node-outbox';
+import {getProjectBySource} from '#db/index.js';
+import {projectFactory} from '#test/index.js';
+import {onSourceRepositoryUpdated} from './on-source-repository-updated.js';
+
+function buildEvent(params: {
+  workspaceId: string;
+  connectionId: string;
+  externalRepositoryId: string;
+}): DomainEvent<IntegrationSourceRepositoryUpdatedEvent> {
+  return {
+    id: crypto.randomUUID(),
+    type: INTEGRATION_SOURCE_REPOSITORY_UPDATED,
+    createdAt: new Date(),
+    payload: {
+      provider: 'github',
+      workspaceId: params.workspaceId,
+      connectionId: params.connectionId,
+      deliveryId: crypto.randomUUID(),
+      receivedAt: new Date().toISOString(),
+      repository: {
+        externalRepositoryId: params.externalRepositoryId,
+        owner: 'acme',
+        name: 'platform-renamed',
+        defaultBranch: 'trunk',
+      },
+    },
+  };
+}
+
+describe('onSourceRepositoryUpdated', () => {
+  it('refreshes the denormalized repository identity by stable external id', async () => {
+    const workspaceId = crypto.randomUUID();
+    const connectionId = crypto.randomUUID();
+    const externalRepositoryId = `github:${crypto.randomUUID()}`;
+    const project = await projectFactory.create({
+      workspaceId,
+      sourceConnectionId: connectionId,
+      sourceExternalRepositoryId: externalRepositoryId,
+      sourceRepositoryOwner: 'old-owner',
+      sourceRepositoryName: 'old-name',
+      sourceDefaultBranch: 'main',
+    });
+    const event = buildEvent({workspaceId, connectionId, externalRepositoryId});
+
+    await onSourceRepositoryUpdated(event.payload, event);
+
+    const refreshed = await getProjectBySource({
+      workspaceId,
+      sourceConnectionId: connectionId,
+      sourceExternalRepositoryId: externalRepositoryId,
+    });
+    expect(refreshed).toMatchObject({
+      id: project.id,
+      sourceRepositoryOwner: 'acme',
+      sourceRepositoryName: 'platform-renamed',
+      sourceDefaultBranch: 'trunk',
+    });
+  });
+
+  it('ignores updates for repositories without a bound project', async () => {
+    const event = buildEvent({
+      workspaceId: crypto.randomUUID(),
+      connectionId: crypto.randomUUID(),
+      externalRepositoryId: `github:${crypto.randomUUID()}`,
+    });
+
+    await expect(onSourceRepositoryUpdated(event.payload, event)).resolves.toBeUndefined();
+  });
+
+  it('deduplicates the same repository update event for a project', async () => {
+    const workspaceId = crypto.randomUUID();
+    const connectionId = crypto.randomUUID();
+    const externalRepositoryId = `github:${crypto.randomUUID()}`;
+    await projectFactory.create({
+      workspaceId,
+      sourceConnectionId: connectionId,
+      sourceExternalRepositoryId: externalRepositoryId,
+      sourceRepositoryOwner: 'old-owner',
+      sourceRepositoryName: 'old-name',
+      sourceDefaultBranch: 'main',
+    });
+    const event = buildEvent({workspaceId, connectionId, externalRepositoryId});
+
+    await onSourceRepositoryUpdated(event.payload, event);
+    const duplicate = {
+      ...event,
+      payload: {
+        ...event.payload,
+        repository: {...event.payload.repository, name: 'stale-name'},
+      },
+    };
+    await onSourceRepositoryUpdated(duplicate.payload, duplicate);
+
+    const refreshed = await getProjectBySource({
+      workspaceId,
+      sourceConnectionId: connectionId,
+      sourceExternalRepositoryId: externalRepositoryId,
+    });
+    expect(refreshed).toMatchObject({
+      sourceRepositoryName: 'platform-renamed',
+    });
+  });
+});

package/src/presentation/subscribers/on-source-repository-updated.ts

@@ -0,0 +1,50 @@
+import type {IntegrationSourceRepositoryUpdatedEvent} from '@shipfox/api-integration-core-dto';
+import {logger} from '@shipfox/node-opentelemetry';
+import type {DomainEvent} from '@shipfox/node-outbox';
+import {db} from '#db/db.js';
+import {recordIntegrationEventForProject} from '#db/integration-event-dedup.js';
+import {getProjectBySource, updateProjectSourceRepository} from '#db/projects.js';
+
+export async function onSourceRepositoryUpdated(
+  payload: IntegrationSourceRepositoryUpdatedEvent,
+  event: DomainEvent<IntegrationSourceRepositoryUpdatedEvent>,
+): Promise<void> {
+  const project = await getProjectBySource({
+    workspaceId: payload.workspaceId,
+    sourceConnectionId: payload.connectionId,
+    sourceExternalRepositoryId: payload.repository.externalRepositoryId,
+  });
+
+  if (project) {
+    const outcome = await db().transaction(async (tx) => {
+      const {firstSeen} = await recordIntegrationEventForProject({
+        tx,
+        integrationEventId: event.id,
+        projectId: project.id,
+      });
+      if (!firstSeen) return 'duplicate';
+
+      const updated = await updateProjectSourceRepository({
+        tx,
+        workspaceId: payload.workspaceId,
+        sourceConnectionId: payload.connectionId,
+        sourceExternalRepositoryId: payload.repository.externalRepositoryId,
+        sourceRepositoryOwner: payload.repository.owner,
+        sourceRepositoryName: payload.repository.name,
+        sourceDefaultBranch: payload.repository.defaultBranch,
+      });
+      return updated ? 'updated' : 'missing';
+    });
+
+    if (outcome !== 'missing') return;
+  }
+
+  logger().info(
+    {
+      eventId: event.id,
+      connectionId: payload.connectionId,
+      externalRepositoryId: payload.repository.externalRepositoryId,
+    },
+    'source repository updated: no project bound to source, dropping',
+  );
+}

package/test/factories/project.ts

@@ -1,3 +1,4 @@
+import {withSlugSuffix} from '@shipfox/api-common-dto';
 import {Factory} from 'fishery';
 import type {Project} from '#core/entities/index.js';
 import {createProject} from '#db/index.js';
@@ -9,6 +10,7 @@ export const projectFactory = Factory.define<Project>(({sequence, onCreate}) =>
       sourceConnectionId: project.sourceConnectionId,
       sourceExternalRepositoryId: project.sourceExternalRepositoryId,
       name: project.name,
+      slug: project.slug,
     }),
   );
 
@@ -17,7 +19,11 @@ export const projectFactory = Factory.define<Project>(({sequence, onCreate}) =>
     workspaceId: crypto.randomUUID(),
     sourceConnectionId: crypto.randomUUID(),
     sourceExternalRepositoryId: `repository-${sequence}`,
+    sourceRepositoryOwner: null,
+    sourceRepositoryName: null,
+    sourceDefaultBranch: null,
     name: `Project ${sequence}`,
+    slug: withSlugSuffix('project', sequence + 1),
     createdAt: new Date(),
     updatedAt: new Date(),
   };