@shipfox/api-definitions 5.0.0 → 7.1.0

package/src/presentation/routes/create-definition.test.ts

@@ -1,29 +1,19 @@
 import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
 import type {FastifyInstance} from 'fastify';
 import Fastify from 'fastify';
 import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
-import {buildCreateDefinitionRoute, createDefinitionRoute} from './create-definition.js';
-
-const projectAccessState = vi.hoisted(() => ({workspaceId: '', sourceConnectionId: ''}));
-
-vi.mock('@shipfox/api-projects', () => ({
-  ProjectNotFoundError: class ProjectNotFoundError extends Error {},
-  requireProjectAccess: vi.fn(({projectId}) =>
-    Promise.resolve({
-      project: {
-        id: projectId,
-        workspaceId: projectAccessState.workspaceId,
-        sourceConnectionId: projectAccessState.sourceConnectionId,
-      },
-      workspaceId: projectAccessState.workspaceId,
-    }),
-  ),
-}));
+import {buildCreateDefinitionRoute} from './create-definition.js';
+
+const getProjectById = vi.fn();
+const projects = {getProjectById} as Pick<ProjectsModuleClient, 'getProjectById'>;
 
 describe('POST /api/definitions', () => {
   let app: FastifyInstance;
   let workspaceId: string;
   let projectId: string;
+  let sourceConnectionId: string;
 
   beforeAll(async () => {
     app = Fastify();
@@ -40,15 +30,20 @@ describe('POST /api/definitions', () => {
       );
       done();
     });
-    app.post('/api/definitions', createDefinitionRoute);
+    app.post(
+      '/api/definitions',
+      buildCreateDefinitionRoute({projects: projects as ProjectsModuleClient}),
+    );
     await app.ready();
   });
 
   beforeEach(() => {
     workspaceId = crypto.randomUUID();
     projectId = crypto.randomUUID();
-    projectAccessState.workspaceId = workspaceId;
-    projectAccessState.sourceConnectionId = crypto.randomUUID();
+    sourceConnectionId = crypto.randomUUID();
+    getProjectById.mockResolvedValue({
+      project: {id: projectId, workspaceId, sourceConnectionId},
+    } as never);
   });
 
   const validYaml = `
@@ -82,7 +77,7 @@ jobs:
   });
 
   test('skips connection snapshot loading when YAML has no integrations', async () => {
-    const loadWorkspaceConnectionSnapshot = vi.fn(() => Promise.resolve(new Map()));
+    const getAgentToolsContext = vi.fn();
     const appWithOptions = Fastify();
     appWithOptions.setValidatorCompiler(validatorCompiler);
     appWithOptions.setSerializerCompiler(serializerCompiler);
@@ -100,8 +95,11 @@ jobs:
     appWithOptions.post(
       '/api/definitions',
       buildCreateDefinitionRoute({
-        agentToolSelectionCatalogs: new Map(),
-        loadWorkspaceConnectionSnapshot,
+        projects: projects as ProjectsModuleClient,
+        integrations: {getAgentToolsContext} as Pick<
+          IntegrationsModuleClient,
+          'getAgentToolsContext'
+        > as IntegrationsModuleClient,
       }),
     );
     await appWithOptions.ready();
@@ -117,35 +115,39 @@ jobs:
     });
 
     expect(res.statusCode).toBe(200);
-    expect(loadWorkspaceConnectionSnapshot).not.toHaveBeenCalled();
+    expect(getAgentToolsContext).not.toHaveBeenCalled();
   });
 
   test('uses the project source connection as the default integration connection', async () => {
-    const loadWorkspaceConnectionSnapshot = vi.fn(() =>
-      Promise.resolve(
-        new Map([
-          [
-            'github-main',
-            {
-              id: projectAccessState.sourceConnectionId,
-              provider: 'github',
-              capabilities: ['agent_tools'] as const,
-            },
-          ],
-        ]),
-      ),
-    );
-    const getIntegrationConnectionById = vi.fn(() =>
+    const getAgentToolsContext = vi.fn(() =>
       Promise.resolve({
-        id: projectAccessState.sourceConnectionId,
-        workspaceId,
-        provider: 'github',
-        externalAccountId: 'installation-1',
-        slug: 'github-main',
-        displayName: 'GitHub',
-        lifecycleStatus: 'active' as const,
-        createdAt: new Date(),
-        updatedAt: new Date(),
+        selectionCatalogs: [
+          {
+            provider: 'github',
+            selectors: [
+              {
+                token: 'issue_read',
+                kind: 'family' as const,
+                sensitivity: 'read' as const,
+                sensitive: false,
+              },
+            ],
+          },
+        ],
+        catalogs: [],
+        workspaceConnections: [
+          {
+            id: sourceConnectionId,
+            slug: 'github-main',
+            provider: 'github',
+            capabilities: ['agent_tools' as const],
+          },
+        ],
+        defaultConnection: {
+          id: sourceConnectionId,
+          slug: 'github-main',
+          provider: 'github',
+        },
       }),
     );
     const appWithOptions = Fastify();
@@ -165,18 +167,11 @@ jobs:
     appWithOptions.post(
       '/api/definitions',
       buildCreateDefinitionRoute({
-        agentToolSelectionCatalogs: new Map([
-          [
-            'github',
-            {
-              selectors: [
-                {token: 'issue_read', kind: 'family', sensitivity: 'read', sensitive: false},
-              ],
-            },
-          ],
-        ]),
-        loadWorkspaceConnectionSnapshot,
-        getIntegrationConnectionById,
+        projects: projects as ProjectsModuleClient,
+        integrations: {getAgentToolsContext} as Pick<
+          IntegrationsModuleClient,
+          'getAgentToolsContext'
+        > as IntegrationsModuleClient,
       }),
     );
     await appWithOptions.ready();
@@ -201,9 +196,10 @@ jobs:
     });
 
     expect(res.statusCode).toBe(200);
-    expect(getIntegrationConnectionById).toHaveBeenCalledWith(
-      projectAccessState.sourceConnectionId,
-    );
+    expect(getAgentToolsContext).toHaveBeenCalledWith({
+      workspaceId,
+      defaultConnectionId: sourceConnectionId,
+    });
   });
 
   test('invalid YAML syntax returns 400', async () => {

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

@@ -3,27 +3,24 @@ import {
   definitionResponseSchema,
   definitionValidationErrorSchema,
 } from '@shipfox/api-definitions-dto';
-import type {
-  AgentToolSelectionCatalogs,
-  GetIntegrationConnectionByIdFn,
-  LoadWorkspaceConnectionSnapshot,
-} from '@shipfox/api-integration-core';
-import {ProjectNotFoundError, requireProjectAccess} from '@shipfox/api-projects';
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
 import {ClientError, defineRoute} from '@shipfox/node-fastify';
 import {z} from 'zod';
 import {DefinitionParseError} from '#core/errors.js';
 import {hasAgentStepIntegrations} from '#core/has-agent-step-integrations.js';
+import {loadIntegrationValidationContext} from '#core/integrations.js';
 import {parseDefinition} from '#core/parse-definition.js';
 import {upsertDefinition} from '#db/definitions.js';
 import {toDefinitionDto} from '#presentation/dto/index.js';
+import {requireProjectAccess} from './project-access.js';
 
 export interface CreateDefinitionRouteOptions {
-  agentToolSelectionCatalogs?: AgentToolSelectionCatalogs | undefined;
-  loadWorkspaceConnectionSnapshot?: LoadWorkspaceConnectionSnapshot | undefined;
-  getIntegrationConnectionById?: GetIntegrationConnectionByIdFn | undefined;
+  projects: ProjectsModuleClient;
+  integrations?: IntegrationsModuleClient;
 }
 
-export function buildCreateDefinitionRoute(options: CreateDefinitionRouteOptions = {}) {
+export function buildCreateDefinitionRoute(options: CreateDefinitionRouteOptions) {
   return defineRoute({
     method: 'POST',
     path: '/',
@@ -47,36 +44,22 @@ export function buildCreateDefinitionRoute(options: CreateDefinitionRouteOptions
           status: 400,
         });
       }
-      if (error instanceof ProjectNotFoundError) {
-        throw new ClientError(error.message, 'project-not-found', {status: 404});
-      }
       throw error;
     },
     handler: async (request) => {
       const {project_id: projectId, config_path, source, yaml: yamlString, sha, ref} = request.body;
-      const {project} = await requireProjectAccess({request, projectId});
+      const project = await requireProjectAccess(request, projectId, options.projects);
 
       const structurallyParsed = parseDefinition(yamlString);
-      const {
-        agentToolSelectionCatalogs,
-        loadWorkspaceConnectionSnapshot,
-        getIntegrationConnectionById,
-      } = options;
+      const {integrations} = options;
       const parsed =
-        agentToolSelectionCatalogs !== undefined &&
-        loadWorkspaceConnectionSnapshot !== undefined &&
-        hasAgentStepIntegrations(structurallyParsed.document)
+        integrations !== undefined && hasAgentStepIntegrations(structurallyParsed.document)
           ? parseDefinition(yamlString, {
-              integrationValidationContext: {
-                agentToolSelectionCatalogs,
-                workspaceConnectionSnapshot: await loadWorkspaceConnectionSnapshot(
-                  project.workspaceId,
-                ),
-                defaultConnectionSlug:
-                  getIntegrationConnectionById === undefined
-                    ? undefined
-                    : (await getIntegrationConnectionById(project.sourceConnectionId))?.slug,
-              },
+              integrationValidationContext: await loadIntegrationValidationContext(
+                integrations,
+                project.workspaceId,
+                project.sourceConnectionId,
+              ),
             })
           : structurallyParsed;
 
@@ -97,5 +80,3 @@ export function buildCreateDefinitionRoute(options: CreateDefinitionRouteOptions
     },
   });
 }
-
-export const createDefinitionRoute = buildCreateDefinitionRoute();

package/src/presentation/routes/get-definition.test.ts

@@ -1,21 +1,27 @@
 import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
 import type {FastifyInstance} from 'fastify';
 import Fastify from 'fastify';
 import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
 import {definitionFactory} from '#test/index.js';
-import {getDefinitionRoute} from './get-definition.js';
+import {buildGetDefinitionRoute} from './get-definition.js';
 
 const projectAccessState = vi.hoisted(() => ({workspaceId: ''}));
 
-vi.mock('@shipfox/api-projects', () => ({
-  ProjectNotFoundError: class ProjectNotFoundError extends Error {},
-  requireProjectAccess: vi.fn(({projectId}) =>
+const projects = {
+  getProjectById: vi.fn(({projectId}) =>
     Promise.resolve({
-      project: {id: projectId, workspaceId: projectAccessState.workspaceId},
-      workspaceId: projectAccessState.workspaceId,
+      project: {
+        id: projectId,
+        workspaceId: projectAccessState.workspaceId,
+        sourceConnectionId: crypto.randomUUID(),
+        sourceExternalRepositoryId: 'repo',
+        name: 'Project',
+      },
     }),
   ),
-}));
+  requireProjectForWorkspace: vi.fn(),
+} as unknown as ProjectsModuleClient;
 
 describe('GET /api/definitions/:id', () => {
   let app: FastifyInstance;
@@ -36,7 +42,7 @@ describe('GET /api/definitions/:id', () => {
       );
       done();
     });
-    app.get('/api/definitions/:id', getDefinitionRoute);
+    app.get('/api/definitions/:id', buildGetDefinitionRoute(projects));
     await app.ready();
   });
 

package/src/presentation/routes/get-definition.ts

@@ -1,37 +1,34 @@
 import {definitionResponseSchema} from '@shipfox/api-definitions-dto';
-import {ProjectNotFoundError, requireProjectAccess} from '@shipfox/api-projects';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
 import {ClientError, defineRoute} from '@shipfox/node-fastify';
 import {z} from 'zod';
 import {getDefinitionById} from '#db/definitions.js';
 import {toDefinitionDto} from '#presentation/dto/index.js';
+import {requireProjectAccess} from './project-access.js';
 
-export const getDefinitionRoute = defineRoute({
-  method: 'GET',
-  path: '/:id',
-  description: 'Get a definition by ID',
-  schema: {
-    params: z.object({
-      id: z.string().uuid(),
-    }),
-    response: {
-      200: definitionResponseSchema,
+export function buildGetDefinitionRoute(projects: ProjectsModuleClient) {
+  return defineRoute({
+    method: 'GET',
+    path: '/:id',
+    description: 'Get a definition by ID',
+    schema: {
+      params: z.object({
+        id: z.string().uuid(),
+      }),
+      response: {
+        200: definitionResponseSchema,
+      },
     },
-  },
-  errorHandler: (error) => {
-    if (error instanceof ProjectNotFoundError) {
-      throw new ClientError('Definition not found', 'not-found', {status: 404});
-    }
-    throw error;
-  },
-  handler: async (request) => {
-    const {id} = request.params;
-    const definition = await getDefinitionById(id);
+    handler: async (request) => {
+      const {id} = request.params;
+      const definition = await getDefinitionById(id);
 
-    if (!definition) {
-      throw new ClientError('Definition not found', 'not-found', {status: 404});
-    }
-    await requireProjectAccess({request, projectId: definition.projectId});
+      if (!definition) {
+        throw new ClientError('Definition not found', 'not-found', {status: 404});
+      }
+      await requireProjectAccess(request, definition.projectId, projects);
 
-    return toDefinitionDto(definition);
-  },
-});
+      return toDefinitionDto(definition);
+    },
+  });
+}

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

@@ -1,7 +1,14 @@
 import {AUTH_USER, buildUserContext, setUserContext} from '@shipfox/api-auth-context';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
 import {type AuthMethod, ClientError, closeApp, createApp} from '@shipfox/node-fastify';
 import type {FastifyRequest} from 'fastify';
-import {definitionRoutes} from './index.js';
+import {createDefinitionRoutes} from './index.js';
+
+const projects = {
+  getProjectById: vi.fn(),
+  requireProjectForWorkspace: vi.fn(),
+} as unknown as ProjectsModuleClient;
+const definitionRoutes = createDefinitionRoutes({projects});
 
 const fakeUserAuth: AuthMethod = {
   name: AUTH_USER,

package/src/presentation/routes/index.ts

@@ -4,25 +4,23 @@ import {
   buildCreateDefinitionRoute,
   type CreateDefinitionRouteOptions,
 } from './create-definition.js';
-import {getDefinitionRoute} from './get-definition.js';
-import {listDefinitionsRoute} from './list-definitions.js';
+import {buildGetDefinitionRoute} from './get-definition.js';
+import {buildListDefinitionsRoute} from './list-definitions.js';
 import {validateDefinitionRoute} from './validate-definition.js';
 
 export interface DefinitionRouteOptions extends CreateDefinitionRouteOptions {}
 
-export function createDefinitionRoutes(options: DefinitionRouteOptions = {}): RouteGroup[] {
+export function createDefinitionRoutes(options: DefinitionRouteOptions): RouteGroup[] {
   return [
     {
       prefix: '/definitions',
       auth: AUTH_USER,
       routes: [
         buildCreateDefinitionRoute(options),
-        listDefinitionsRoute,
-        getDefinitionRoute,
+        buildListDefinitionsRoute(options.projects),
+        buildGetDefinitionRoute(options.projects),
         validateDefinitionRoute,
       ],
     },
   ];
 }
-
-export const definitionRoutes = createDefinitionRoutes();

package/src/presentation/routes/list-definitions.test.ts

@@ -1,11 +1,12 @@
 import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
 import {encodeStringIdCursor} from '@shipfox/node-drizzle';
 import type {FastifyInstance} from 'fastify';
 import Fastify from 'fastify';
 import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
 import {markDefinitionSyncState} from '#db/index.js';
 import {definitionFactory} from '#test/index.js';
-import {listDefinitionsRoute} from './list-definitions.js';
+import {buildListDefinitionsRoute} from './list-definitions.js';
 
 const projectAccessState = vi.hoisted(() => ({
   workspaceId: '',
@@ -13,20 +14,20 @@ const projectAccessState = vi.hoisted(() => ({
   sourceExternalRepositoryId: '',
 }));
 
-vi.mock('@shipfox/api-projects', () => ({
-  ProjectNotFoundError: class ProjectNotFoundError extends Error {},
-  requireProjectAccess: vi.fn(({projectId}) =>
+const projects = {
+  getProjectById: vi.fn(({projectId}) =>
     Promise.resolve({
       project: {
         id: projectId,
         workspaceId: projectAccessState.workspaceId,
         sourceConnectionId: projectAccessState.sourceConnectionId,
         sourceExternalRepositoryId: projectAccessState.sourceExternalRepositoryId,
+        name: 'Project',
       },
-      workspaceId: projectAccessState.workspaceId,
     }),
   ),
-}));
+  requireProjectForWorkspace: vi.fn(),
+} as unknown as ProjectsModuleClient;
 
 describe('GET /api/definitions', () => {
   let app: FastifyInstance;
@@ -50,7 +51,7 @@ describe('GET /api/definitions', () => {
       );
       done();
     });
-    app.get('/api/definitions', listDefinitionsRoute);
+    app.get('/api/definitions', buildListDefinitionsRoute(projects));
     await app.ready();
   });
 

package/src/presentation/routes/list-definitions.ts

@@ -2,48 +2,45 @@ import {
   definitionListQuerySchema,
   definitionListResponseSchema,
 } from '@shipfox/api-definitions-dto';
-import {ProjectNotFoundError, requireProjectAccess} from '@shipfox/api-projects';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
 import {decodeStringIdCursor, encodeStringIdCursor} from '@shipfox/node-drizzle';
 import {ClientError, defineRoute} from '@shipfox/node-fastify';
 import {listDefinitions} from '#db/definitions.js';
 import {getLatestDefinitionSyncState} from '#db/sync-states.js';
 import {toDefinitionDto, toDefinitionSyncSummaryDto} from '#presentation/dto/index.js';
+import {requireProjectAccess} from './project-access.js';
 
-export const listDefinitionsRoute = defineRoute({
-  method: 'GET',
-  path: '/',
-  description: 'List all definitions for a project',
-  schema: {
-    querystring: definitionListQuerySchema,
-    response: {
-      200: definitionListResponseSchema,
+export function buildListDefinitionsRoute(projects: ProjectsModuleClient) {
+  return defineRoute({
+    method: 'GET',
+    path: '/',
+    description: 'List all definitions for a project',
+    schema: {
+      querystring: definitionListQuerySchema,
+      response: {
+        200: definitionListResponseSchema,
+      },
     },
-  },
-  errorHandler: (error) => {
-    if (error instanceof ProjectNotFoundError) {
-      throw new ClientError(error.message, 'project-not-found', {status: 404});
-    }
-    throw error;
-  },
-  handler: async (request) => {
-    const {project_id: projectId, limit, cursor} = request.query;
-    const decodedCursor = decodeStringIdCursor(cursor);
-    if (cursor && !decodedCursor) {
-      throw new ClientError('Invalid cursor', 'invalid-cursor', {status: 400});
-    }
+    handler: async (request) => {
+      const {project_id: projectId, limit, cursor} = request.query;
+      const decodedCursor = decodeStringIdCursor(cursor);
+      if (cursor && !decodedCursor) {
+        throw new ClientError('Invalid cursor', 'invalid-cursor', {status: 400});
+      }
 
-    const {project} = await requireProjectAccess({request, projectId});
-    const result = await listDefinitions({projectId, limit, cursor: decodedCursor});
-    const syncState = await getLatestDefinitionSyncState({
-      projectId,
-      sourceConnectionId: project.sourceConnectionId,
-      sourceExternalRepositoryId: project.sourceExternalRepositoryId,
-    });
+      const project = await requireProjectAccess(request, projectId, projects);
+      const result = await listDefinitions({projectId, limit, cursor: decodedCursor});
+      const syncState = await getLatestDefinitionSyncState({
+        projectId,
+        sourceConnectionId: project.sourceConnectionId,
+        sourceExternalRepositoryId: project.sourceExternalRepositoryId,
+      });
 
-    return {
-      definitions: result.definitions.map(toDefinitionDto),
-      sync: toDefinitionSyncSummaryDto(syncState),
-      next_cursor: result.nextCursor ? encodeStringIdCursor(result.nextCursor) : null,
-    };
-  },
-});
+      return {
+        definitions: result.definitions.map(toDefinitionDto),
+        sync: toDefinitionSyncSummaryDto(syncState),
+        next_cursor: result.nextCursor ? encodeStringIdCursor(result.nextCursor) : null,
+      };
+    },
+  });
+}

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

@@ -0,0 +1,16 @@
+import {requireWorkspaceAccess} from '@shipfox/api-auth-context';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
+import {ClientError} from '@shipfox/node-fastify';
+import type {FastifyRequest} from 'fastify';
+
+export async function requireProjectAccess(
+  request: FastifyRequest,
+  projectId: string,
+  projects: ProjectsModuleClient,
+) {
+  const {project} = await projects.getProjectById({projectId});
+  if (project === null)
+    throw new ClientError('Project not found', 'project-not-found', {status: 404});
+  requireWorkspaceAccess({request, workspaceId: project.workspaceId});
+  return project;
+}

package/src/temporal/activities/sync-activities.test.ts

@@ -1,7 +1,7 @@
-import {
-  IntegrationProviderError,
-  type IntegrationSourceControlService,
-} from '@shipfox/api-integration-core';
+import type {IntegrationSourceControlService} from '@shipfox/api-integration-core';
+import {integrationsInterModuleContract} from '@shipfox/api-integration-core-dto';
+import {createInterModuleKnownError} from '@shipfox/inter-module';
+import {isErrorReported} from '@shipfox/node-error-monitoring';
 import {ApplicationFailure} from '@temporalio/common';
 import {sql} from 'drizzle-orm';
 import {db, definitionSyncStates} from '#db/index.js';
@@ -142,6 +142,8 @@ describe('definition sync activities', () => {
         type: 'unknown',
         message: 'temporary outage',
       });
+      const error = await result.catch((error: unknown) => error);
+      expect(isErrorReported(error)).toBe(false);
     });
 
     it('preserves retryable provider error codes for workflow-level failure persistence', async () => {
@@ -149,7 +151,11 @@ describe('definition sync activities', () => {
         sourceControl({
           resolveRepository: vi.fn(() => {
             return Promise.reject(
-              new IntegrationProviderError('timeout', 'GitHub request timed out'),
+              createInterModuleKnownError(
+                integrationsInterModuleContract.methods.resolveSourceRepository,
+                'provider-failure',
+                {reason: 'timeout'},
+              ),
             );
           }),
         }),
@@ -165,8 +171,10 @@ describe('definition sync activities', () => {
       await expect(result).rejects.toMatchObject({
         nonRetryable: false,
         type: 'provider-timeout',
-        message: 'GitHub request timed out',
+        message: 'integrations.resolveSourceRepository: provider-failure',
       });
+      const error = await result.catch((error: unknown) => error);
+      expect(isErrorReported(error)).toBe(true);
     });
   });