@shipfox/api-projects 5.0.0 → 7.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-projects",
   "license": "MIT",
-  "version": "5.0.0",
+  "version": "7.1.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -25,39 +25,23 @@
     "@temporalio/workflow": "1.18.1",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@shipfox/api-auth-context": "5.0.0",
-    "@shipfox/api-integration-core": "5.0.0",
-    "@shipfox/api-integration-core-dto": "5.0.0",
-    "@shipfox/api-projects-dto": "5.0.0",
-    "@shipfox/node-drizzle": "0.3.1",
-    "@shipfox/node-fastify": "0.2.3",
-    "@shipfox/node-module": "0.3.2",
-    "@shipfox/node-opentelemetry": "0.5.2",
-    "@shipfox/node-outbox": "0.2.3",
+    "@shipfox/api-auth-context": "7.1.0",
+    "@shipfox/api-integration-core-dto": "6.0.0",
+    "@shipfox/api-projects-dto": "6.0.0",
+    "@shipfox/inter-module": "0.2.0",
+    "@shipfox/node-drizzle": "0.3.2",
+    "@shipfox/node-fastify": "0.3.0",
+    "@shipfox/node-module": "0.5.0",
+    "@shipfox/node-opentelemetry": "0.6.0",
+    "@shipfox/node-outbox": "0.2.4",
     "@shipfox/node-postgres": "0.4.2",
-    "@shipfox/node-temporal": "0.3.1"
-  },
-  "devDependencies": {
-    "@temporalio/activity": "1.18.1",
-    "@temporalio/client": "1.18.1",
-    "@temporalio/common": "1.18.1",
-    "@temporalio/testing": "1.18.1",
-    "@temporalio/worker": "1.18.1",
-    "@types/pg": "^8.15.5",
-    "drizzle-kit": "^0.31.10",
-    "fastify": "^5.3.3",
-    "fastify-type-provider-zod": "^6.0.0",
-    "fishery": "^2.4.0",
-    "@shipfox/biome": "1.8.2",
-    "@shipfox/swc": "1.2.6",
-    "@shipfox/ts-config": "1.3.8",
-    "@shipfox/typescript": "1.1.7",
-    "@shipfox/vitest": "1.2.3"
+    "@shipfox/node-temporal": "0.4.0"
   },
   "scripts": {
     "build": "shipfox-swc && shipfox-temporal-bundle dist/temporal/workflows/index.js",
     "check": "shipfox-biome-check",
     "check:fix": "shipfox-biome-check --write",
+    "depcruise": "shipfox-depcruise",
     "test": "shipfox-vitest-run",
     "test:watch": "shipfox-vitest-watch",
     "type": "shipfox-tsc-check",

package/src/core/projects.test.ts

@@ -1,5 +1,6 @@
-import type {IntegrationSourceControlService} from '@shipfox/api-integration-core';
-import {IntegrationProviderError} from '@shipfox/api-integration-core';
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto';
+import {integrationsInterModuleContract} from '@shipfox/api-integration-core-dto';
+import {createInterModuleKnownError} from '@shipfox/inter-module';
 import {sql} from 'drizzle-orm';
 import {db} from '#db/index.js';
 import {projectsOutbox} from '#db/schema/outbox.js';
@@ -9,29 +10,20 @@ describe('createProjectFromSource', () => {
   let actorId: string;
   let workspaceId: string;
   let sourceConnectionId: string;
-  let sourceControl: IntegrationSourceControlService;
+  let integrations: Pick<IntegrationsModuleClient, 'resolveSourceRepository'>;
 
   beforeEach(() => {
     actorId = crypto.randomUUID();
     workspaceId = crypto.randomUUID();
     sourceConnectionId = crypto.randomUUID();
-    sourceControl = {
-      getConnection: vi.fn(),
-      listRepositories: vi.fn(),
-      resolveRepository: vi.fn(async () => {
+    integrations = {
+      resolveSourceRepository: vi.fn(async () => {
         await Promise.resolve();
         return {
           connection: {
             id: sourceConnectionId,
-            workspaceId,
             provider: 'gitea' as const,
-            externalAccountId: 'gitea-owner',
             slug: 'gitea_owner',
-            displayName: 'Gitea',
-            lifecycleStatus: 'active' as const,
-            capabilities: ['source_control' as const],
-            createdAt: new Date(),
-            updatedAt: new Date(),
           },
           repository: {
             externalRepositoryId: 'gitea:gitea-owner/platform',
@@ -45,9 +37,6 @@ describe('createProjectFromSource', () => {
           },
         };
       }),
-      listFiles: vi.fn(),
-      fetchFile: vi.fn(),
-      createCheckoutSpec: vi.fn(),
     };
   });
 
@@ -58,7 +47,7 @@ describe('createProjectFromSource', () => {
       name: 'Platform',
       sourceConnectionId,
       sourceExternalRepositoryId: 'gitea:gitea-owner/platform',
-      sourceControl,
+      integrations: integrations as IntegrationsModuleClient,
     });
 
     expect(project.workspaceId).toBe(workspaceId);
@@ -74,7 +63,7 @@ describe('createProjectFromSource', () => {
       name: 'Platform',
       sourceConnectionId,
       sourceExternalRepositoryId: 'gitea:gitea-owner/platform',
-      sourceControl,
+      integrations: integrations as IntegrationsModuleClient,
     });
 
     const events = await db()
@@ -108,7 +97,7 @@ describe('createProjectFromSource', () => {
       name: 'Platform',
       sourceConnectionId,
       sourceExternalRepositoryId: 'gitea:gitea-owner/platform',
-      sourceControl,
+      integrations: integrations as IntegrationsModuleClient,
     });
 
     const result = createProjectFromSource({
@@ -117,15 +106,19 @@ describe('createProjectFromSource', () => {
       name: 'Platform Again',
       sourceConnectionId,
       sourceExternalRepositoryId: 'gitea:gitea-owner/platform',
-      sourceControl,
+      integrations: integrations as IntegrationsModuleClient,
     });
 
     await expect(result).rejects.toThrow('Project already exists');
   });
 
   test('surfaces provider repository access failures', async () => {
-    vi.mocked(sourceControl.resolveRepository).mockRejectedValueOnce(
-      new IntegrationProviderError('repository-not-found', 'Repository not found'),
+    vi.mocked(integrations.resolveSourceRepository).mockRejectedValueOnce(
+      createInterModuleKnownError(
+        integrationsInterModuleContract.methods.resolveSourceRepository,
+        'provider-failure',
+        {reason: 'repository-not-found'},
+      ),
     );
 
     const result = createProjectFromSource({
@@ -134,9 +127,12 @@ describe('createProjectFromSource', () => {
       name: 'Missing',
       sourceConnectionId,
       sourceExternalRepositoryId: 'not-found',
-      sourceControl,
+      integrations: integrations as IntegrationsModuleClient,
     });
 
-    await expect(result).rejects.toMatchObject({reason: 'repository-not-found'});
+    await expect(result).rejects.toMatchObject({
+      code: 'provider-failure',
+      details: {reason: 'repository-not-found'},
+    });
   });
 });

package/src/core/projects.ts

@@ -1,4 +1,4 @@
-import type {IntegrationSourceControlService} from '@shipfox/api-integration-core';
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto';
 import {
   PROJECT_CREATED,
   PROJECT_SOURCE_BOUND,
@@ -19,13 +19,17 @@ export interface CreateProjectFromSourceParams {
   name: string;
   sourceConnectionId: string;
   sourceExternalRepositoryId: string;
-  sourceControl: IntegrationSourceControlService;
+  integrations: IntegrationsModuleClient;
 }
 
 export async function createProjectFromSource(
   params: CreateProjectFromSourceParams,
 ): Promise<Project> {
-  const source = await params.sourceControl.resolveRepository({
+  let source: {
+    connection: {id: string; provider: string};
+    repository: {externalRepositoryId: string};
+  };
+  source = await params.integrations.resolveSourceRepository({
     workspaceId: params.workspaceId,
     connectionId: params.sourceConnectionId,
     externalRepositoryId: params.sourceExternalRepositoryId,

package/src/index.ts

@@ -1,6 +1,6 @@
 import {dirname, resolve} from 'node:path';
 import {fileURLToPath} from 'node:url';
-import type {IntegrationSourceControlService} from '@shipfox/api-integration-core';
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto';
 import {
   INTEGRATION_SOURCE_COMMIT_PUSHED,
   type IntegrationsEventMap,
@@ -11,6 +11,7 @@ import {db, migrationsPath, projectsOutbox} from '#db/index.js';
 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 {createProjectsMaintenanceActivities} from '#temporal/activities/index.js';
 import {PROJECTS_MAINTENANCE_TASK_QUEUE} from '#temporal/constants.js';
@@ -41,17 +42,18 @@ export {
 export {createProjectRoutes, requireProjectAccess} from '#presentation/index.js';
 
 export interface CreateProjectsModuleOptions {
-  sourceControl: IntegrationSourceControlService;
+  integrations: IntegrationsModuleClient;
 }
 
-export function createProjectsModule({sourceControl}: CreateProjectsModuleOptions): ShipfoxModule {
+export function createProjectsModule({integrations}: CreateProjectsModuleOptions): ShipfoxModule {
   return {
     name: 'projects',
     database: {db, migrationsPath},
-    routes: createProjectRoutes(sourceControl),
+    routes: createProjectRoutes(integrations),
     e2eRoutes: [projectsE2eRoutes],
     metrics: registerProjectsServiceMetrics,
     publishers: [{name: 'projects', table: projectsOutbox, db, eventSchemas: projectsEventSchemas}],
+    interModulePresentations: [createProjectsInterModulePresentation()],
     subscribers: [subscriber(INTEGRATION_SOURCE_COMMIT_PUSHED, onSourceCommitPushed)],
     workers: [
       {

package/src/presentation/inter-module.ts

@@ -0,0 +1,33 @@
+import {projectsInterModuleContract} from '@shipfox/api-projects-dto';
+import {
+  createInterModuleKnownError,
+  defineInterModulePresentation,
+  type InterModulePresentation,
+} from '@shipfox/inter-module';
+import {getProjectById} from '#db/projects.js';
+
+export function createProjectsInterModulePresentation(): InterModulePresentation<
+  typeof projectsInterModuleContract
+> {
+  return defineInterModulePresentation(projectsInterModuleContract, {
+    getProjectById: async ({projectId}) => ({project: (await getProjectById(projectId)) ?? null}),
+    requireProjectForWorkspace: async ({projectId, workspaceId}) => {
+      const project = await getProjectById(projectId);
+      if (project === undefined) {
+        throw createInterModuleKnownError(
+          projectsInterModuleContract.methods.requireProjectForWorkspace,
+          'project-not-found',
+          {projectId},
+        );
+      }
+      if (project.workspaceId !== workspaceId) {
+        throw createInterModuleKnownError(
+          projectsInterModuleContract.methods.requireProjectForWorkspace,
+          'project-workspace-mismatch',
+          {projectId, workspaceId},
+        );
+      }
+      return {project};
+    },
+  });
+}

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

@@ -1,41 +1,21 @@
 import {AUTH_USER, requireUserContext, requireWorkspaceAccess} from '@shipfox/api-auth-context';
 import {
-  IntegrationCapabilityUnavailableError,
-  IntegrationConnectionInactiveError,
-  IntegrationConnectionNotFoundError,
-  IntegrationConnectionWorkspaceMismatchError,
-  IntegrationProviderError,
-  type IntegrationProviderErrorReason,
-  IntegrationProviderUnavailableError,
-  type IntegrationSourceControlService,
-} from '@shipfox/api-integration-core';
+  type IntegrationsModuleClient,
+  integrationsInterModuleContract,
+} from '@shipfox/api-integration-core-dto';
 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 {toProjectDto} from '#presentation/dto/index.js';
 
-function providerStatus(reason: IntegrationProviderErrorReason): number {
+function providerStatus(reason: string): number {
   if (reason === 'rate-limited') return 429;
   if (reason === 'timeout' || reason === 'provider-unavailable') return 503;
   return 422;
 }
 
-function isProviderError(error: unknown): error is IntegrationProviderError {
-  return (
-    error instanceof IntegrationProviderError ||
-    (error instanceof Error &&
-      'reason' in error &&
-      typeof error.reason === 'string' &&
-      (error.reason === 'repository-not-found' ||
-        error.reason === 'access-denied' ||
-        error.reason === 'rate-limited' ||
-        error.reason === 'timeout' ||
-        error.reason === 'provider-unavailable' ||
-        error.reason === 'malformed-provider-response'))
-  );
-}
-
-export function createProjectRoute(sourceControl: IntegrationSourceControlService) {
+export function createProjectRoute(integrations: IntegrationsModuleClient) {
   return defineRoute({
     method: 'POST',
     path: '/',
@@ -48,20 +28,40 @@ export function createProjectRoute(sourceControl: IntegrationSourceControlServic
       },
     },
     errorHandler: (error) => {
-      if (error instanceof IntegrationConnectionNotFoundError) {
-        throw new ClientError(error.message, 'source-connection-not-found', {status: 404});
+      const known = isInterModuleKnownError(
+        integrationsInterModuleContract.methods.resolveSourceRepository,
+        error,
+      )
+        ? error
+        : undefined;
+      if (known?.code === 'connection-not-found') {
+        throw new ClientError('Source connection not found', 'source-connection-not-found', {
+          status: 404,
+        });
       }
-      if (error instanceof IntegrationConnectionWorkspaceMismatchError) {
-        throw new ClientError(error.message, 'forbidden', {status: 403});
+      if (known?.code === 'connection-workspace-mismatch') {
+        throw new ClientError('Source connection does not belong to this workspace', 'forbidden', {
+          status: 403,
+        });
       }
-      if (error instanceof IntegrationConnectionInactiveError) {
-        throw new ClientError(error.message, 'source-connection-inactive', {status: 422});
+      if (known?.code === 'connection-inactive') {
+        throw new ClientError('Source connection is not active', 'source-connection-inactive', {
+          status: 422,
+        });
       }
-      if (error instanceof IntegrationProviderUnavailableError) {
-        throw new ClientError(error.message, 'integration-provider-unavailable', {status: 422});
+      if (known?.code === 'provider-unavailable') {
+        throw new ClientError(
+          'Integration provider is unavailable',
+          'integration-provider-unavailable',
+          {status: 422},
+        );
       }
-      if (error instanceof IntegrationCapabilityUnavailableError) {
-        throw new ClientError(error.message, 'integration-capability-unavailable', {status: 422});
+      if (known?.code === 'capability-unavailable') {
+        throw new ClientError(
+          'Integration capability is unavailable',
+          'integration-capability-unavailable',
+          {status: 422},
+        );
       }
       if (error instanceof ProjectAlreadyExistsError) {
         throw new ClientError(error.message, 'project-already-exists', {
@@ -73,10 +73,10 @@ export function createProjectRoute(sourceControl: IntegrationSourceControlServic
           status: 409,
         });
       }
-      if (isProviderError(error)) {
-        throw new ClientError(error.message, error.reason, {
-          details: {retry_after_seconds: error.retryAfterSeconds},
-          status: providerStatus(error.reason),
+      if (known?.code === 'provider-failure') {
+        throw new ClientError('Integration provider request failed', known.details.reason, {
+          details: {retry_after_seconds: known.details.retryAfterSeconds},
+          status: providerStatus(known.details.reason),
         });
       }
       throw error;
@@ -92,7 +92,7 @@ export function createProjectRoute(sourceControl: IntegrationSourceControlServic
         name,
         sourceConnectionId: source.connection_id,
         sourceExternalRepositoryId: source.external_repository_id,
-        sourceControl,
+        integrations,
       });
 
       reply.status(201);

package/src/presentation/routes/index.ts

@@ -1,14 +1,14 @@
-import type {IntegrationSourceControlService} from '@shipfox/api-integration-core';
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto';
 import type {RouteGroup} from '@shipfox/node-fastify';
 import {createProjectRoute} from './create-project.js';
 import {getProjectRoute} from './get-project.js';
 import {listProjectsRoute} from './list-projects.js';
 
-export function createProjectRoutes(sourceControl: IntegrationSourceControlService): RouteGroup[] {
+export function createProjectRoutes(integrations: IntegrationsModuleClient): RouteGroup[] {
   return [
     {
       prefix: '/projects',
-      routes: [createProjectRoute(sourceControl), listProjectsRoute, getProjectRoute],
+      routes: [createProjectRoute(integrations), listProjectsRoute, getProjectRoute],
     },
   ];
 }

package/src/presentation/routes/projects.test.ts

@@ -4,8 +4,11 @@ import {
   setUserContext,
   type UserContextMembership,
 } from '@shipfox/api-auth-context';
-import type {IntegrationSourceControlService} from '@shipfox/api-integration-core';
-import {IntegrationConnectionNotFoundError} from '@shipfox/api-integration-core';
+import {
+  type IntegrationsModuleClient,
+  integrationsInterModuleContract,
+} from '@shipfox/api-integration-core-dto';
+import {createInterModuleKnownError} from '@shipfox/inter-module';
 import type {AuthMethod} from '@shipfox/node-fastify';
 import {closeApp, createApp} from '@shipfox/node-fastify';
 import type {FastifyInstance, FastifyRequest} from 'fastify';
@@ -33,30 +36,21 @@ describe('project routes', () => {
   let app: FastifyInstance;
   let workspaceId: string;
   let sourceConnectionId: string;
-  let sourceControl: IntegrationSourceControlService;
+  let integrations: Pick<IntegrationsModuleClient, 'resolveSourceRepository'>;
 
   beforeEach(async () => {
     await closeApp();
     workspaceId = crypto.randomUUID();
     sourceConnectionId = crypto.randomUUID();
     authenticatedMemberships = [{workspaceId, role: 'admin'}];
-    sourceControl = {
-      getConnection: vi.fn(),
-      listRepositories: vi.fn(),
-      resolveRepository: vi.fn(async () => {
+    integrations = {
+      resolveSourceRepository: vi.fn(async () => {
         await Promise.resolve();
         return {
           connection: {
             id: sourceConnectionId,
-            workspaceId,
             provider: 'gitea' as const,
-            externalAccountId: 'gitea-owner',
             slug: 'gitea_owner',
-            displayName: 'Gitea',
-            lifecycleStatus: 'active' as const,
-            capabilities: ['source_control' as const],
-            createdAt: new Date(),
-            updatedAt: new Date(),
           },
           repository: {
             externalRepositoryId: 'gitea:gitea-owner/platform',
@@ -70,13 +64,10 @@ describe('project routes', () => {
           },
         };
       }),
-      listFiles: vi.fn(),
-      fetchFile: vi.fn(),
-      createCheckoutSpec: vi.fn(),
     };
     app = await createApp({
       auth: [fakeUserAuth],
-      routes: createProjectRoutes(sourceControl),
+      routes: createProjectRoutes(integrations as IntegrationsModuleClient),
       swagger: false,
     });
     await app.ready();
@@ -129,7 +120,7 @@ describe('project routes', () => {
     });
 
     expect(res.statusCode).toBe(400);
-    expect(sourceControl.resolveRepository).not.toHaveBeenCalled();
+    expect(integrations.resolveSourceRepository).not.toHaveBeenCalled();
   });
 
   test('lists projects for a workspace with source references', async () => {
@@ -164,17 +155,11 @@ describe('project routes', () => {
   test('filters projects by `search` (case-insensitive substring on name)', async () => {
     const names = ['Platform', 'Runner', 'Notifier'];
     for (const [index, name] of names.entries()) {
-      vi.mocked(sourceControl.resolveRepository).mockResolvedValueOnce({
+      vi.mocked(integrations.resolveSourceRepository).mockResolvedValueOnce({
         connection: {
           id: sourceConnectionId,
-          workspaceId,
           provider: 'gitea',
-          externalAccountId: 'gitea-owner',
           slug: 'gitea_owner',
-          displayName: 'Gitea',
-          lifecycleStatus: 'active',
-          createdAt: new Date(),
-          updatedAt: new Date(),
         },
         repository: {
           externalRepositoryId: `gitea:gitea-owner/${name.toLowerCase()}-${index}`,
@@ -242,8 +227,12 @@ describe('project routes', () => {
   });
 
   test('maps missing source connections to a stable error', async () => {
-    vi.mocked(sourceControl.resolveRepository).mockRejectedValueOnce(
-      new IntegrationConnectionNotFoundError(sourceConnectionId),
+    vi.mocked(integrations.resolveSourceRepository).mockRejectedValueOnce(
+      createInterModuleKnownError(
+        integrationsInterModuleContract.methods.resolveSourceRepository,
+        'connection-not-found',
+        {connectionId: sourceConnectionId},
+      ),
     );
 
     const res = await app.inject({

package/src/presentation/subscribers/on-source-commit-pushed.test.ts

@@ -1,6 +1,7 @@
 import {
   INTEGRATION_SOURCE_COMMIT_PUSHED,
   type IntegrationSourceCommitPushedEvent,
+  type IntegrationsModuleClient,
   type SourcePushPayload,
 } from '@shipfox/api-integration-core-dto';
 import {PROJECT_SOURCE_COMMIT_OBSERVED} from '@shipfox/api-projects-dto';
@@ -140,7 +141,7 @@ describe('onSourceCommitPushed', () => {
   // The source/event filter is the subscription itself, so this module should
   // only receive the typed source-control event.
   it('registers the projects module on INTEGRATION_SOURCE_COMMIT_PUSHED', () => {
-    const module = createProjectsModule({sourceControl: {} as never});
+    const module = createProjectsModule({integrations: {} as IntegrationsModuleClient});
 
     const events = module.subscribers?.map((subscriber) => subscriber.event);