@shipfox/api-projects 11.0.0 → 12.2.0

package/src/db/projects.ts

@@ -1,15 +1,35 @@
-import {and, count, desc, eq, ilike, inArray, lt, or, type SQL} from 'drizzle-orm';
+import {isUniqueViolation} from '@shipfox/node-drizzle';
+import {and, count, desc, eq, ilike, inArray, lt, or, type SQL, sql} from 'drizzle-orm';
 import type {Project} from '#core/entities/project.js';
-import {ProjectAlreadyExistsError, ProjectNotFoundError} from '#core/errors.js';
+import {
+  ProjectAlreadyExistsError,
+  ProjectNotFoundError,
+  ProjectSlugConflictError,
+} from '#core/errors.js';
 import {recordProjectCreated} from '#metrics/instance.js';
-import {db} from './db.js';
+import {db, type Executor} from './db.js';
 import {projects, toProject} from './schema/projects.js';
 
+type ProjectDatabase = ReturnType<typeof db>;
+type ProjectTransaction = Parameters<Parameters<ProjectDatabase['transaction']>[0]>[0];
+
 export interface CreateProjectParams {
   workspaceId: string;
   sourceConnectionId: string;
   sourceExternalRepositoryId: string;
   name: string;
+  slug: string;
+}
+
+export interface UpdateProjectParams {
+  projectId: string;
+  name?: string | undefined;
+  slug?: string | undefined;
+}
+
+export interface UpdateProjectResult {
+  project: Project;
+  changed: boolean;
 }
 
 export interface ProjectCursor {
@@ -50,6 +70,8 @@ export interface ListAdminProjectsResult {
   nextCursor: ProjectCursor | null;
 }
 
+const PROJECTS_WORKSPACE_SLUG_UNIQUE_CONSTRAINT = 'projects_workspace_slug_unique';
+
 function cursorWhere(cursor: ProjectCursor | undefined): SQL | undefined {
   if (!cursor) return undefined;
   return or(
@@ -60,37 +82,51 @@ function cursorWhere(cursor: ProjectCursor | undefined): SQL | undefined {
 
 export async function createProject(params: CreateProjectParams): Promise<Project> {
   const project = await db().transaction(async (tx) => {
-    const [projectRow] = await tx
-      .insert(projects)
-      .values({
-        workspaceId: params.workspaceId,
-        sourceConnectionId: params.sourceConnectionId,
-        sourceExternalRepositoryId: params.sourceExternalRepositoryId,
-        name: params.name,
-      })
-      .onConflictDoNothing({
-        target: [projects.sourceConnectionId, projects.sourceExternalRepositoryId],
-      })
-      .returning();
+    let projectRow: typeof projects.$inferSelect | undefined;
+    for (let attempt = 0; attempt < 2 && !projectRow; attempt += 1) {
+      try {
+        [projectRow] = await tx
+          .insert(projects)
+          .values({
+            workspaceId: params.workspaceId,
+            sourceConnectionId: params.sourceConnectionId,
+            sourceExternalRepositoryId: params.sourceExternalRepositoryId,
+            name: params.name,
+            slug: params.slug,
+          })
+          .onConflictDoNothing({
+            target: [projects.sourceConnectionId, projects.sourceExternalRepositoryId],
+          })
+          .returning();
+      } catch (error) {
+        if (isUniqueViolation(error, PROJECTS_WORKSPACE_SLUG_UNIQUE_CONSTRAINT)) {
+          throw new ProjectSlugConflictError(params.slug);
+        }
+        throw error;
+      }
 
-    if (!projectRow) {
-      const [conflict] = await tx
-        .select()
-        .from(projects)
-        .where(
-          and(
-            eq(projects.sourceConnectionId, params.sourceConnectionId),
-            eq(projects.sourceExternalRepositoryId, params.sourceExternalRepositoryId),
-          ),
-        )
-        .limit(1);
-      if (conflict) {
-        throw new ProjectAlreadyExistsError(
-          conflict.id,
-          params.sourceConnectionId,
-          params.sourceExternalRepositoryId,
-        );
+      if (!projectRow) {
+        const [conflict] = await tx
+          .select()
+          .from(projects)
+          .where(
+            and(
+              eq(projects.sourceConnectionId, params.sourceConnectionId),
+              eq(projects.sourceExternalRepositoryId, params.sourceExternalRepositoryId),
+            ),
+          )
+          .limit(1);
+        if (conflict) {
+          throw new ProjectAlreadyExistsError(
+            conflict.id,
+            params.sourceConnectionId,
+            params.sourceExternalRepositoryId,
+          );
+        }
       }
+    }
+
+    if (!projectRow) {
       throw new Error('Insert returned no rows');
     }
 
@@ -100,6 +136,45 @@ export async function createProject(params: CreateProjectParams): Promise<Projec
   return project;
 }
 
+export async function updateProject(
+  params: UpdateProjectParams,
+  options: {tx?: ProjectDatabase | ProjectTransaction | undefined} = {},
+): Promise<UpdateProjectResult | undefined> {
+  const executor = options.tx ?? db();
+
+  const [existingRow] = await executor
+    .select()
+    .from(projects)
+    .where(eq(projects.id, params.projectId))
+    .limit(1);
+  if (!existingRow) return undefined;
+
+  const nextName = params.name ?? existingRow.name;
+  const nextSlug = params.slug ?? existingRow.slug;
+  if (nextName === existingRow.name && nextSlug === existingRow.slug) {
+    return {project: toProject(existingRow), changed: false};
+  }
+
+  try {
+    const [row] = await executor
+      .update(projects)
+      .set({
+        ...(params.name !== undefined ? {name: params.name} : {}),
+        ...(params.slug !== undefined ? {slug: params.slug} : {}),
+        updatedAt: new Date(),
+      })
+      .where(eq(projects.id, params.projectId))
+      .returning();
+
+    return row ? {project: toProject(row), changed: true} : undefined;
+  } catch (error) {
+    if (isUniqueViolation(error, PROJECTS_WORKSPACE_SLUG_UNIQUE_CONSTRAINT)) {
+      throw new ProjectSlugConflictError(nextSlug);
+    }
+    throw error;
+  }
+}
+
 export async function getProjectById(id: string): Promise<Project | undefined> {
   const rows = await db().select().from(projects).where(eq(projects.id, id)).limit(1);
 
@@ -134,6 +209,39 @@ export async function getProjectBySource(
   return toProject(row);
 }
 
+export interface UpdateProjectSourceRepositoryParams extends GetProjectBySourceParams {
+  tx?: Executor;
+  sourceRepositoryOwner: string;
+  sourceRepositoryName: string;
+  sourceDefaultBranch: string;
+}
+
+export async function updateProjectSourceRepository(
+  params: UpdateProjectSourceRepositoryParams,
+): Promise<Project | undefined> {
+  const executor = params.tx ?? db();
+  const rows = await executor
+    .update(projects)
+    .set({
+      sourceRepositoryOwner: params.sourceRepositoryOwner,
+      sourceRepositoryName: params.sourceRepositoryName,
+      sourceDefaultBranch: params.sourceDefaultBranch,
+      updatedAt: new Date(),
+    })
+    .where(
+      and(
+        eq(projects.workspaceId, params.workspaceId),
+        eq(projects.sourceConnectionId, params.sourceConnectionId),
+        eq(projects.sourceExternalRepositoryId, params.sourceExternalRepositoryId),
+      ),
+    )
+    .returning();
+
+  const row = rows[0];
+  if (!row) return undefined;
+  return toProject(row);
+}
+
 export async function requireProjectForWorkspace(params: {
   projectId: string;
   workspaceId: string;
@@ -144,12 +252,113 @@ export async function requireProjectForWorkspace(params: {
   return project;
 }
 
+export interface ResolveCheckoutTargetParams {
+  workspaceId: string;
+  defaults: {
+    connectionId: string;
+    owner: string;
+  };
+  target: {project: string} | {connection?: string | undefined; repository: string};
+}
+
+export interface ResolvedCheckoutTarget {
+  projectId: string;
+  connectionId: string;
+  externalRepositoryId: string;
+}
+
+export interface UpdateProjectSourceMetadataParams {
+  workspaceId: string;
+  projectId: string;
+  sourceConnectionId: string;
+  sourceExternalRepositoryId: string;
+  sourceRepositoryOwner: string;
+  sourceRepositoryName: string;
+  sourceDefaultBranch: string;
+}
+
+export async function updateProjectSourceMetadata(
+  params: UpdateProjectSourceMetadataParams,
+): Promise<void> {
+  await db()
+    .update(projects)
+    .set({
+      sourceConnectionId: params.sourceConnectionId,
+      sourceExternalRepositoryId: params.sourceExternalRepositoryId,
+      sourceRepositoryOwner: params.sourceRepositoryOwner,
+      sourceRepositoryName: params.sourceRepositoryName,
+      sourceDefaultBranch: params.sourceDefaultBranch,
+      updatedAt: new Date(),
+    })
+    .where(and(eq(projects.workspaceId, params.workspaceId), eq(projects.id, params.projectId)));
+}
+
+export async function resolveCheckoutTarget(
+  params: ResolveCheckoutTargetParams,
+): Promise<ResolvedCheckoutTarget | undefined> {
+  const selection = {
+    projectId: projects.id,
+    connectionId: projects.sourceConnectionId,
+    externalRepositoryId: projects.sourceExternalRepositoryId,
+  };
+
+  if ('project' in params.target) {
+    const [project] = await db()
+      .select(selection)
+      .from(projects)
+      .where(
+        and(eq(projects.workspaceId, params.workspaceId), eq(projects.id, params.target.project)),
+      )
+      .limit(1);
+    return project;
+  }
+
+  const separator = params.target.repository.indexOf('/');
+  if (separator === 0 || separator === params.target.repository.length - 1) return undefined;
+
+  const repository =
+    separator === -1
+      ? {
+          connectionId: params.target.connection ?? params.defaults.connectionId,
+          owner: params.defaults.owner,
+          name: params.target.repository,
+        }
+      : params.target.repository.indexOf('/', separator + 1) === -1
+        ? {
+            connectionId: params.target.connection ?? params.defaults.connectionId,
+            owner: params.target.repository.slice(0, separator),
+            name: params.target.repository.slice(separator + 1),
+          }
+        : undefined;
+  if (repository === undefined) return undefined;
+
+  const matches = await db()
+    .select(selection)
+    .from(projects)
+    .where(
+      and(
+        eq(projects.workspaceId, params.workspaceId),
+        eq(projects.sourceConnectionId, repository.connectionId),
+        sql`lower(${projects.sourceRepositoryOwner}) = lower(${repository.owner})`,
+        sql`lower(${projects.sourceRepositoryName}) = lower(${repository.name})`,
+      ),
+    )
+    .limit(2);
+
+  // Owner/name isn't a unique key: renamed or reconnected repositories can leave
+  // more than one project row matching. Fail closed instead of picking arbitrarily.
+  return matches.length === 1 ? matches[0] : undefined;
+}
+
 export async function listProjects(params: ListProjectsParams): Promise<ListProjectsResult> {
   const conditions = [eq(projects.workspaceId, params.workspaceId)];
   const cursorCondition = cursorWhere(params.cursor);
   if (cursorCondition) conditions.push(cursorCondition);
   if (params.search) {
-    conditions.push(ilike(projects.name, `%${escapeIlikePattern(params.search)}%`));
+    const searchPattern = `%${escapeIlikePattern(params.search)}%`;
+    conditions.push(
+      or(ilike(projects.name, searchPattern), ilike(projects.slug, searchPattern)) as SQL,
+    );
   }
 
   const rows = await db()

package/src/db/schema/projects.ts

@@ -1,4 +1,5 @@
 import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {sql} from 'drizzle-orm';
 import {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
 import type {Project} from '#core/entities/project.js';
 import {pgTable} from './common.js';
@@ -10,7 +11,11 @@ export const projects = pgTable(
     workspaceId: uuid('workspace_id').notNull(),
     sourceConnectionId: uuid('source_connection_id').notNull(),
     sourceExternalRepositoryId: text('source_external_repository_id').notNull(),
+    sourceRepositoryOwner: text('source_repository_owner'),
+    sourceRepositoryName: text('source_repository_name'),
+    sourceDefaultBranch: text('source_default_branch'),
     name: text('name').notNull(),
+    slug: text('slug').notNull(),
     createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
     updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),
   },
@@ -19,7 +24,14 @@ export const projects = pgTable(
       table.sourceConnectionId,
       table.sourceExternalRepositoryId,
     ),
+    uniqueIndex('projects_workspace_slug_unique').on(table.workspaceId, table.slug),
     index('projects_workspace_created_id_idx').on(table.workspaceId, table.createdAt, table.id),
+    index('projects_source_repository_lookup_idx').on(
+      table.workspaceId,
+      table.sourceConnectionId,
+      sql`lower(${table.sourceRepositoryOwner})`,
+      sql`lower(${table.sourceRepositoryName})`,
+    ),
   ],
 );
 
@@ -32,7 +44,11 @@ export function toProject(row: ProjectDb): Project {
     workspaceId: row.workspaceId,
     sourceConnectionId: row.sourceConnectionId,
     sourceExternalRepositoryId: row.sourceExternalRepositoryId,
+    sourceRepositoryOwner: row.sourceRepositoryOwner,
+    sourceRepositoryName: row.sourceRepositoryName,
+    sourceDefaultBranch: row.sourceDefaultBranch,
     name: row.name,
+    slug: row.slug,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
   };

package/src/index.ts

@@ -3,6 +3,7 @@ import {fileURLToPath} from 'node:url';
 import type {AuthInterModuleClient} from '@shipfox/api-auth-dto/inter-module';
 import {
   INTEGRATION_SOURCE_COMMIT_PUSHED,
+  INTEGRATION_SOURCE_REPOSITORY_UPDATED,
   type IntegrationsEventMap,
 } from '@shipfox/api-integration-core-dto';
 import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/inter-module';
@@ -13,7 +14,7 @@ import {registerProjectsServiceMetrics} from '#metrics/index.js';
 import {projectsE2eRoutes} from '#presentation/e2eRoutes/index.js';
 import {createProjectRoutes} from '#presentation/index.js';
 import {createProjectsInterModulePresentation} from '#presentation/inter-module.js';
-import {onSourceCommitPushed} from '#presentation/subscribers/index.js';
+import {onSourceCommitPushed, onSourceRepositoryUpdated} from '#presentation/subscribers/index.js';
 import {createProjectsMaintenanceActivities} from '#temporal/activities/index.js';
 import {PROJECTS_MAINTENANCE_TASK_QUEUE} from '#temporal/constants.js';
 
@@ -28,6 +29,8 @@ export {
   ProjectAccessDeniedError,
   ProjectAlreadyExistsError,
   ProjectNotFoundError,
+  ProjectSlugConflictError,
+  updateProjectDetails,
 } from '#core/index.js';
 export type {GetProjectBySourceParams} from '#db/index.js';
 export {
@@ -59,8 +62,11 @@ export function createProjectsModule({
     e2eRoutes: [projectsE2eRoutes],
     metrics: registerProjectsServiceMetrics,
     publishers: [{name: 'projects', table: projectsOutbox, db, eventSchemas: projectsEventSchemas}],
-    interModulePresentations: [createProjectsInterModulePresentation()],
-    subscribers: [subscriber(INTEGRATION_SOURCE_COMMIT_PUSHED, onSourceCommitPushed)],
+    interModulePresentations: [createProjectsInterModulePresentation({integrations})],
+    subscribers: [
+      subscriber(INTEGRATION_SOURCE_COMMIT_PUSHED, onSourceCommitPushed),
+      subscriber(INTEGRATION_SOURCE_REPOSITORY_UPDATED, onSourceRepositoryUpdated),
+    ],
     workers: [
       {
         taskQueue: PROJECTS_MAINTENANCE_TASK_QUEUE,

package/src/presentation/dto/project.ts

@@ -6,6 +6,7 @@ export function toProjectDto(project: Project) {
     id: project.id,
     workspace_id: project.workspaceId,
     name: project.name,
+    slug: project.slug,
     source: {
       connection_id: project.sourceConnectionId,
       external_repository_id: project.sourceExternalRepositoryId,

package/src/presentation/e2eRoutes/create-project.test.ts

@@ -6,6 +6,7 @@ import {projectsE2eRoutes} from './index.js';
 
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
 const E2E_SOURCE_RE = /^e2e:/u;
+const GENERATED_PROJECT_SLUG_RE = /^e2e-project-/u;
 
 describe('projects E2E routes', () => {
   afterEach(async () => {
@@ -34,6 +35,28 @@ describe('projects E2E routes', () => {
     expect(res.json().source.external_repository_id).toMatch(E2E_SOURCE_RE);
   });
 
+  test('generates distinct slugs for repeated names in one workspace', async () => {
+    const workspaceId = crypto.randomUUID();
+    const app = await createApp({routes: [projectsE2eRoutes], swagger: false});
+
+    const first = await app.inject({
+      method: 'POST',
+      url: '/projects',
+      payload: {workspace_id: workspaceId, name: 'E2E Project'},
+    });
+    const second = await app.inject({
+      method: 'POST',
+      url: '/projects',
+      payload: {workspace_id: workspaceId, name: 'E2E Project'},
+    });
+
+    expect(first.statusCode).toBe(201);
+    expect(second.statusCode).toBe(201);
+    expect(first.json().slug).toMatch(GENERATED_PROJECT_SLUG_RE);
+    expect(second.json().slug).toMatch(GENERATED_PROJECT_SLUG_RE);
+    expect(second.json().slug).not.toBe(first.json().slug);
+  });
+
   test('preserves explicit synthetic source values', async () => {
     const workspaceId = crypto.randomUUID();
     const sourceConnectionId = crypto.randomUUID();

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

@@ -1,10 +1,11 @@
 import {randomUUID} from 'node:crypto';
+import {slugifyName, withSlugSuffix} from '@shipfox/api-common-dto';
 import {
   e2eCreateProjectBodySchema,
   e2eCreateProjectResponseSchema,
 } from '@shipfox/api-projects-dto';
 import {ClientError, defineRoute} from '@shipfox/node-fastify';
-import {ProjectAlreadyExistsError} from '#core/index.js';
+import {ProjectAlreadyExistsError, ProjectSlugConflictError} from '#core/index.js';
 import {createProject} from '#db/index.js';
 import {toProjectDto} from '#presentation/dto/index.js';
 
@@ -12,6 +13,13 @@ function syntheticExternalRepositoryId(): string {
   return `e2e:${randomUUID()}`;
 }
 
+const MAX_GENERATED_SLUG_ATTEMPTS = 5;
+
+function generatedProjectSlug(slugBase: string): string {
+  const suffix = Number.parseInt(randomUUID().replaceAll('-', '').slice(0, 8), 16);
+  return withSlugSuffix(slugBase, suffix);
+}
+
 export const createE2eProjectRoute = defineRoute({
   method: 'POST',
   path: '/',
@@ -33,18 +41,39 @@ export const createE2eProjectRoute = defineRoute({
         status: 409,
       });
     }
+    if (error instanceof ProjectSlugConflictError) {
+      throw new ClientError('Project slug already exists', 'slug-conflict', {status: 409});
+    }
     throw error;
   },
   handler: async (request, reply) => {
-    const project = await createProject({
-      workspaceId: request.body.workspace_id,
-      name: request.body.name,
-      sourceConnectionId: request.body.source_connection_id ?? randomUUID(),
-      sourceExternalRepositoryId:
-        request.body.source_external_repository_id ?? syntheticExternalRepositoryId(),
-    });
+    const requestedSlug = request.body.slug;
+    const slugBase = slugifyName(request.body.name, {fallback: 'project'});
+    let slug = requestedSlug ?? generatedProjectSlug(slugBase);
+
+    for (let attempt = 0; attempt < MAX_GENERATED_SLUG_ATTEMPTS; attempt += 1) {
+      try {
+        const project = await createProject({
+          workspaceId: request.body.workspace_id,
+          name: request.body.name,
+          slug,
+          sourceConnectionId: request.body.source_connection_id ?? randomUUID(),
+          sourceExternalRepositoryId:
+            request.body.source_external_repository_id ?? syntheticExternalRepositoryId(),
+        });
+
+        reply.code(201);
+        return toProjectDto(project);
+      } catch (error) {
+        const shouldRetrySlug =
+          requestedSlug === undefined &&
+          error instanceof ProjectSlugConflictError &&
+          attempt < MAX_GENERATED_SLUG_ATTEMPTS - 1;
+        if (!shouldRetrySlug) throw error;
+        slug = generatedProjectSlug(slugBase);
+      }
+    }
 
-    reply.code(201);
-    return toProjectDto(project);
+    throw new Error('Unable to generate a unique project slug');
   },
 });