@shipfox/api-projects 10.2.0 → 12.0.0

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

@@ -0,0 +1,309 @@
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/inter-module';
+import {projectsInterModuleContract} from '@shipfox/api-projects-dto/inter-module';
+import {isInterModuleKnownError} from '@shipfox/inter-module';
+import {createInMemoryInterModuleTransport} from '@shipfox/node-module/inter-module';
+import {db} from '#db/index.js';
+import {projects} from '#db/schema/projects.js';
+import {createProjectsInterModulePresentation} from './inter-module.js';
+
+function createClient(
+  integrations: Pick<IntegrationsModuleClient, 'resolveSourceRepository'> = {
+    resolveSourceRepository: vi.fn(async ({connectionId, externalRepositoryId}) => ({
+      connection: {id: connectionId, provider: 'github', slug: 'github'},
+      repository: {
+        externalRepositoryId,
+        owner: 'acme',
+        name: 'api',
+        fullName: 'acme/api',
+        defaultBranch: 'main',
+        visibility: 'private' as const,
+        cloneUrl: 'https://github.com/acme/api.git',
+        htmlUrl: 'https://github.com/acme/api',
+      },
+    })),
+  },
+) {
+  const transport = createInMemoryInterModuleTransport();
+  const client = transport.createClient(projectsInterModuleContract);
+  transport.register(createProjectsInterModulePresentation({integrations}));
+  transport.seal();
+  return client;
+}
+
+async function insertProject(params: {
+  workspaceId: string;
+  connectionId: string;
+  owner: string | null;
+  name: string | null;
+  externalRepositoryId?: string;
+}) {
+  const [project] = await db()
+    .insert(projects)
+    .values({
+      workspaceId: params.workspaceId,
+      sourceConnectionId: params.connectionId,
+      sourceExternalRepositoryId:
+        params.externalRepositoryId ?? `repository-${crypto.randomUUID()}`,
+      sourceRepositoryOwner: params.owner,
+      sourceRepositoryName: params.name,
+      name: params.name ?? 'Project',
+      slug: `p-${crypto.randomUUID().slice(0, 8)}`,
+    })
+    .returning({
+      projectId: projects.id,
+      connectionId: projects.sourceConnectionId,
+      externalRepositoryId: projects.sourceExternalRepositoryId,
+    });
+
+  if (project === undefined) throw new Error('Project insert returned no row');
+  return project;
+}
+
+async function expectUnauthorized(
+  client: ReturnType<typeof createClient>,
+  input: Parameters<typeof client.resolveCheckoutTarget>[0],
+) {
+  const error = await client.resolveCheckoutTarget(input).catch((caught) => caught);
+
+  expect(
+    isInterModuleKnownError(projectsInterModuleContract.methods.resolveCheckoutTarget, error),
+  ).toBe(true);
+  if (isInterModuleKnownError(projectsInterModuleContract.methods.resolveCheckoutTarget, error)) {
+    expect(error.code).toBe('checkout-repository-not-authorized');
+    expect(error.details).toEqual({});
+  }
+}
+
+describe('Projects checkout target inter-module presentation', () => {
+  test('resolves a project by its workspace-scoped source repository', async () => {
+    const client = createClient();
+    const workspaceId = crypto.randomUUID();
+    const connectionId = crypto.randomUUID();
+    const project = await insertProject({
+      workspaceId,
+      connectionId,
+      owner: 'acme',
+      name: 'api',
+      externalRepositoryId: 'github:42',
+    });
+
+    await expect(
+      client.getProjectBySource({
+        workspaceId,
+        sourceConnectionId: connectionId,
+        sourceExternalRepositoryId: project.externalRepositoryId,
+      }),
+    ).resolves.toMatchObject({project: {id: project.projectId}});
+
+    await expect(
+      client.getProjectBySource({
+        workspaceId: crypto.randomUUID(),
+        sourceConnectionId: connectionId,
+        sourceExternalRepositoryId: project.externalRepositoryId,
+      }),
+    ).resolves.toEqual({project: null});
+  });
+
+  test('resolves a project target in its workspace', async () => {
+    const client = createClient();
+    const workspaceId = crypto.randomUUID();
+    const project = await insertProject({
+      workspaceId,
+      connectionId: crypto.randomUUID(),
+      owner: 'acme',
+      name: 'api',
+    });
+
+    await expect(
+      client.resolveCheckoutTarget({
+        workspaceId,
+        defaults: {connectionId: crypto.randomUUID(), owner: 'other'},
+        target: {project: project.projectId},
+      }),
+    ).resolves.toEqual(project);
+  });
+
+  test('resolves a bare repository name against the default owner', async () => {
+    const client = createClient();
+    const workspaceId = crypto.randomUUID();
+    const connectionId = crypto.randomUUID();
+    const project = await insertProject({
+      workspaceId,
+      connectionId,
+      owner: 'AcMe',
+      name: 'Api',
+    });
+
+    await expect(
+      client.resolveCheckoutTarget({
+        workspaceId,
+        defaults: {connectionId, owner: 'acme'},
+        target: {repository: 'api'},
+      }),
+    ).resolves.toEqual(project);
+  });
+
+  test('resolves an owner/name repository case-insensitively', async () => {
+    const client = createClient();
+    const workspaceId = crypto.randomUUID();
+    const connectionId = crypto.randomUUID();
+    const project = await insertProject({
+      workspaceId,
+      connectionId,
+      owner: 'AcMe',
+      name: 'Api',
+    });
+
+    await expect(
+      client.resolveCheckoutTarget({
+        workspaceId,
+        defaults: {connectionId, owner: 'other'},
+        target: {repository: 'aCmE/aPI'},
+      }),
+    ).resolves.toEqual(project);
+  });
+
+  test('uses an explicit connection to select between identical repositories', async () => {
+    const client = createClient();
+    const workspaceId = crypto.randomUUID();
+    const defaultConnectionId = crypto.randomUUID();
+    const explicitConnectionId = crypto.randomUUID();
+    await insertProject({
+      workspaceId,
+      connectionId: defaultConnectionId,
+      owner: 'acme',
+      name: 'api',
+    });
+    const explicitProject = await insertProject({
+      workspaceId,
+      connectionId: explicitConnectionId,
+      owner: 'acme',
+      name: 'api',
+    });
+
+    await expect(
+      client.resolveCheckoutTarget({
+        workspaceId,
+        defaults: {connectionId: defaultConnectionId, owner: 'acme'},
+        target: {connection: explicitConnectionId, repository: 'acme/api'},
+      }),
+    ).resolves.toEqual(explicitProject);
+  });
+
+  test('rejects an ambiguous owner/name match instead of picking arbitrarily', async () => {
+    const client = createClient();
+    const workspaceId = crypto.randomUUID();
+    const connectionId = crypto.randomUUID();
+    await insertProject({workspaceId, connectionId, owner: 'acme', name: 'api'});
+    await insertProject({workspaceId, connectionId, owner: 'acme', name: 'api'});
+
+    await expectUnauthorized(client, {
+      workspaceId,
+      defaults: {connectionId, owner: 'acme'},
+      target: {repository: 'acme/api'},
+    });
+  });
+
+  test('refreshes provider metadata before resolving a repository name', async () => {
+    const workspaceId = crypto.randomUUID();
+    const connectionId = crypto.randomUUID();
+    const externalRepositoryId = `github:${crypto.randomUUID()}`;
+    const resolveSourceRepository = vi.fn(async () => ({
+      connection: {id: connectionId, provider: 'github', slug: 'github'},
+      repository: {
+        externalRepositoryId,
+        owner: 'acme',
+        name: 'new-name',
+        fullName: 'acme/new-name',
+        defaultBranch: 'main',
+        visibility: 'private' as const,
+        cloneUrl: 'https://github.com/acme/new-name.git',
+        htmlUrl: 'https://github.com/acme/new-name',
+      },
+    }));
+    const client = createClient({resolveSourceRepository});
+    const project = await insertProject({
+      workspaceId,
+      connectionId,
+      owner: 'acme',
+      name: 'old-name',
+      externalRepositoryId,
+    });
+
+    await expectUnauthorized(client, {
+      workspaceId,
+      defaults: {connectionId, owner: 'acme'},
+      target: {repository: 'acme/old-name'},
+    });
+
+    await expect(
+      client.resolveCheckoutTarget({
+        workspaceId,
+        defaults: {connectionId, owner: 'acme'},
+        target: {repository: 'acme/new-name'},
+      }),
+    ).resolves.toEqual(project);
+    expect(resolveSourceRepository).toHaveBeenCalledWith({
+      workspaceId,
+      connectionId,
+      externalRepositoryId: project.externalRepositoryId,
+    });
+  });
+
+  test('does not let a bare name escape the default owner', async () => {
+    const client = createClient();
+    const workspaceId = crypto.randomUUID();
+    const connectionId = crypto.randomUUID();
+    await insertProject({
+      workspaceId,
+      connectionId,
+      owner: 'other',
+      name: 'api',
+    });
+
+    await expectUnauthorized(client, {
+      workspaceId,
+      defaults: {connectionId, owner: 'acme'},
+      target: {repository: 'api'},
+    });
+  });
+
+  test('rejects a project from another workspace', async () => {
+    const client = createClient();
+    const project = await insertProject({
+      workspaceId: crypto.randomUUID(),
+      connectionId: crypto.randomUUID(),
+      owner: 'acme',
+      name: 'api',
+    });
+
+    await expectUnauthorized(client, {
+      workspaceId: crypto.randomUUID(),
+      defaults: {connectionId: project.connectionId, owner: 'acme'},
+      target: {project: project.projectId},
+    });
+  });
+
+  test.each([
+    ['an unknown target', {repository: 'acme/missing'}],
+    ['a leading slash', {repository: '/api'}],
+    ['a trailing slash', {repository: 'acme/'}],
+    ['more than one slash', {repository: 'acme/api/extra'}],
+  ])('rejects %s', async (_label, target) => {
+    const client = createClient();
+    const workspaceId = crypto.randomUUID();
+    const connectionId = crypto.randomUUID();
+    await insertProject({
+      workspaceId,
+      connectionId,
+      owner: 'acme',
+      name: 'new-name',
+    });
+
+    await expectUnauthorized(client, {
+      workspaceId,
+      defaults: {connectionId, owner: 'acme'},
+      target,
+    });
+  });
+});

package/src/presentation/inter-module.ts

@@ -1,16 +1,26 @@
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/inter-module';
 import {projectsInterModuleContract} from '@shipfox/api-projects-dto/inter-module';
 import {
   createInterModuleKnownError,
   defineInterModulePresentation,
   type InterModulePresentation,
 } from '@shipfox/inter-module';
-import {getProjectById, getWorkspaceProjectCounts} from '#db/projects.js';
+import {
+  getProjectById,
+  getProjectBySource,
+  getWorkspaceProjectCounts,
+  resolveCheckoutTarget,
+  updateProjectSourceMetadata,
+} from '#db/projects.js';
 
-export function createProjectsInterModulePresentation(): InterModulePresentation<
-  typeof projectsInterModuleContract
-> {
+export function createProjectsInterModulePresentation(params: {
+  integrations: Pick<IntegrationsModuleClient, 'resolveSourceRepository'>;
+}): InterModulePresentation<typeof projectsInterModuleContract> {
   return defineInterModulePresentation(projectsInterModuleContract, {
     getProjectById: async ({projectId}) => ({project: (await getProjectById(projectId)) ?? null}),
+    getProjectBySource: async (input) => ({
+      project: (await getProjectBySource(input)) ?? null,
+    }),
     requireProjectForWorkspace: async ({projectId, workspaceId}) => {
       const project = await getProjectById(projectId);
       if (project === undefined) {
@@ -32,5 +42,67 @@ export function createProjectsInterModulePresentation(): InterModulePresentation
     getWorkspaceProjectCounts: async ({workspaceIds}) => ({
       counts: await getWorkspaceProjectCounts({workspaceIds}),
     }),
+    resolveCheckoutTarget: async (input) => {
+      const target = await resolveCheckoutTarget(input);
+      if (target === undefined) {
+        throw createInterModuleKnownError(
+          projectsInterModuleContract.methods.resolveCheckoutTarget,
+          'checkout-repository-not-authorized',
+          {},
+        );
+      }
+
+      if ('repository' in input.target) {
+        const source = await params.integrations
+          .resolveSourceRepository({
+            workspaceId: input.workspaceId,
+            connectionId: target.connectionId,
+            externalRepositoryId: target.externalRepositoryId,
+          })
+          .catch(() => undefined);
+        if (source === undefined) {
+          throw createInterModuleKnownError(
+            projectsInterModuleContract.methods.resolveCheckoutTarget,
+            'checkout-repository-not-authorized',
+            {},
+          );
+        }
+
+        const separator = input.target.repository.indexOf('/');
+        const requestedOwner =
+          separator === -1 ? input.defaults.owner : input.target.repository.slice(0, separator);
+        const requestedName =
+          separator === -1 ? input.target.repository : input.target.repository.slice(separator + 1);
+        const repositoryMatches =
+          source.repository.owner.toLowerCase() === requestedOwner.toLowerCase() &&
+          source.repository.name.toLowerCase() === requestedName.toLowerCase();
+
+        await updateProjectSourceMetadata({
+          workspaceId: input.workspaceId,
+          projectId: target.projectId,
+          sourceConnectionId: source.connection.id,
+          sourceExternalRepositoryId: source.repository.externalRepositoryId,
+          sourceRepositoryOwner: source.repository.owner,
+          sourceRepositoryName: source.repository.name,
+          sourceDefaultBranch: source.repository.defaultBranch,
+        });
+
+        if (!repositoryMatches) {
+          throw createInterModuleKnownError(
+            projectsInterModuleContract.methods.resolveCheckoutTarget,
+            'checkout-repository-not-authorized',
+            {},
+          );
+        }
+
+        return {
+          ...target,
+          connectionId: source.connection.id,
+          externalRepositoryId: source.repository.externalRepositoryId,
+        };
+      }
+
+      return target;
+    },
   });
 }

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

@@ -6,7 +6,11 @@ import {
 import {createProjectBodySchema, projectResponseSchema} from '@shipfox/api-projects-dto';
 import {isInterModuleKnownError} from '@shipfox/inter-module';
 import {ClientError, defineRoute} from '@shipfox/node-fastify';
-import {createProjectFromSource, ProjectAlreadyExistsError} from '#core/index.js';
+import {
+  createProjectFromSource,
+  ProjectAlreadyExistsError,
+  ProjectSlugConflictError,
+} from '#core/index.js';
 import {toProjectDto} from '#presentation/dto/index.js';
 
 function providerStatus(reason: string): number {
@@ -73,6 +77,9 @@ export function createProjectRoute(integrations: IntegrationsModuleClient) {
           status: 409,
         });
       }
+      if (error instanceof ProjectSlugConflictError) {
+        throw new ClientError('Project slug already exists', 'slug-conflict', {status: 409});
+      }
       if (known?.code === 'provider-failure') {
         throw new ClientError('Integration provider request failed', known.details.reason, {
           details: {retry_after_seconds: known.details.retryAfterSeconds},
@@ -82,7 +89,7 @@ export function createProjectRoute(integrations: IntegrationsModuleClient) {
       throw error;
     },
     handler: async (request, reply) => {
-      const {workspace_id: workspaceId, name, source} = request.body;
+      const {workspace_id: workspaceId, name, slug, source} = request.body;
       const actor = requireUserContext(request);
 
       requireWorkspaceAccess({request, workspaceId});
@@ -90,6 +97,7 @@ export function createProjectRoute(integrations: IntegrationsModuleClient) {
         actorId: actor.userId,
         workspaceId,
         name,
+        slug,
         sourceConnectionId: source.connection_id,
         sourceExternalRepositoryId: source.external_repository_id,
         integrations,

package/src/presentation/routes/index.ts

@@ -5,6 +5,7 @@ import {createAdminProjectsRoute} from './admin-projects.js';
 import {createProjectRoute} from './create-project.js';
 import {getProjectRoute} from './get-project.js';
 import {listProjectsRoute} from './list-projects.js';
+import {updateProjectRoute} from './update-project.js';
 
 export function createProjectRoutes(
   integrations: IntegrationsModuleClient,
@@ -13,7 +14,12 @@ export function createProjectRoutes(
   return [
     {
       prefix: '/projects',
-      routes: [createProjectRoute(integrations), listProjectsRoute, getProjectRoute],
+      routes: [
+        createProjectRoute(integrations),
+        listProjectsRoute,
+        getProjectRoute,
+        updateProjectRoute,
+      ],
     },
     {
       prefix: '/admin/projects',