@shipfox/api-server 4.0.0 → 6.0.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "@shipfox/api-server",
   "license": "MIT",
   "private": false,
-  "version": "4.0.0",
+  "version": "6.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -12,66 +12,65 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "imports": {
-    "#*": {
-      "workspace-source": "./src/*",
-      "development": "./src/*",
-      "default": "./dist/*"
-    }
+    "#*": "./dist/*"
   },
   "exports": {
     ".": {
-      "development": {
-        "types": "./src/index.ts",
-        "default": "./src/index.ts"
-      },
-      "default": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./instrumentation": {
-      "development": {
-        "types": "./src/instrumentation.ts",
-        "default": "./src/instrumentation.ts"
-      },
-      "default": {
-        "types": "./dist/instrumentation.d.ts",
-        "default": "./dist/instrumentation.js"
-      }
+      "types": "./dist/instrumentation.d.ts",
+      "default": "./dist/instrumentation.js"
     }
   },
   "dependencies": {
-    "@shipfox/annotations": "4.0.0",
-    "@shipfox/api-agent": "4.0.0",
-    "@shipfox/api-auth": "4.0.0",
-    "@shipfox/api-definitions": "4.0.0",
-    "@shipfox/api-dispatcher": "4.0.0",
-    "@shipfox/api-integration-core": "4.0.0",
-    "@shipfox/api-logs": "4.0.0",
-    "@shipfox/api-projects": "4.0.0",
-    "@shipfox/api-runners": "4.0.0",
-    "@shipfox/api-secrets": "4.0.0",
-    "@shipfox/api-triggers": "4.0.0",
-    "@shipfox/api-workflows": "4.0.0",
-    "@shipfox/api-workspaces": "4.0.0",
-    "@shipfox/config": "1.2.1",
-    "@shipfox/node-error-monitoring": "0.1.2",
-    "@shipfox/node-fastify": "0.2.2",
-    "@shipfox/node-module": "0.3.1",
-    "@shipfox/node-opentelemetry": "0.5.1",
-    "@shipfox/node-postgres": "0.4.1"
+    "@shipfox/annotations": "6.0.0",
+    "@shipfox/annotations-dto": "6.0.0",
+    "@shipfox/api-agent": "6.0.0",
+    "@shipfox/api-agent-dto": "6.0.0",
+    "@shipfox/api-auth": "6.0.0",
+    "@shipfox/api-auth-dto": "6.0.0",
+    "@shipfox/api-definitions": "6.0.0",
+    "@shipfox/api-definitions-dto": "6.0.0",
+    "@shipfox/api-dispatcher": "6.0.0",
+    "@shipfox/api-email-challenges": "0.2.0",
+    "@shipfox/api-integration-core": "6.0.0",
+    "@shipfox/api-integration-core-dto": "6.0.0",
+    "@shipfox/api-logs": "6.0.0",
+    "@shipfox/api-projects": "6.0.0",
+    "@shipfox/api-projects-dto": "6.0.0",
+    "@shipfox/api-runners": "6.0.0",
+    "@shipfox/api-runners-dto": "6.0.0",
+    "@shipfox/api-secrets": "6.0.0",
+    "@shipfox/api-secrets-dto": "6.0.0",
+    "@shipfox/api-triggers": "6.0.0",
+    "@shipfox/api-workflows": "6.0.0",
+    "@shipfox/api-workflows-dto": "6.0.0",
+    "@shipfox/api-workspaces-dto": "6.0.0",
+    "@shipfox/api-workspaces": "6.0.0",
+    "@shipfox/config": "1.2.2",
+    "@shipfox/node-error-monitoring": "0.1.3",
+    "@shipfox/node-fastify": "0.2.4",
+    "@shipfox/node-jwt": "0.3.0",
+    "@shipfox/node-module": "0.4.0",
+    "@shipfox/node-opentelemetry": "0.5.2",
+    "@shipfox/node-postgres": "0.4.2"
   },
   "devDependencies": {
-    "@shipfox/biome": "1.8.1",
-    "@shipfox/swc": "1.2.5",
+    "@shipfox/biome": "1.8.2",
+    "@shipfox/depcruise": "1.0.2",
+    "@shipfox/inter-module": "0.2.0",
+    "@shipfox/swc": "1.2.6",
     "@shipfox/ts-config": "1.3.8",
-    "@shipfox/typescript": "1.1.6",
-    "@shipfox/vitest": "1.2.2"
+    "@shipfox/typescript": "1.1.7",
+    "@shipfox/vitest": "1.2.3"
   },
   "scripts": {
     "build": "shipfox-swc",
     "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/index.ts

@@ -1,3 +1,3 @@
-export {defaultModules} from './modules.js';
+export {type DefaultModulesOptions, defaultModules} from './modules.js';
 export type {CreateServerOptions, RunServerOptions, ServerHandle} from './server.js';
 export {createServer, runServer} from './server.js';

package/src/modules.test.ts

@@ -1,28 +1,74 @@
+import {annotationsInterModuleContract} from '@shipfox/annotations-dto/inter-module';
+import {agentInterModuleContract} from '@shipfox/api-agent-dto/inter-module';
+import {authInterModuleContract} from '@shipfox/api-auth-dto/inter-module';
+import {definitionsInterModuleContract} from '@shipfox/api-definitions-dto/inter-module';
+import {integrationsInterModuleContract} from '@shipfox/api-integration-core-dto';
+import {projectsInterModuleContract} from '@shipfox/api-projects-dto';
+import {runnersInterModuleContract} from '@shipfox/api-runners-dto/inter-module';
+import {
+  type SecretsInterModuleClient,
+  secretsInterModuleContract,
+} from '@shipfox/api-secrets-dto/inter-module';
+import {workflowsInterModuleContract} from '@shipfox/api-workflows-dto/inter-module';
+import {workspacesInterModuleContract} from '@shipfox/api-workspaces-dto/inter-module';
+import {defineInterModulePresentation} from '@shipfox/inter-module';
 import {defaultModules} from './modules.js';
 
 const mocks = vi.hoisted(() => ({
   buildAgentToolCatalogs: vi.fn(),
   buildAgentToolSelectionCatalogs: vi.fn(),
+  createAgentModule: vi.fn(),
   createDefinitionsModule: vi.fn(),
   createIntegrationsContext: vi.fn(),
+  createLogsModule: vi.fn(),
   createProjectsModule: vi.fn(),
+  createRunnersModule: vi.fn(),
+  createSecretsModule: vi.fn(),
+  createTriggersModule: vi.fn(),
+  createWorkflowsModule: vi.fn(),
   createWorkspaceConnectionSnapshotLoader: vi.fn(),
   deleteSecrets: vi.fn(),
   getIntegrationConnectionById: vi.fn(),
   getSecret: vi.fn(),
-  loadRunningLeasedStep: vi.fn(),
-  setAgentToolMaterializationServices: vi.fn(),
   setSecrets: vi.fn(),
-  setSourceControl: vi.fn(),
 }));
 
-vi.mock('@shipfox/api-agent', () => ({agentModule: {name: 'agent'}}));
-vi.mock('@shipfox/annotations', () => ({annotationsModule: {name: 'annotations'}}));
-vi.mock('@shipfox/api-auth', () => ({authModule: {name: 'auth'}}));
+vi.mock('@shipfox/annotations', () => ({
+  annotationsModule: {
+    name: 'annotations',
+    interModulePresentations: [
+      {
+        contract: annotationsInterModuleContract,
+        handlers: {replaceOrRemoveAnnotation: vi.fn()},
+      },
+    ],
+  },
+}));
+vi.mock('@shipfox/api-auth', () => ({
+  createAuthModule: () => ({
+    name: 'auth',
+    interModulePresentations: [
+      {
+        contract: authInterModuleContract,
+        handlers: {
+          mintJobLeaseToken: vi.fn(),
+          mintRunnerSessionToken: vi.fn(),
+        },
+      },
+    ],
+  }),
+}));
+vi.mock('@shipfox/api-agent', () => ({createAgentModule: mocks.createAgentModule}));
+vi.mock('@shipfox/api-auth/config', () => ({
+  config: {AUTH_JOB_LEASE_TOKEN_EXPIRES_IN: '90m'},
+}));
 vi.mock('@shipfox/api-definitions', () => ({
   createDefinitionsModule: mocks.createDefinitionsModule,
 }));
 vi.mock('@shipfox/api-dispatcher', () => ({dispatcherModule: {name: 'dispatcher'}}));
+vi.mock('@shipfox/api-email-challenges', () => ({
+  emailChallengesModule: {name: 'email-challenges'},
+}));
 vi.mock('@shipfox/api-integration-core', () => ({
   buildAgentToolCatalogs: mocks.buildAgentToolCatalogs,
   buildAgentToolSelectionCatalogs: mocks.buildAgentToolSelectionCatalogs,
@@ -30,56 +76,162 @@ vi.mock('@shipfox/api-integration-core', () => ({
   createWorkspaceConnectionSnapshotLoader: mocks.createWorkspaceConnectionSnapshotLoader,
   getIntegrationConnectionById: mocks.getIntegrationConnectionById,
 }));
-vi.mock('@shipfox/api-logs', () => ({logsModule: {name: 'logs'}}));
+vi.mock('@shipfox/api-logs', () => ({createLogsModule: mocks.createLogsModule}));
 vi.mock('@shipfox/api-projects', () => ({createProjectsModule: mocks.createProjectsModule}));
-vi.mock('@shipfox/api-runners', () => ({runnersModule: {name: 'runners'}}));
+vi.mock('@shipfox/api-runners', () => ({createRunnersModule: mocks.createRunnersModule}));
 vi.mock('@shipfox/api-secrets', () => ({
+  createSecretsModule: mocks.createSecretsModule,
   deleteSecrets: mocks.deleteSecrets,
   getSecret: mocks.getSecret,
-  secretsModule: {name: 'secrets'},
   setSecrets: mocks.setSecrets,
 }));
-vi.mock('@shipfox/api-triggers', () => ({triggersModule: {name: 'triggers'}}));
+vi.mock('@shipfox/api-triggers', () => ({createTriggersModule: mocks.createTriggersModule}));
 vi.mock('@shipfox/api-workflows', () => ({
-  loadRunningLeasedStep: mocks.loadRunningLeasedStep,
-  setAgentToolMaterializationServices: mocks.setAgentToolMaterializationServices,
-  setSourceControl: mocks.setSourceControl,
-  workflowsModule: {name: 'workflows'},
+  createWorkflowsModule: mocks.createWorkflowsModule,
+}));
+vi.mock('@shipfox/api-workspaces', () => ({
+  workspacesModule: {
+    name: 'workspaces',
+    interModulePresentations: [
+      {
+        contract: workspacesInterModuleContract,
+        handlers: {
+          listMembershipsForTokenClaims: vi.fn(),
+          preflightInvitationAcceptance: vi.fn(),
+          acceptInvitation: vi.fn(),
+          requireActiveMembership: vi.fn(),
+        },
+      },
+    ],
+  },
 }));
-vi.mock('@shipfox/api-workspaces', () => ({workspacesModule: {name: 'workspaces'}}));
 
 describe('defaultModules', () => {
   beforeEach(() => {
     mocks.buildAgentToolCatalogs.mockReset();
     mocks.buildAgentToolSelectionCatalogs.mockReset();
+    mocks.createAgentModule.mockReset();
     mocks.createDefinitionsModule.mockReset();
     mocks.createIntegrationsContext.mockReset();
+    mocks.createLogsModule.mockReset();
     mocks.createProjectsModule.mockReset();
+    mocks.createRunnersModule.mockReset();
+    mocks.createSecretsModule.mockReset();
+    mocks.createTriggersModule.mockReset();
+    mocks.createWorkflowsModule.mockReset();
     mocks.createWorkspaceConnectionSnapshotLoader.mockReset();
     mocks.deleteSecrets.mockReset();
     mocks.getIntegrationConnectionById.mockReset();
     mocks.getSecret.mockReset();
-    mocks.loadRunningLeasedStep.mockReset();
-    mocks.setAgentToolMaterializationServices.mockReset();
     mocks.setSecrets.mockReset();
-    mocks.setSourceControl.mockReset();
 
     mocks.createIntegrationsContext.mockResolvedValue({
-      module: {name: 'integrations'},
+      module: {
+        name: 'integrations',
+        interModulePresentations: [
+          defineInterModulePresentation(integrationsInterModuleContract, {
+            createCheckoutSpec: vi.fn(),
+            fetchSourceFile: vi.fn(),
+            getAgentToolsContext: vi.fn(),
+            listSourceFiles: vi.fn(),
+            resolveSourceRepository: vi.fn(),
+          }),
+        ],
+      },
       registry: {},
       sourceControl: {provider: 'source-control'},
     });
+    mocks.createLogsModule.mockReturnValue({name: 'logs'});
     mocks.buildAgentToolCatalogs.mockResolvedValue(new Map());
     mocks.buildAgentToolSelectionCatalogs.mockResolvedValue(new Map());
     mocks.createWorkspaceConnectionSnapshotLoader.mockReturnValue(vi.fn());
-    mocks.createProjectsModule.mockReturnValue({name: 'projects'});
-    mocks.createDefinitionsModule.mockReturnValue({name: 'definitions'});
+    mocks.deleteSecrets.mockResolvedValue({deleted: 1});
+    mocks.getSecret.mockResolvedValue({value: 'secret'});
+    mocks.setSecrets.mockResolvedValue({});
+    mocks.createProjectsModule.mockReturnValue({
+      name: 'projects',
+      interModulePresentations: [
+        defineInterModulePresentation(projectsInterModuleContract, {
+          getProjectById: () => ({project: null}),
+          requireProjectForWorkspace: () => ({
+            project: {
+              id: crypto.randomUUID(),
+              workspaceId: crypto.randomUUID(),
+              sourceConnectionId: crypto.randomUUID(),
+              sourceExternalRepositoryId: 'repo',
+              name: 'Project',
+            },
+          }),
+        }),
+      ],
+    });
+    mocks.createSecretsModule.mockReturnValue({
+      name: 'secrets',
+      interModulePresentations: [
+        defineInterModulePresentation(secretsInterModuleContract, {
+          deleteSecrets: mocks.deleteSecrets,
+          getSecret: mocks.getSecret,
+          getSecretsByNamespace: vi.fn(),
+          getVariablesByNamespace: vi.fn(),
+          setSecrets: mocks.setSecrets,
+        }),
+      ],
+    });
+    mocks.createAgentModule.mockReturnValue({
+      name: 'agent',
+      interModulePresentations: [
+        {
+          contract: agentInterModuleContract,
+          handlers: {resolveAgentConfig: vi.fn(), resolveRuntimeCredentials: vi.fn()},
+        },
+      ],
+    });
+    mocks.createRunnersModule.mockReturnValue({
+      name: 'runners',
+      interModulePresentations: [
+        {
+          contract: runnersInterModuleContract,
+          handlers: {
+            cancelJobs: vi.fn(),
+            enqueueJobExecution: vi.fn(),
+            getEffectiveRunnerToolCapabilities: vi.fn(),
+            getLeaseState: vi.fn(),
+            releaseJobExecution: vi.fn(),
+          },
+        },
+      ],
+    });
+    mocks.createDefinitionsModule.mockReturnValue({
+      name: 'definitions',
+      interModulePresentations: [
+        {
+          contract: definitionsInterModuleContract,
+          handlers: {getDefinitionForWorkflowRun: vi.fn()},
+        },
+      ],
+    });
+    mocks.createWorkflowsModule.mockReturnValue({
+      name: 'workflows',
+      interModulePresentations: [
+        {
+          contract: workflowsInterModuleContract,
+          handlers: {
+            deliverEventToJobListener: vi.fn(),
+            getLeasedAgentToolContext: vi.fn(),
+            getStepLogContext: vi.fn(),
+            startRunFromTrigger: vi.fn(),
+          },
+        },
+      ],
+    });
+    mocks.createTriggersModule.mockReturnValue({name: 'triggers'});
   });
 
   it('returns the API modules in lifecycle order', async () => {
     const modules = await defaultModules();
 
     expect(modules.map((module) => module.name)).toEqual([
+      'email-challenges',
       'auth',
       'workspaces',
       'secrets',
@@ -96,64 +248,143 @@ describe('defaultModules', () => {
     ]);
   });
 
-  it('uses the leased-step loader and namespaced provider secrets', async () => {
+  it('injects Auth into the Runners module', async () => {
+    await defaultModules();
+
+    expect(mocks.createRunnersModule).toHaveBeenCalledWith({auth: expect.any(Object)});
+  });
+
+  it('injects Workflows into integrations and logs and namespaces provider secrets', async () => {
     await defaultModules();
 
     expect(mocks.createIntegrationsContext).toHaveBeenCalledWith({
+      workspaces: expect.anything(),
       secrets: {
-        deleteSecrets: mocks.deleteSecrets,
+        deleteSecrets: expect.any(Function),
         linear: {
           deleteSecrets: expect.any(Function),
           getSecret: expect.any(Function),
           setSecrets: expect.any(Function),
         },
+        jira: {
+          deleteSecrets: expect.any(Function),
+          getSecret: expect.any(Function),
+          setSecrets: expect.any(Function),
+        },
         slack: {
           deleteSecrets: expect.any(Function),
           getSecret: expect.any(Function),
           setSecrets: expect.any(Function),
         },
       },
-      agentTools: {loadLeasedAgentStep: mocks.loadRunningLeasedStep},
+      agentTools: {workflows: expect.objectContaining({getStepLogContext: expect.any(Function)})},
+      webhookDeliverySource: undefined,
     });
 
     const integrationsOptions = mocks.createIntegrationsContext.mock.calls[0]?.[0] as {
       secrets: {
-        linear: {
-          deleteSecrets: (params: {namespace: string}) => unknown;
-          getSecret: (params: {namespace: string}) => unknown;
-          setSecrets: (params: {namespace: string}) => unknown;
-        };
-        slack: {
-          deleteSecrets: (params: {namespace: string}) => unknown;
-          getSecret: (params: {namespace: string}) => unknown;
-          setSecrets: (params: {namespace: string}) => unknown;
-        };
+        linear: Pick<SecretsInterModuleClient, 'deleteSecrets' | 'getSecret' | 'setSecrets'>;
+        jira: Pick<SecretsInterModuleClient, 'deleteSecrets' | 'getSecret' | 'setSecrets'>;
+        slack: Pick<SecretsInterModuleClient, 'deleteSecrets' | 'getSecret' | 'setSecrets'>;
       };
+      agentTools: {workflows: unknown};
     };
-    integrationsOptions.secrets.linear.getSecret({namespace: 'workspace'});
-    integrationsOptions.secrets.linear.setSecrets({namespace: 'workspace'});
-    integrationsOptions.secrets.linear.deleteSecrets({namespace: 'workspace'});
-    integrationsOptions.secrets.slack.getSecret({namespace: 'workspace'});
-    integrationsOptions.secrets.slack.setSecrets({namespace: 'workspace'});
-    integrationsOptions.secrets.slack.deleteSecrets({namespace: 'workspace'});
-
-    expect(mocks.getSecret).toHaveBeenCalledWith({
+    expect(integrationsOptions.agentTools.workflows).toEqual(
+      expect.objectContaining({getLeasedAgentToolContext: expect.any(Function)}),
+    );
+    expect(mocks.createLogsModule).toHaveBeenCalledWith({
+      workflows: expect.objectContaining({getStepLogContext: expect.any(Function)}),
+      jobLeaseTokenTtlSeconds: 5400,
+    });
+
+    const scope = {workspaceId: crypto.randomUUID(), projectId: null, namespace: 'workspace'};
+    await Promise.all([
+      integrationsOptions.secrets.linear.getSecret({...scope, key: 'token'}),
+      integrationsOptions.secrets.linear.setSecrets({
+        ...scope,
+        values: {token: 'secret'},
+        editedBy: undefined,
+      }),
+      integrationsOptions.secrets.linear.deleteSecrets({...scope, keys: ['token']}),
+      integrationsOptions.secrets.jira.getSecret({...scope, key: 'token'}),
+      integrationsOptions.secrets.jira.setSecrets({
+        ...scope,
+        values: {token: 'secret'},
+        editedBy: undefined,
+      }),
+      integrationsOptions.secrets.jira.deleteSecrets({...scope, keys: ['token']}),
+      integrationsOptions.secrets.slack.getSecret({...scope, key: 'token'}),
+      integrationsOptions.secrets.slack.setSecrets({
+        ...scope,
+        values: {token: 'secret'},
+        editedBy: undefined,
+      }),
+      integrationsOptions.secrets.slack.deleteSecrets({...scope, keys: ['token']}),
+    ]);
+
+    expect(mocks.getSecret.mock.calls.map(([params]) => params)).toContainEqual({
+      key: 'token',
       namespace: 'system/integrations/linear/workspace',
+      projectId: null,
+      workspaceId: scope.workspaceId,
     });
-    expect(mocks.setSecrets).toHaveBeenCalledWith({
+    expect(mocks.setSecrets.mock.calls.map(([params]) => params)).toContainEqual({
+      values: {token: 'secret'},
       namespace: 'system/integrations/linear/workspace',
+      projectId: null,
+      workspaceId: scope.workspaceId,
     });
-    expect(mocks.deleteSecrets).toHaveBeenCalledWith({
+    expect(mocks.deleteSecrets.mock.calls.map(([params]) => params)).toContainEqual({
+      keys: ['token'],
       namespace: 'system/integrations/linear/workspace',
+      projectId: null,
+      workspaceId: scope.workspaceId,
+    });
+    expect(mocks.getSecret.mock.calls.map(([params]) => params)).toContainEqual({
+      key: 'token',
+      namespace: 'system/integrations/jira/workspace',
+      projectId: null,
+      workspaceId: scope.workspaceId,
+    });
+    expect(mocks.setSecrets.mock.calls.map(([params]) => params)).toContainEqual({
+      values: {token: 'secret'},
+      namespace: 'system/integrations/jira/workspace',
+      projectId: null,
+      workspaceId: scope.workspaceId,
     });
-    expect(mocks.getSecret).toHaveBeenCalledWith({
+    expect(mocks.deleteSecrets.mock.calls.map(([params]) => params)).toContainEqual({
+      keys: ['token'],
+      namespace: 'system/integrations/jira/workspace',
+      projectId: null,
+      workspaceId: scope.workspaceId,
+    });
+    expect(mocks.getSecret.mock.calls.map(([params]) => params)).toContainEqual({
+      key: 'token',
       namespace: 'system/integrations/slack/workspace',
+      projectId: null,
+      workspaceId: scope.workspaceId,
     });
-    expect(mocks.setSecrets).toHaveBeenCalledWith({
+    expect(mocks.setSecrets.mock.calls.map(([params]) => params)).toContainEqual({
+      values: {token: 'secret'},
       namespace: 'system/integrations/slack/workspace',
+      projectId: null,
+      workspaceId: scope.workspaceId,
     });
-    expect(mocks.deleteSecrets).toHaveBeenCalledWith({
+    expect(mocks.deleteSecrets.mock.calls.map(([params]) => params)).toContainEqual({
+      keys: ['token'],
       namespace: 'system/integrations/slack/workspace',
+      projectId: null,
+      workspaceId: scope.workspaceId,
     });
   });
+
+  it('passes an optional webhook delivery source to integration composition', async () => {
+    const webhookDeliverySource = {createService: vi.fn()};
+
+    await defaultModules({webhookDeliverySource});
+
+    expect(mocks.createIntegrationsContext).toHaveBeenCalledWith(
+      expect.objectContaining({webhookDeliverySource}),
+    );
+  });
 });