@shipfox/api-integration-core 2.0.0

package/test/agent-tools-gateway-helpers.ts

@@ -0,0 +1,210 @@
+import type {CallToolResult} from '@modelcontextprotocol/sdk/types.js';
+import type {
+  MaterializedAgentIntegrationConfigDto,
+  MaterializedAgentIntegrationToolConfigDto,
+} from '@shipfox/api-agent-dto';
+import type {LeasedJobContext} from '@shipfox/api-auth-context';
+import type {IntegrationConnection} from '#core/entities/connection.js';
+import type {AgentToolCatalogEntry, AgentToolsProvider} from '#core/providers/agent-tools.js';
+import {createIntegrationProviderRegistry} from '#core/providers/registry.js';
+
+export function leaseContext(overrides: Partial<LeasedJobContext> = {}): LeasedJobContext {
+  const now = Math.floor(Date.now() / 1000);
+  return {
+    workflowRunId: crypto.randomUUID(),
+    workflowRunAttemptId: crypto.randomUUID(),
+    jobId: crypto.randomUUID(),
+    jobExecutionId: crypto.randomUUID(),
+    projectId: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    runnerSessionId: crypto.randomUUID(),
+    currentStepId: crypto.randomUUID(),
+    currentStepAttempt: 1,
+    aud: 'runner-job-lease',
+    iat: now,
+    exp: now + 3600,
+    ...overrides,
+  };
+}
+
+export function connection(overrides: Partial<IntegrationConnection> = {}): IntegrationConnection {
+  const now = new Date();
+  return {
+    id: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    provider: 'github',
+    externalAccountId: 'installation-1',
+    slug: 'github-main',
+    displayName: 'GitHub',
+    lifecycleStatus: 'active',
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  };
+}
+
+export function materializedTool(
+  overrides: Partial<MaterializedAgentIntegrationToolConfigDto> = {},
+): MaterializedAgentIntegrationToolConfigDto {
+  return {
+    id: 'issue_read',
+    sensitivity: 'read',
+    sensitive: false,
+    requiredScope: [],
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        method: {
+          type: 'string',
+          enum: ['get', 'get_comments', 'get_labels'],
+        },
+        owner: {type: 'string'},
+        repo: {type: 'string'},
+        issue_number: {type: 'integer'},
+      },
+      required: ['method', 'owner', 'repo', 'issue_number'],
+      oneOf: [
+        {properties: {method: {const: 'get'}}, required: ['issue_number']},
+        {properties: {method: {const: 'get_comments'}}, required: ['issue_number']},
+        {properties: {method: {const: 'get_labels'}}, required: ['issue_number']},
+      ],
+    },
+    methods: [
+      {
+        id: 'get',
+        token: 'issue_read.get',
+        description: 'Get one issue.',
+        sensitivity: 'read',
+        sensitive: false,
+        requiredScope: [],
+      },
+      {
+        id: 'get_comments',
+        token: 'issue_read.get_comments',
+        description: 'Get issue comments.',
+        sensitivity: 'read',
+        sensitive: false,
+        requiredScope: [],
+      },
+    ],
+    ...overrides,
+  };
+}
+
+export function materializedIntegration(
+  overrides: Partial<MaterializedAgentIntegrationConfigDto> = {},
+): MaterializedAgentIntegrationConfigDto {
+  return {
+    connectionId: crypto.randomUUID(),
+    connectionSlug: 'github-main',
+    provider: 'github',
+    requiredScope: [],
+    tools: [materializedTool()],
+    ...overrides,
+  };
+}
+
+export function agentStepConfig(
+  integrations: MaterializedAgentIntegrationConfigDto[] = [materializedIntegration()],
+): Record<string, unknown> {
+  return {
+    provider: 'openai',
+    model: 'gpt-5',
+    thinking: 'off',
+    prompt: 'Use tools',
+    integrations,
+  };
+}
+
+export function catalogTool(overrides: Partial<AgentToolCatalogEntry> = {}): AgentToolCatalogEntry {
+  return {
+    id: 'issue_read',
+    description: 'Read issue metadata from GitHub.',
+    sensitivity: 'read',
+    sensitive: false,
+    requiredScope: [],
+    inputSchema: {type: 'object', properties: {}, additionalProperties: false},
+    outputSchema: {type: 'object', additionalProperties: true},
+    methods: [
+      {
+        id: 'get',
+        description: 'Get one issue.',
+        sensitivity: 'read',
+        sensitive: false,
+        requiredScope: [],
+      },
+      {
+        id: 'get_comments',
+        description: 'Get issue comments.',
+        sensitivity: 'read',
+        sensitive: false,
+        requiredScope: [],
+      },
+    ],
+    ...overrides,
+  };
+}
+
+export interface AgentToolsProviderOptions {
+  result?: CallToolResult | undefined;
+  openSessionError?: unknown;
+  callError?: unknown;
+  onOpenSession?(input: {
+    connection: IntegrationConnection;
+    tools: readonly AgentToolCatalogEntry[];
+  }): void;
+  onCall?(input: {toolId: string; arguments: Record<string, unknown>}): void;
+  onClose?(): void;
+}
+
+export function agentToolsProvider(
+  catalog: readonly AgentToolCatalogEntry[] = [catalogTool()],
+  options: AgentToolsProviderOptions = {},
+): AgentToolsProvider {
+  return {
+    catalog: () => catalog,
+    selectionCatalog: () => ({selectors: []}),
+    openSession: (input) => {
+      if (options.openSessionError) return Promise.reject(options.openSessionError);
+      options.onOpenSession?.({connection: input.connection, tools: input.tools});
+      return Promise.resolve({
+        call: (call) => {
+          options.onCall?.(call);
+          if (options.callError) return Promise.reject(options.callError);
+          return Promise.resolve(
+            options.result ?? {
+              content: [{type: 'text', text: 'dispatched'}],
+              structuredContent: {
+                status: 'dispatched',
+                provider: input.connection.provider,
+                connection_id: input.connection.id,
+                tool_id: call.toolId,
+                method: call.arguments.method,
+              },
+            },
+          );
+        },
+        close: () => {
+          options.onClose?.();
+          return Promise.resolve();
+        },
+      });
+    },
+  };
+}
+
+export function registryWithAgentTools(
+  catalog: readonly AgentToolCatalogEntry[] = [catalogTool()],
+  options: AgentToolsProviderOptions = {},
+) {
+  return createIntegrationProviderRegistry([
+    {
+      provider: 'github',
+      displayName: 'GitHub',
+      adapters: {
+        agent_tools: agentToolsProvider(catalog, options),
+      },
+    },
+  ]);
+}

package/test/env.ts

@@ -0,0 +1,23 @@
+process.env.POSTGRES_HOST ??= 'localhost';
+process.env.POSTGRES_PORT ??= '5432';
+process.env.POSTGRES_USERNAME ??= 'shipfox';
+process.env.POSTGRES_PASSWORD ??= 'password';
+process.env.POSTGRES_DATABASE = 'api_test';
+process.env.POSTGRES_MAX_CONNECTIONS ??= '5';
+process.env.TZ = 'UTC';
+process.env.GITHUB_APP_ID = '1';
+process.env.GITHUB_APP_PRIVATE_KEY = 'test-private-key';
+process.env.GITHUB_APP_CLIENT_ID = 'test-client-id';
+process.env.GITHUB_APP_CLIENT_SECRET = 'test-client-secret';
+process.env.GITHUB_APP_WEBHOOK_SECRET = 'test-webhook-secret';
+process.env.GITHUB_APP_SLUG = 'shipfox-test';
+process.env.GITHUB_INSTALL_STATE_SECRET = 'test-install-state-secret';
+process.env.LINEAR_OAUTH_CLIENT_ID = 'test-client-id';
+process.env.LINEAR_OAUTH_CLIENT_SECRET = 'test-client-secret';
+process.env.LINEAR_WEBHOOK_SIGNING_SECRET = 'test-webhook-secret';
+process.env.LINEAR_OAUTH_REDIRECT_URL = 'https://shipfox.example.com/integrations/linear/callback';
+process.env.LINEAR_MCP_ENDPOINT = 'https://mcp.linear.app/mcp';
+process.env.GITEA_BASE_URL = 'https://gitea.example.com';
+process.env.GITEA_SERVICE_USERNAME = 'shipfox-bot';
+process.env.GITEA_SERVICE_TOKEN = 'test-service-token';
+process.env.GITEA_WEBHOOK_SECRET = 'test-webhook-secret';

package/test/factories/connection.ts

@@ -0,0 +1,21 @@
+import {Factory} from 'fishery';
+import type {IntegrationConnection} from '#core/entities/connection.js';
+import {upsertIntegrationConnection} from '#db/connections.js';
+
+export const integrationConnectionFactory = Factory.define<IntegrationConnection>(
+  ({sequence, onCreate}) => {
+    onCreate(upsertIntegrationConnection);
+
+    return {
+      id: crypto.randomUUID(),
+      workspaceId: crypto.randomUUID(),
+      provider: 'gitea',
+      externalAccountId: `gitea-${sequence}`,
+      slug: `gitea_${sequence}`,
+      displayName: `Gitea Connection ${sequence}`,
+      lifecycleStatus: 'active',
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+  },
+);

package/test/globalSetup.ts

@@ -0,0 +1,22 @@
+import './env.js';
+import {
+  db as githubDb,
+  migrationsPath as githubMigrationsPath,
+} from '@shipfox/api-integration-github';
+import {runMigrations} from '@shipfox/node-drizzle';
+import {closePostgresClient, createPostgresClient} from '@shipfox/node-postgres';
+import {sql} from 'drizzle-orm';
+import {closeDb, db} from '#db/db.js';
+import {migrationsPath} from '#db/migrations.js';
+
+export async function setup() {
+  createPostgresClient();
+
+  await runMigrations(db(), migrationsPath, '__drizzle_migrations_integrations');
+  await runMigrations(githubDb(), githubMigrationsPath, '__drizzle_migrations_integrations_github');
+  await db().execute(sql`TRUNCATE integrations_connections CASCADE`);
+  await db().execute(sql`TRUNCATE integrations_webhook_deliveries CASCADE`);
+
+  closeDb();
+  await closePostgresClient();
+}

package/test/index.ts

@@ -0,0 +1 @@
+export {integrationConnectionFactory} from './factories/connection.js';

package/test/route-utils.ts

@@ -0,0 +1,104 @@
+import {
+  AUTH_USER,
+  buildUserContext,
+  setUserContext,
+  type UserContextMembership,
+} from '@shipfox/api-auth-context';
+import {type AuthMethod, ClientError, closeApp, createApp} from '@shipfox/node-fastify';
+import {afterEach, beforeEach} from '@shipfox/vitest/vi';
+import type {FastifyInstance, FastifyRequest} from 'fastify';
+import {createIntegrationsModule, type IntegrationProvider} from '#index.js';
+
+let authenticatedMemberships: UserContextMembership[] = [];
+
+const fakeUserAuth: AuthMethod = {
+  name: AUTH_USER,
+  authenticate: (request: FastifyRequest) => {
+    if (request.headers.authorization !== 'Bearer user') {
+      throw new ClientError('Invalid user token', 'unauthorized', {status: 401});
+    }
+
+    setUserContext(
+      request,
+      buildUserContext({
+        userId: 'user-1',
+        email: 'user@example.com',
+        memberships: authenticatedMemberships,
+      }),
+    );
+    return Promise.resolve();
+  },
+};
+
+export function sourceProvider(overrides: Partial<IntegrationProvider> = {}): IntegrationProvider {
+  return {
+    provider: 'gitea',
+    displayName: 'Gitea',
+    adapters: {
+      source_control: {
+        listRepositories: async () => {
+          await Promise.resolve();
+          return {
+            repositories: [
+              {
+                externalRepositoryId: 'gitea:gitea-owner/platform',
+                owner: 'gitea-owner',
+                name: 'platform',
+                fullName: 'gitea-owner/platform',
+                defaultBranch: 'main',
+                visibility: 'private',
+                cloneUrl: 'https://gitea.local/gitea-owner/platform.git',
+                htmlUrl: 'https://gitea.local/gitea-owner/platform',
+              },
+            ],
+            nextCursor: null,
+          };
+        },
+        resolveRepository: async () => {
+          await Promise.resolve();
+          throw new Error('not used');
+        },
+        listFiles: async () => {
+          await Promise.resolve();
+          return {files: [], nextCursor: null};
+        },
+        fetchFile: async () => {
+          await Promise.resolve();
+          throw new Error('not used');
+        },
+      },
+    },
+    ...overrides,
+  };
+}
+
+export async function createTestApp(providers: IntegrationProvider[]): Promise<FastifyInstance> {
+  const integrationsModule = await createIntegrationsModule({providers});
+  const app = await createApp({
+    auth: [fakeUserAuth],
+    routes: integrationsModule.routes ?? [],
+    swagger: false,
+  });
+  await app.ready();
+  return app;
+}
+
+export function useIntegrationRouteTest() {
+  let workspaceId: string;
+
+  beforeEach(async () => {
+    await closeApp();
+    workspaceId = crypto.randomUUID();
+    authenticatedMemberships = [{workspaceId, role: 'admin'}];
+  });
+
+  afterEach(async () => {
+    await closeApp();
+  });
+
+  return {
+    get workspaceId() {
+      return workspaceId;
+    },
+  };
+}

package/test/setup.ts

@@ -0,0 +1,19 @@
+import './env.js';
+import {closeDb as closeGithubDb} from '@shipfox/api-integration-github';
+import {closePostgresClient, createPostgresClient} from '@shipfox/node-postgres';
+import {afterAll, afterEach, beforeAll, vi} from '@shipfox/vitest/vi';
+import {closeDb} from '#db/db.js';
+
+beforeAll(() => {
+  createPostgresClient();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+afterAll(async () => {
+  closeDb();
+  closeGithubDb();
+  await closePostgresClient();
+});

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@shipfox/ts-config/node",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "exclude": ["**/*.test.tsx", "**/*.test.ts"]
+}