@shipfox/api-projects-dto 10.0.0 → 12.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-projects-dto",
   "license": "MIT",
-  "version": "10.0.0",
+  "version": "12.0.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,43 @@ 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('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,25 @@ 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 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 +35,14 @@ 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()}),
+    },
     requireProjectForWorkspace: {
       input: z.object({projectId: idSchema, workspaceId: idSchema}),
       output: z.object({project: projectSchema}),
@@ -34,6 +55,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

@@ -1,8 +1,14 @@
 export {
+  type AdminProjectSummaryDto,
+  adminProjectSummaryDtoSchema,
   type CreateProjectBodyDto,
   createProjectBodySchema,
+  type ListAdminProjectsQueryDto,
+  type ListAdminProjectsResponseDto,
   type ListProjectsQueryDto,
   type ListProjectsResponseDto,
+  listAdminProjectsQuerySchema,
+  listAdminProjectsResponseSchema,
   listProjectsQuerySchema,
   listProjectsResponseSchema,
   type ProjectDto,
@@ -11,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(),
@@ -48,3 +59,30 @@ export const listProjectsResponseSchema = z.object({
 });
 
 export type ListProjectsResponseDto = z.infer<typeof listProjectsResponseSchema>;
+
+export const adminProjectSummaryDtoSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  status: z.literal('active'),
+  workspace_id: z.string().uuid(),
+  created_at: z.string(),
+  updated_at: z.string(),
+});
+
+export type AdminProjectSummaryDto = z.infer<typeof adminProjectSummaryDtoSchema>;
+
+export const listAdminProjectsQuerySchema = z.object({
+  project_id: z.string().uuid().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(50),
+  cursor: z.string().optional(),
+  search: z.string().min(1).max(100).optional(),
+});
+
+export type ListAdminProjectsQueryDto = z.infer<typeof listAdminProjectsQuerySchema>;
+
+export const listAdminProjectsResponseSchema = z.object({
+  projects: z.array(adminProjectSummaryDtoSchema),
+  next_cursor: z.string().nullable(),
+});
+
+export type ListAdminProjectsResponseDto = z.infer<typeof listAdminProjectsResponseSchema>;