@shipfox/api-projects 11.0.0 → 12.2.0

package/drizzle/0000_initial.sql

@@ -3,7 +3,11 @@ CREATE TABLE "projects_projects" (
 	"workspace_id" uuid NOT NULL,
 	"source_connection_id" uuid NOT NULL,
 	"source_external_repository_id" text NOT NULL,
+	"source_repository_owner" text,
+	"source_repository_name" text,
+	"source_default_branch" text,
 	"name" text NOT NULL,
+	"slug" text NOT NULL,
 	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
 	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
 );
@@ -30,7 +34,9 @@ CREATE TABLE "projects_integration_event_dedup" (
 );
 --> statement-breakpoint
 CREATE UNIQUE INDEX "projects_source_unique" ON "projects_projects" USING btree ("source_connection_id","source_external_repository_id");--> statement-breakpoint
+CREATE UNIQUE INDEX "projects_workspace_slug_unique" ON "projects_projects" USING btree ("workspace_id","slug");--> statement-breakpoint
 CREATE INDEX "projects_workspace_created_id_idx" ON "projects_projects" USING btree ("workspace_id","created_at","id");--> statement-breakpoint
+CREATE INDEX "projects_source_repository_lookup_idx" ON "projects_projects" USING btree ("workspace_id","source_connection_id",lower("source_repository_owner"),lower("source_repository_name"));--> statement-breakpoint
 CREATE INDEX "projects_outbox_pending_idx" ON "projects_outbox" USING btree ("next_dispatch_at","created_at") WHERE "dispatched_at" IS NULL AND "dead_lettered_at" IS NULL;
 --> statement-breakpoint
 CREATE INDEX "projects_outbox_dispatched_retention_idx" ON "projects_outbox" USING btree ("dispatched_at","id") WHERE "dispatched_at" IS NOT NULL;--> statement-breakpoint

package/drizzle/meta/0000_snapshot.json

@@ -214,12 +214,36 @@
           "primaryKey": false,
           "notNull": true
         },
+        "source_repository_owner": {
+          "name": "source_repository_owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "source_repository_name": {
+          "name": "source_repository_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "source_default_branch": {
+          "name": "source_default_branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
         "name": {
           "name": "name",
           "type": "text",
           "primaryKey": false,
           "notNull": true
         },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
         "created_at": {
           "name": "created_at",
           "type": "timestamp with time zone",
@@ -257,6 +281,27 @@
           "method": "btree",
           "with": {}
         },
+        "projects_workspace_slug_unique": {
+          "name": "projects_workspace_slug_unique",
+          "columns": [
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
         "projects_workspace_created_id_idx": {
           "name": "projects_workspace_created_id_idx",
           "columns": [
@@ -283,6 +328,39 @@
           "concurrently": false,
           "method": "btree",
           "with": {}
+        },
+        "projects_source_repository_lookup_idx": {
+          "name": "projects_source_repository_lookup_idx",
+          "columns": [
+            {
+              "expression": "workspace_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "source_connection_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "lower(\"source_repository_owner\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "lower(\"source_repository_name\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
         }
       },
       "foreignKeys": {},

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-projects",
   "license": "MIT",
-  "version": "11.0.0",
+  "version": "12.2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -21,18 +21,19 @@
     "@temporalio/workflow": "1.18.1",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@shipfox/api-auth-dto": "10.2.0",
-    "@shipfox/api-auth-context": "11.0.0",
-    "@shipfox/api-integration-core-dto": "9.0.2",
-    "@shipfox/api-projects-dto": "10.1.0",
-    "@shipfox/inter-module": "0.2.2",
-    "@shipfox/node-drizzle": "0.3.4",
-    "@shipfox/node-fastify": "0.4.0",
-    "@shipfox/node-module": "1.0.4",
-    "@shipfox/node-opentelemetry": "0.6.3",
+    "@shipfox/api-auth-dto": "12.0.0",
+    "@shipfox/api-auth-context": "12.2.0",
+    "@shipfox/api-common-dto": "12.0.0",
+    "@shipfox/api-integration-core-dto": "12.2.0",
+    "@shipfox/api-projects-dto": "12.2.0",
+    "@shipfox/inter-module": "0.2.3",
+    "@shipfox/node-drizzle": "0.3.5",
+    "@shipfox/node-fastify": "0.4.2",
+    "@shipfox/node-module": "1.0.6",
+    "@shipfox/node-opentelemetry": "0.6.4",
     "@shipfox/node-outbox": "0.2.6",
-    "@shipfox/node-postgres": "0.4.4",
-    "@shipfox/node-temporal": "0.4.4"
+    "@shipfox/node-postgres": "0.5.0",
+    "@shipfox/node-temporal": "0.4.5"
   },
   "imports": {
     "#*": "./dist/*"

package/src/core/entities/project.ts

@@ -3,7 +3,11 @@ export interface Project {
   workspaceId: string;
   sourceConnectionId: string;
   sourceExternalRepositoryId: string;
+  sourceRepositoryOwner: string | null;
+  sourceRepositoryName: string | null;
+  sourceDefaultBranch: string | null;
   name: string;
+  slug: string;
   createdAt: Date;
   updatedAt: Date;
 }

package/src/core/errors.ts

@@ -24,3 +24,10 @@ export class ProjectAlreadyExistsError extends Error {
     this.name = 'ProjectAlreadyExistsError';
   }
 }
+
+export class ProjectSlugConflictError extends Error {
+  constructor(public readonly slug: string) {
+    super(`Project slug already exists: ${slug}`);
+    this.name = 'ProjectSlugConflictError';
+  }
+}

package/src/core/index.ts

@@ -3,6 +3,7 @@ export {
   ProjectAccessDeniedError,
   ProjectAlreadyExistsError,
   ProjectNotFoundError,
+  ProjectSlugConflictError,
 } from './errors.js';
-export type {CreateProjectFromSourceParams} from './projects.js';
-export {createProjectFromSource} from './projects.js';
+export type {CreateProjectFromSourceParams, UpdateProjectDetailsParams} from './projects.js';
+export {createProjectFromSource, updateProjectDetails} from './projects.js';

package/src/core/projects.test.ts

@@ -45,6 +45,7 @@ describe('createProjectFromSource', () => {
       actorId,
       workspaceId,
       name: 'Platform',
+      slug: 'platform',
       sourceConnectionId,
       sourceExternalRepositoryId: 'gitea:gitea-owner/platform',
       integrations: integrations as IntegrationsModuleClient,
@@ -52,8 +53,12 @@ describe('createProjectFromSource', () => {
 
     expect(project.workspaceId).toBe(workspaceId);
     expect(project.name).toBe('Platform');
+    expect(project.slug).toBe('platform');
     expect(project.sourceConnectionId).toBe(sourceConnectionId);
     expect(project.sourceExternalRepositoryId).toBe('gitea:gitea-owner/platform');
+    expect(project.sourceRepositoryOwner).toBe('gitea-owner');
+    expect(project.sourceRepositoryName).toBe('platform');
+    expect(project.sourceDefaultBranch).toBe('main');
   });
 
   test('emits project lifecycle events in the same transaction', async () => {
@@ -61,6 +66,7 @@ describe('createProjectFromSource', () => {
       actorId,
       workspaceId,
       name: 'Platform',
+      slug: 'platform',
       sourceConnectionId,
       sourceExternalRepositoryId: 'gitea:gitea-owner/platform',
       integrations: integrations as IntegrationsModuleClient,
@@ -78,6 +84,7 @@ describe('createProjectFromSource', () => {
     expect(events.map((event) => event.payload)).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
+          slug: 'platform',
           sourceConnectionId,
           sourceExternalRepositoryId: 'gitea:gitea-owner/platform',
         }),
@@ -95,6 +102,7 @@ describe('createProjectFromSource', () => {
       actorId,
       workspaceId,
       name: 'Platform',
+      slug: 'platform',
       sourceConnectionId,
       sourceExternalRepositoryId: 'gitea:gitea-owner/platform',
       integrations: integrations as IntegrationsModuleClient,
@@ -104,6 +112,7 @@ describe('createProjectFromSource', () => {
       actorId,
       workspaceId,
       name: 'Platform Again',
+      slug: 'platform-again',
       sourceConnectionId,
       sourceExternalRepositoryId: 'gitea:gitea-owner/platform',
       integrations: integrations as IntegrationsModuleClient,
@@ -125,6 +134,7 @@ describe('createProjectFromSource', () => {
       actorId,
       workspaceId,
       name: 'Missing',
+      slug: 'missing',
       sourceConnectionId,
       sourceExternalRepositoryId: 'not-found',
       integrations: integrations as IntegrationsModuleClient,

package/src/core/projects.ts

@@ -2,16 +2,25 @@ import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/i
 import {
   PROJECT_CREATED,
   PROJECT_SOURCE_BOUND,
+  PROJECT_UPDATED,
   type ProjectsEventMap,
 } from '@shipfox/api-projects-dto';
+import {isUniqueViolation} from '@shipfox/node-drizzle';
 import {writeOutboxEvent} from '@shipfox/node-outbox';
 import {and, eq} from 'drizzle-orm';
 import {db} from '#db/db.js';
+import {updateProject} from '#db/projects.js';
 import {projectsOutbox} from '#db/schema/outbox.js';
 import {projects, toProject} from '#db/schema/projects.js';
 import {recordProjectCreated} from '#metrics/instance.js';
 import type {Project} from './entities/project.js';
-import {ProjectAlreadyExistsError} from './errors.js';
+import {
+  ProjectAlreadyExistsError,
+  ProjectNotFoundError,
+  ProjectSlugConflictError,
+} from './errors.js';
+
+const PROJECTS_WORKSPACE_SLUG_UNIQUE_CONSTRAINT = 'projects_workspace_slug_unique';
 
 export interface CreateProjectFromSourceParams {
   actorId: string;
@@ -19,54 +28,68 @@ export interface CreateProjectFromSourceParams {
   name: string;
   sourceConnectionId: string;
   sourceExternalRepositoryId: string;
+  slug: string;
   integrations: IntegrationsModuleClient;
 }
 
 export async function createProjectFromSource(
   params: CreateProjectFromSourceParams,
 ): Promise<Project> {
-  let source: {
-    connection: {id: string; provider: string};
-    repository: {externalRepositoryId: string};
-  };
-  source = await params.integrations.resolveSourceRepository({
+  const source = await params.integrations.resolveSourceRepository({
     workspaceId: params.workspaceId,
     connectionId: params.sourceConnectionId,
     externalRepositoryId: params.sourceExternalRepositoryId,
   });
 
   const project = await db().transaction(async (tx) => {
-    const [projectRow] = await tx
-      .insert(projects)
-      .values({
-        workspaceId: params.workspaceId,
-        sourceConnectionId: source.connection.id,
-        sourceExternalRepositoryId: source.repository.externalRepositoryId,
-        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: source.connection.id,
+            sourceExternalRepositoryId: source.repository.externalRepositoryId,
+            sourceRepositoryOwner: source.repository.owner,
+            sourceRepositoryName: source.repository.name,
+            sourceDefaultBranch: source.repository.defaultBranch,
+            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 [existing] = await tx
-        .select()
-        .from(projects)
-        .where(
-          and(
-            eq(projects.sourceConnectionId, source.connection.id),
-            eq(projects.sourceExternalRepositoryId, source.repository.externalRepositoryId),
-          ),
-        )
-        .limit(1);
-      if (existing) {
-        throw new ProjectAlreadyExistsError(
-          existing.id,
-          source.connection.id,
-          source.repository.externalRepositoryId,
-        );
+      if (!projectRow) {
+        const [existing] = await tx
+          .select()
+          .from(projects)
+          .where(
+            and(
+              eq(projects.sourceConnectionId, source.connection.id),
+              eq(projects.sourceExternalRepositoryId, source.repository.externalRepositoryId),
+            ),
+          )
+          .limit(1);
+        if (existing) {
+          throw new ProjectAlreadyExistsError(
+            existing.id,
+            source.connection.id,
+            source.repository.externalRepositoryId,
+          );
+        }
       }
+    }
+
+    if (!projectRow) {
       throw new Error('Project insert returned no rows');
     }
 
@@ -78,6 +101,7 @@ export async function createProjectFromSource(
         actorId: params.actorId,
         workspaceId: project.workspaceId,
         projectId: project.id,
+        slug: project.slug,
         sourceConnectionId: project.sourceConnectionId,
         sourceExternalRepositoryId: project.sourceExternalRepositoryId,
       },
@@ -99,3 +123,34 @@ export async function createProjectFromSource(
   recordProjectCreated();
   return project;
 }
+
+export interface UpdateProjectDetailsParams {
+  actorId: string;
+  projectId: string;
+  name?: string | undefined;
+  slug?: string | undefined;
+}
+
+export function updateProjectDetails(params: UpdateProjectDetailsParams): Promise<Project> {
+  return db().transaction(async (tx) => {
+    const update = await updateProject(
+      {projectId: params.projectId, name: params.name, slug: params.slug},
+      {tx},
+    );
+    if (!update) throw new ProjectNotFoundError(params.projectId);
+    if (!update.changed) return update.project;
+
+    await writeOutboxEvent<ProjectsEventMap>(tx, projectsOutbox, {
+      type: PROJECT_UPDATED,
+      payload: {
+        actorId: params.actorId,
+        workspaceId: update.project.workspaceId,
+        projectId: update.project.id,
+        name: update.project.name,
+        slug: update.project.slug,
+      },
+    });
+
+    return update.project;
+  });
+}

package/src/db/db.ts

@@ -17,6 +17,9 @@ export function db() {
   return _db;
 }
 
+export type Tx = Parameters<Parameters<ReturnType<typeof db>['transaction']>[0]>[0];
+export type Executor = ReturnType<typeof db> | Tx;
+
 export function closeDb(): void {
   _db = undefined;
 }

package/src/db/index.ts

@@ -14,6 +14,10 @@ export type {
   ListAdminProjectsResult,
   ListProjectsParams,
   ListProjectsResult,
+  ResolveCheckoutTargetParams,
+  ResolvedCheckoutTarget,
+  UpdateProjectParams,
+  UpdateProjectResult,
 } from './projects.js';
 export {
   createProject,
@@ -24,6 +28,8 @@ export {
   listAdminProjects,
   listProjects,
   requireProjectForWorkspace,
+  resolveCheckoutTarget,
+  updateProject,
 } from './projects.js';
 export {projectsIntegrationEventDedup} from './schema/integration-event-dedup.js';
 export {projectsOutbox} from './schema/outbox.js';

package/src/db/projects.test.ts

@@ -1,5 +1,13 @@
+import {eq} from 'drizzle-orm';
 import {projectFactory} from '#test/index.js';
-import {getProjectCount, getWorkspaceProjectCounts} from './projects.js';
+import {db} from './db.js';
+import {
+  getProjectById,
+  getProjectCount,
+  getWorkspaceProjectCounts,
+  updateProject,
+} from './projects.js';
+import {projects} from './schema/projects.js';
 
 describe('getProjectCount', () => {
   it('reports the current project count', async () => {
@@ -28,3 +36,38 @@ describe('getProjectCount', () => {
     expect(counts).toEqual([{workspaceId, count: 0}]);
   });
 });
+
+describe('updateProject', () => {
+  it('preserves a concurrent update to fields omitted from a partial update', async () => {
+    const project = await projectFactory.create();
+    let allowStaleTransactionUpdate!: () => void;
+    let staleTransactionRead!: () => void;
+    const staleTransactionCanUpdate = new Promise<void>((resolve) => {
+      allowStaleTransactionUpdate = resolve;
+    });
+    const staleTransactionHasRead = new Promise<void>((resolve) => {
+      staleTransactionRead = resolve;
+    });
+
+    const staleTransaction = db().transaction(async (tx) => {
+      await tx.select({id: projects.id}).from(projects).where(eq(projects.id, project.id)).limit(1);
+      staleTransactionRead();
+      await staleTransactionCanUpdate;
+      return updateProject({projectId: project.id, slug: 'stale-slug-update'}, {tx});
+    });
+
+    await staleTransactionHasRead;
+    try {
+      await updateProject({projectId: project.id, name: 'Concurrent name'});
+    } finally {
+      allowStaleTransactionUpdate();
+    }
+    await staleTransaction;
+
+    const finalProject = await getProjectById(project.id);
+    expect(finalProject).toMatchObject({
+      name: 'Concurrent name',
+      slug: 'stale-slug-update',
+    });
+  });
+});