@shipfox/api-projects-dto 10.1.0 → 12.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-projects-dto",
   "license": "MIT",
-  "version": "10.1.0",
+  "version": "12.2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -23,8 +23,8 @@
   },
   "dependencies": {
     "zod": "^4.4.3",
-    "@shipfox/api-common-dto": "9.2.0",
-    "@shipfox/inter-module": "0.2.2"
+    "@shipfox/api-common-dto": "12.0.0",
+    "@shipfox/inter-module": "0.2.3"
   },
   "imports": {
     "#*": "./dist/*"

package/src/e2e/project.ts

@@ -1,10 +1,11 @@
-import {displayNameSchema} from '@shipfox/api-common-dto';
+import {displayNameSchema, slugSchema} from '@shipfox/api-common-dto';
 import {z} from 'zod';
 import {projectResponseSchema} from '../schemas/project.js';
 
 export const e2eCreateProjectBodySchema = z.object({
   workspace_id: z.string().uuid(),
   name: displayNameSchema,
+  slug: slugSchema.optional(),
   source_connection_id: z.string().uuid().optional(),
   source_external_repository_id: z.string().min(1).max(255).optional(),
 });

package/src/events.test.ts

@@ -0,0 +1,23 @@
+import {projectCreatedEventSchema} from './events.js';
+
+const legacyProjectCreatedEvent = {
+  actorId: 'actor-1',
+  workspaceId: 'workspace-1',
+  projectId: 'project-1',
+  sourceConnectionId: 'connection-1',
+  sourceExternalRepositoryId: 'repository-1',
+};
+
+describe('project created event schema', () => {
+  test('accepts legacy in-flight payloads without a slug', () => {
+    expect(projectCreatedEventSchema.parse(legacyProjectCreatedEvent)).toEqual(
+      legacyProjectCreatedEvent,
+    );
+  });
+
+  test('preserves slugs on new payloads', () => {
+    expect(
+      projectCreatedEventSchema.parse({...legacyProjectCreatedEvent, slug: 'project'}),
+    ).toMatchObject({slug: 'project'});
+  });
+});

package/src/events.ts

@@ -3,17 +3,36 @@ import {z} from 'zod';
 const nonEmptyStringSchema = z.string().nonempty();
 
 export const PROJECT_CREATED = 'projects.project.created' as const;
+export const PROJECT_UPDATED = 'projects.project.updated' as const;
 export const PROJECT_SOURCE_BOUND = 'projects.project.source_bound' as const;
 export const PROJECT_SOURCE_COMMIT_OBSERVED = 'projects.project.source_commit_observed' as const;
 
-export const projectCreatedEventSchema = z.object({
+const projectCreatedEventWithoutSlugSchema = z.object({
   actorId: nonEmptyStringSchema,
   workspaceId: nonEmptyStringSchema,
   projectId: nonEmptyStringSchema,
   sourceConnectionId: nonEmptyStringSchema,
   sourceExternalRepositoryId: nonEmptyStringSchema,
 });
-export type ProjectCreatedEvent = z.infer<typeof projectCreatedEventSchema>;
+
+const projectCreatedEventWithSlugSchema = projectCreatedEventWithoutSlugSchema.extend({
+  slug: nonEmptyStringSchema,
+});
+
+export const projectCreatedEventSchema = z.union([
+  projectCreatedEventWithSlugSchema,
+  projectCreatedEventWithoutSlugSchema,
+]);
+export type ProjectCreatedEvent = z.infer<typeof projectCreatedEventWithSlugSchema>;
+
+export const projectUpdatedEventSchema = z.object({
+  actorId: nonEmptyStringSchema,
+  workspaceId: nonEmptyStringSchema,
+  projectId: nonEmptyStringSchema,
+  name: nonEmptyStringSchema,
+  slug: nonEmptyStringSchema,
+});
+export type ProjectUpdatedEvent = z.infer<typeof projectUpdatedEventSchema>;
 
 export const projectSourceBoundEventSchema = z.object({
   actorId: nonEmptyStringSchema,
@@ -40,12 +59,14 @@ export type ProjectSourceCommitObservedEvent = z.infer<
 
 export interface ProjectsEventMap {
   [PROJECT_CREATED]: ProjectCreatedEvent;
+  [PROJECT_UPDATED]: ProjectUpdatedEvent;
   [PROJECT_SOURCE_BOUND]: ProjectSourceBoundEvent;
   [PROJECT_SOURCE_COMMIT_OBSERVED]: ProjectSourceCommitObservedEvent;
 }
 
 export const projectsEventSchemas = {
   [PROJECT_CREATED]: projectCreatedEventSchema,
+  [PROJECT_UPDATED]: projectUpdatedEventSchema,
   [PROJECT_SOURCE_BOUND]: projectSourceBoundEventSchema,
   [PROJECT_SOURCE_COMMIT_OBSERVED]: projectSourceCommitObservedEventSchema,
 } satisfies Record<keyof ProjectsEventMap, z.ZodType>;

package/src/inter-module.test.ts

@@ -9,11 +9,59 @@ describe('projectsInterModuleContract', () => {
         workspaceId: '00000000-0000-4000-8000-000000000002',
         sourceConnectionId: '00000000-0000-4000-8000-000000000003',
         sourceExternalRepositoryId: 'shipfox/project',
+        sourceRepositoryOwner: 'shipfox',
         name: 'Project',
       },
     });
 
     expect(result.project?.id).toBe(projectId);
+    expect(result.project?.sourceRepositoryOwner).toBe('shipfox');
+  });
+
+  test('accepts checkout targets addressed by project or repository', () => {
+    const workspaceId = '00000000-0000-4000-8000-000000000001';
+    const connectionId = '00000000-0000-4000-8000-000000000002';
+
+    expect(
+      projectsInterModuleContract.methods.resolveCheckoutTarget.input.parse({
+        workspaceId,
+        defaults: {connectionId, owner: 'acme'},
+        target: {project: '00000000-0000-4000-8000-000000000003'},
+      }).target,
+    ).toEqual({project: '00000000-0000-4000-8000-000000000003'});
+    expect(
+      projectsInterModuleContract.methods.resolveCheckoutTarget.input.parse({
+        workspaceId,
+        defaults: {connectionId, owner: 'acme'},
+        target: {connection: connectionId, repository: 'acme/api'},
+      }).target,
+    ).toEqual({connection: connectionId, repository: 'acme/api'});
+  });
+
+  test('accepts paginated workspace project source listings', () => {
+    const workspaceId = '00000000-0000-4000-8000-000000000001';
+    const cursor = {
+      createdAt: '2026-08-05T12:00:00.000Z',
+      id: '00000000-0000-4000-8000-000000000002',
+    };
+
+    expect(
+      projectsInterModuleContract.methods.listProjectsByWorkspace.input.parse({
+        workspaceId,
+        limit: 100,
+        cursor,
+      }),
+    ).toEqual({workspaceId, limit: 100, cursor});
+  });
+
+  test('defines the checkout authorization failure', () => {
+    const details = {};
+
+    expect(
+      projectsInterModuleContract.methods.resolveCheckoutTarget.errors[
+        'checkout-repository-not-authorized'
+      ].parse(details),
+    ).toEqual(details);
   });
 
   test.each([

package/src/inter-module.ts

@@ -7,12 +7,29 @@ const projectSchema = z.object({
   workspaceId: idSchema,
   sourceConnectionId: idSchema,
   sourceExternalRepositoryId: z.string(),
+  sourceRepositoryOwner: z.string().min(1).nullable().optional(),
   name: z.string(),
 });
 const workspaceProjectCountSchema = z.object({
   workspaceId: idSchema,
   count: z.number().int().nonnegative(),
 });
+const projectCursorSchema = z.object({
+  createdAt: z.string().datetime(),
+  id: idSchema,
+});
+const checkoutTargetSchema = z.union([
+  z.strictObject({project: idSchema}),
+  z.strictObject({
+    connection: idSchema.optional(),
+    repository: z.string().min(1),
+  }),
+]);
+const resolvedCheckoutTargetSchema = z.object({
+  projectId: idSchema,
+  connectionId: idSchema,
+  externalRepositoryId: z.string(),
+});
 
 /** Producer-owned project lookup and workspace ownership operations. */
 export const projectsInterModuleContract = defineInterModuleContract({
@@ -22,6 +39,25 @@ export const projectsInterModuleContract = defineInterModuleContract({
       input: z.object({projectId: idSchema}),
       output: z.object({project: projectSchema.nullable()}),
     },
+    getProjectBySource: {
+      input: z.object({
+        workspaceId: idSchema,
+        sourceConnectionId: idSchema,
+        sourceExternalRepositoryId: z.string(),
+      }),
+      output: z.object({project: projectSchema.nullable()}),
+    },
+    listProjectsByWorkspace: {
+      input: z.object({
+        workspaceId: idSchema,
+        limit: z.number().int().min(1).max(100),
+        cursor: projectCursorSchema.optional(),
+      }),
+      output: z.object({
+        projects: z.array(projectSchema),
+        nextCursor: projectCursorSchema.nullable(),
+      }),
+    },
     requireProjectForWorkspace: {
       input: z.object({projectId: idSchema, workspaceId: idSchema}),
       output: z.object({project: projectSchema}),
@@ -34,6 +70,17 @@ export const projectsInterModuleContract = defineInterModuleContract({
       input: z.object({workspaceIds: z.array(idSchema).min(1).max(100)}),
       output: z.object({counts: z.array(workspaceProjectCountSchema)}),
     },
+    resolveCheckoutTarget: {
+      input: z.object({
+        workspaceId: idSchema,
+        defaults: z.object({connectionId: idSchema, owner: z.string().min(1)}),
+        target: checkoutTargetSchema,
+      }),
+      output: resolvedCheckoutTargetSchema,
+      errors: {
+        'checkout-repository-not-authorized': z.object({}),
+      },
+    },
   },
 });
 

package/src/schemas/index.ts

@@ -17,4 +17,6 @@ export {
   projectDtoSchema,
   projectResponseSchema,
   projectSourceDtoSchema,
+  type UpdateProjectBodyDto,
+  updateProjectBodySchema,
 } from './project.js';

package/src/schemas/project.ts

@@ -1,4 +1,4 @@
-import {displayNameSchema} from '@shipfox/api-common-dto';
+import {displayNameSchema, slugSchema} from '@shipfox/api-common-dto';
 import {z} from 'zod';
 
 export const projectSourceDtoSchema = z.object({
@@ -10,6 +10,7 @@ export type ProjectSourceDto = z.infer<typeof projectSourceDtoSchema>;
 export const createProjectBodySchema = z.object({
   workspace_id: z.string().uuid(),
   name: displayNameSchema,
+  slug: slugSchema,
   source: z.object({
     connection_id: z.string().uuid(),
     external_repository_id: z.string().min(1).max(255),
@@ -18,10 +19,20 @@ export const createProjectBodySchema = z.object({
 
 export type CreateProjectBodyDto = z.infer<typeof createProjectBodySchema>;
 
+export const updateProjectBodySchema = z
+  .object({
+    name: displayNameSchema.optional(),
+    slug: slugSchema.optional(),
+  })
+  .partial();
+
+export type UpdateProjectBodyDto = z.infer<typeof updateProjectBodySchema>;
+
 export const projectDtoSchema = z.object({
   id: z.string().uuid(),
   workspace_id: z.string().uuid(),
   name: z.string(),
+  slug: slugSchema,
   source: projectSourceDtoSchema,
   created_at: z.string(),
   updated_at: z.string(),