@shipfox/api-integration-github 2.0.0

package/dist/presentation/e2eRoutes/create-connection.js

@@ -0,0 +1,57 @@
+import { toIntegrationConnectionDto } from '@shipfox/api-integration-core-dto';
+import { createE2eGithubConnectionBodySchema, createE2eGithubConnectionResponseSchema } from '@shipfox/api-integration-github-dto';
+import { ClientError, defineRoute } from '@shipfox/node-fastify';
+export function createE2eGithubConnectionRoute(options) {
+    return defineRoute({
+        method: 'POST',
+        path: '/github-connections',
+        description: 'Create a synthetic GitHub connection for E2E tests.',
+        schema: {
+            body: createE2eGithubConnectionBodySchema,
+            response: {
+                201: createE2eGithubConnectionResponseSchema
+            }
+        },
+        handler: async (request, reply)=>{
+            const body = request.body;
+            const installationId = String(body.installation_id);
+            const existing = await options.getExistingGithubConnection({
+                installationId
+            });
+            if (existing && existing.workspaceId !== body.workspace_id) {
+                throw new ClientError('GitHub installation is already connected to another workspace', 'github-connection-workspace-mismatch', {
+                    status: 409
+                });
+            }
+            const connection = existing ?? await options.connectGithubInstallation({
+                workspaceId: body.workspace_id,
+                installationId,
+                displayName: body.display_name,
+                installerUserId: body.installer_user_id,
+                installation: {
+                    installationId,
+                    accountLogin: body.account_login,
+                    accountType: 'Organization',
+                    repositorySelection: 'all',
+                    suspendedAt: null,
+                    deletedAt: null,
+                    latestEvent: {
+                        id: body.installation_id,
+                        account: {
+                            login: body.account_login,
+                            type: 'Organization'
+                        },
+                        repository_selection: 'all'
+                    },
+                    installerUserId: body.installer_user_id
+                }
+            });
+            reply.code(201);
+            return toIntegrationConnectionDto(connection, {
+                capabilities: options.connectionCapabilities
+            });
+        }
+    });
+}
+
+//# sourceMappingURL=create-connection.js.map

package/dist/presentation/e2eRoutes/create-connection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/e2eRoutes/create-connection.ts"],"sourcesContent":["import type {IntegrationCapability, IntegrationConnection} from '@shipfox/api-integration-core-dto';\nimport {toIntegrationConnectionDto} from '@shipfox/api-integration-core-dto';\nimport {\n  createE2eGithubConnectionBodySchema,\n  createE2eGithubConnectionResponseSchema,\n} from '@shipfox/api-integration-github-dto';\nimport {ClientError, defineRoute} from '@shipfox/node-fastify';\nimport type {ConnectGithubInstallationInput} from '#core/install.js';\n\nexport interface CreateE2eGithubConnectionRouteOptions {\n  getExistingGithubConnection: (input: {\n    installationId: string;\n  }) => Promise<IntegrationConnection<'github'> | undefined>;\n  connectGithubInstallation: (\n    input: ConnectGithubInstallationInput,\n  ) => Promise<IntegrationConnection<'github'>>;\n  connectionCapabilities: IntegrationCapability[];\n}\n\nexport function createE2eGithubConnectionRoute(options: CreateE2eGithubConnectionRouteOptions) {\n  return defineRoute({\n    method: 'POST',\n    path: '/github-connections',\n    description: 'Create a synthetic GitHub connection for E2E tests.',\n    schema: {\n      body: createE2eGithubConnectionBodySchema,\n      response: {201: createE2eGithubConnectionResponseSchema},\n    },\n    handler: async (request, reply) => {\n      const body = request.body;\n      const installationId = String(body.installation_id);\n      const existing = await options.getExistingGithubConnection({installationId});\n      if (existing && existing.workspaceId !== body.workspace_id) {\n        throw new ClientError(\n          'GitHub installation is already connected to another workspace',\n          'github-connection-workspace-mismatch',\n          {status: 409},\n        );\n      }\n\n      const connection =\n        existing ??\n        (await options.connectGithubInstallation({\n          workspaceId: body.workspace_id,\n          installationId,\n          displayName: body.display_name,\n          installerUserId: body.installer_user_id,\n          installation: {\n            installationId,\n            accountLogin: body.account_login,\n            accountType: 'Organization',\n            repositorySelection: 'all',\n            suspendedAt: null,\n            deletedAt: null,\n            latestEvent: {\n              id: body.installation_id,\n              account: {login: body.account_login, type: 'Organization'},\n              repository_selection: 'all',\n            },\n            installerUserId: body.installer_user_id,\n          },\n        }));\n\n      reply.code(201);\n      return toIntegrationConnectionDto(connection, {\n        capabilities: options.connectionCapabilities,\n      });\n    },\n  });\n}\n"],"names":["toIntegrationConnectionDto","createE2eGithubConnectionBodySchema","createE2eGithubConnectionResponseSchema","ClientError","defineRoute","createE2eGithubConnectionRoute","options","method","path","description","schema","body","response","handler","request","reply","installationId","String","installation_id","existing","getExistingGithubConnection","workspaceId","workspace_id","status","connection","connectGithubInstallation","displayName","display_name","installerUserId","installer_user_id","installation","accountLogin","account_login","accountType","repositorySelection","suspendedAt","deletedAt","latestEvent","id","account","login","type","repository_selection","code","capabilities","connectionCapabilities"],"mappings":"AACA,SAAQA,0BAA0B,QAAO,oCAAoC;AAC7E,SACEC,mCAAmC,EACnCC,uCAAuC,QAClC,sCAAsC;AAC7C,SAAQC,WAAW,EAAEC,WAAW,QAAO,wBAAwB;AAa/D,OAAO,SAASC,+BAA+BC,OAA8C;IAC3F,OAAOF,YAAY;QACjBG,QAAQ;QACRC,MAAM;QACNC,aAAa;QACbC,QAAQ;YACNC,MAAMV;YACNW,UAAU;gBAAC,KAAKV;YAAuC;QACzD;QACAW,SAAS,OAAOC,SAASC;YACvB,MAAMJ,OAAOG,QAAQH,IAAI;YACzB,MAAMK,iBAAiBC,OAAON,KAAKO,eAAe;YAClD,MAAMC,WAAW,MAAMb,QAAQc,2BAA2B,CAAC;gBAACJ;YAAc;YAC1E,IAAIG,YAAYA,SAASE,WAAW,KAAKV,KAAKW,YAAY,EAAE;gBAC1D,MAAM,IAAInB,YACR,iEACA,wCACA;oBAACoB,QAAQ;gBAAG;YAEhB;YAEA,MAAMC,aACJL,YACC,MAAMb,QAAQmB,yBAAyB,CAAC;gBACvCJ,aAAaV,KAAKW,YAAY;gBAC9BN;gBACAU,aAAaf,KAAKgB,YAAY;gBAC9BC,iBAAiBjB,KAAKkB,iBAAiB;gBACvCC,cAAc;oBACZd;oBACAe,cAAcpB,KAAKqB,aAAa;oBAChCC,aAAa;oBACbC,qBAAqB;oBACrBC,aAAa;oBACbC,WAAW;oBACXC,aAAa;wBACXC,IAAI3B,KAAKO,eAAe;wBACxBqB,SAAS;4BAACC,OAAO7B,KAAKqB,aAAa;4BAAES,MAAM;wBAAc;wBACzDC,sBAAsB;oBACxB;oBACAd,iBAAiBjB,KAAKkB,iBAAiB;gBACzC;YACF;YAEFd,MAAM4B,IAAI,CAAC;YACX,OAAO3C,2BAA2BwB,YAAY;gBAC5CoB,cAActC,QAAQuC,sBAAsB;YAC9C;QACF;IACF;AACF"}

package/dist/presentation/e2eRoutes/index.d.ts

@@ -0,0 +1,5 @@
+import type { RouteGroup } from '@shipfox/node-fastify';
+import { type CreateE2eGithubConnectionRouteOptions } from './create-connection.js';
+export type CreateGithubE2eRoutesOptions = CreateE2eGithubConnectionRouteOptions;
+export declare function createGithubE2eRoutes(options: CreateGithubE2eRoutesOptions): RouteGroup;
+//# sourceMappingURL=index.d.ts.map

package/dist/presentation/e2eRoutes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/presentation/e2eRoutes/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,uBAAuB,CAAC;AACtD,OAAO,EACL,KAAK,qCAAqC,EAE3C,MAAM,wBAAwB,CAAC;AAEhC,MAAM,MAAM,4BAA4B,GAAG,qCAAqC,CAAC;AAEjF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,UAAU,CAKvF"}

package/dist/presentation/e2eRoutes/index.js

@@ -0,0 +1,11 @@
+import { createE2eGithubConnectionRoute } from './create-connection.js';
+export function createGithubE2eRoutes(options) {
+    return {
+        prefix: '/integrations',
+        routes: [
+            createE2eGithubConnectionRoute(options)
+        ]
+    };
+}
+
+//# sourceMappingURL=index.js.map

package/dist/presentation/e2eRoutes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/e2eRoutes/index.ts"],"sourcesContent":["import type {RouteGroup} from '@shipfox/node-fastify';\nimport {\n  type CreateE2eGithubConnectionRouteOptions,\n  createE2eGithubConnectionRoute,\n} from './create-connection.js';\n\nexport type CreateGithubE2eRoutesOptions = CreateE2eGithubConnectionRouteOptions;\n\nexport function createGithubE2eRoutes(options: CreateGithubE2eRoutesOptions): RouteGroup {\n  return {\n    prefix: '/integrations',\n    routes: [createE2eGithubConnectionRoute(options)],\n  };\n}\n"],"names":["createE2eGithubConnectionRoute","createGithubE2eRoutes","options","prefix","routes"],"mappings":"AACA,SAEEA,8BAA8B,QACzB,yBAAyB;AAIhC,OAAO,SAASC,sBAAsBC,OAAqC;IACzE,OAAO;QACLC,QAAQ;QACRC,QAAQ;YAACJ,+BAA+BE;SAAS;IACnD;AACF"}

package/dist/presentation/routes/errors.d.ts

@@ -0,0 +1,2 @@
+export declare function githubRouteErrorHandler(error: unknown): never;
+//# sourceMappingURL=errors.d.ts.map

package/dist/presentation/routes/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/errors.ts"],"names":[],"mappings":"AAmBA,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAuB7D"}

package/dist/presentation/routes/errors.js

@@ -0,0 +1,46 @@
+import { ConnectionSlugConflictError } from '@shipfox/api-integration-core-dto';
+import { ClientError } from '@shipfox/node-fastify';
+import { GithubInstallationAlreadyLinkedError, GithubInstallationNotAuthorizedError, GithubInstallStateActorMismatchError, GithubInstallStateError, GithubIntegrationProviderError } from '#core/errors.js';
+function providerStatus(reason) {
+    if (reason === 'rate-limited') return 429;
+    if (reason === 'timeout' || reason === 'provider-unavailable') return 503;
+    return 422;
+}
+export function githubRouteErrorHandler(error) {
+    if (error instanceof GithubInstallStateError) {
+        throw new ClientError(error.message, 'invalid-github-install-state', {
+            status: 400
+        });
+    }
+    if (error instanceof GithubInstallStateActorMismatchError) {
+        throw new ClientError(error.message, 'github-install-state-actor-mismatch', {
+            status: 403
+        });
+    }
+    if (error instanceof GithubInstallationNotAuthorizedError) {
+        throw new ClientError(error.message, 'github-installation-not-authorized', {
+            status: 403
+        });
+    }
+    if (error instanceof GithubInstallationAlreadyLinkedError) {
+        throw new ClientError(error.message, 'github-installation-already-linked', {
+            status: 409
+        });
+    }
+    if (error instanceof ConnectionSlugConflictError) {
+        throw new ClientError(error.message, 'slug-conflict', {
+            status: 409
+        });
+    }
+    if (error instanceof GithubIntegrationProviderError) {
+        throw new ClientError(error.message, error.reason, {
+            details: {
+                retry_after_seconds: error.retryAfterSeconds
+            },
+            status: providerStatus(error.reason)
+        });
+    }
+    throw error;
+}
+
+//# sourceMappingURL=errors.js.map

package/dist/presentation/routes/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/routes/errors.ts"],"sourcesContent":["import {\n  ConnectionSlugConflictError,\n  type IntegrationProviderErrorReason,\n} from '@shipfox/api-integration-core-dto';\nimport {ClientError} from '@shipfox/node-fastify';\nimport {\n  GithubInstallationAlreadyLinkedError,\n  GithubInstallationNotAuthorizedError,\n  GithubInstallStateActorMismatchError,\n  GithubInstallStateError,\n  GithubIntegrationProviderError,\n} from '#core/errors.js';\n\nfunction providerStatus(reason: IntegrationProviderErrorReason): number {\n  if (reason === 'rate-limited') return 429;\n  if (reason === 'timeout' || reason === 'provider-unavailable') return 503;\n  return 422;\n}\n\nexport function githubRouteErrorHandler(error: unknown): never {\n  if (error instanceof GithubInstallStateError) {\n    throw new ClientError(error.message, 'invalid-github-install-state', {status: 400});\n  }\n  if (error instanceof GithubInstallStateActorMismatchError) {\n    throw new ClientError(error.message, 'github-install-state-actor-mismatch', {status: 403});\n  }\n  if (error instanceof GithubInstallationNotAuthorizedError) {\n    throw new ClientError(error.message, 'github-installation-not-authorized', {status: 403});\n  }\n  if (error instanceof GithubInstallationAlreadyLinkedError) {\n    throw new ClientError(error.message, 'github-installation-already-linked', {status: 409});\n  }\n  if (error instanceof ConnectionSlugConflictError) {\n    throw new ClientError(error.message, 'slug-conflict', {status: 409});\n  }\n  if (error instanceof GithubIntegrationProviderError) {\n    throw new ClientError(error.message, error.reason, {\n      details: {retry_after_seconds: error.retryAfterSeconds},\n      status: providerStatus(error.reason),\n    });\n  }\n  throw error;\n}\n"],"names":["ConnectionSlugConflictError","ClientError","GithubInstallationAlreadyLinkedError","GithubInstallationNotAuthorizedError","GithubInstallStateActorMismatchError","GithubInstallStateError","GithubIntegrationProviderError","providerStatus","reason","githubRouteErrorHandler","error","message","status","details","retry_after_seconds","retryAfterSeconds"],"mappings":"AAAA,SACEA,2BAA2B,QAEtB,oCAAoC;AAC3C,SAAQC,WAAW,QAAO,wBAAwB;AAClD,SACEC,oCAAoC,EACpCC,oCAAoC,EACpCC,oCAAoC,EACpCC,uBAAuB,EACvBC,8BAA8B,QACzB,kBAAkB;AAEzB,SAASC,eAAeC,MAAsC;IAC5D,IAAIA,WAAW,gBAAgB,OAAO;IACtC,IAAIA,WAAW,aAAaA,WAAW,wBAAwB,OAAO;IACtE,OAAO;AACT;AAEA,OAAO,SAASC,wBAAwBC,KAAc;IACpD,IAAIA,iBAAiBL,yBAAyB;QAC5C,MAAM,IAAIJ,YAAYS,MAAMC,OAAO,EAAE,gCAAgC;YAACC,QAAQ;QAAG;IACnF;IACA,IAAIF,iBAAiBN,sCAAsC;QACzD,MAAM,IAAIH,YAAYS,MAAMC,OAAO,EAAE,uCAAuC;YAACC,QAAQ;QAAG;IAC1F;IACA,IAAIF,iBAAiBP,sCAAsC;QACzD,MAAM,IAAIF,YAAYS,MAAMC,OAAO,EAAE,sCAAsC;YAACC,QAAQ;QAAG;IACzF;IACA,IAAIF,iBAAiBR,sCAAsC;QACzD,MAAM,IAAID,YAAYS,MAAMC,OAAO,EAAE,sCAAsC;YAACC,QAAQ;QAAG;IACzF;IACA,IAAIF,iBAAiBV,6BAA6B;QAChD,MAAM,IAAIC,YAAYS,MAAMC,OAAO,EAAE,iBAAiB;YAACC,QAAQ;QAAG;IACpE;IACA,IAAIF,iBAAiBJ,gCAAgC;QACnD,MAAM,IAAIL,YAAYS,MAAMC,OAAO,EAAED,MAAMF,MAAM,EAAE;YACjDK,SAAS;gBAACC,qBAAqBJ,MAAMK,iBAAiB;YAAA;YACtDH,QAAQL,eAAeG,MAAMF,MAAM;QACrC;IACF;IACA,MAAME;AACR"}

package/dist/presentation/routes/install.d.ts

@@ -0,0 +1,13 @@
+import type { IntegrationConnection } from '@shipfox/api-integration-core-dto';
+import { type RouteGroup } from '@shipfox/node-fastify';
+import type { GithubApiClient } from '#api/client.js';
+import { type ConnectGithubInstallationInput } from '#core/install.js';
+export interface CreateGithubIntegrationRoutesOptions {
+    github: GithubApiClient;
+    getExistingGithubConnection: (input: {
+        installationId: string;
+    }) => Promise<IntegrationConnection<'github'> | undefined>;
+    connectGithubInstallation: (input: ConnectGithubInstallationInput) => Promise<IntegrationConnection<'github'>>;
+}
+export declare function createGithubIntegrationRoutes({ github, getExistingGithubConnection, connectGithubInstallation, }: CreateGithubIntegrationRoutesOptions): RouteGroup;
+//# sourceMappingURL=install.d.ts.map

package/dist/presentation/routes/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/install.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,mCAAmC,CAAC;AAQ7E,OAAO,EAAc,KAAK,UAAU,EAAC,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,gBAAgB,CAAC;AAEpD,OAAO,EAAC,KAAK,8BAA8B,EAAuB,MAAM,kBAAkB,CAAC;AAK3F,MAAM,WAAW,oCAAoC;IACnD,MAAM,EAAE,eAAe,CAAC;IACxB,2BAA2B,EAAE,CAAC,KAAK,EAAE;QACnC,cAAc,EAAE,MAAM,CAAC;KACxB,KAAK,OAAO,CAAC,qBAAqB,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC,CAAC;IAC3D,yBAAyB,EAAE,CACzB,KAAK,EAAE,8BAA8B,KAClC,OAAO,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,CAAC;CAC/C;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,MAAM,EACN,2BAA2B,EAC3B,yBAAyB,GAC1B,EAAE,oCAAoC,GAAG,UAAU,CA6DnD"}

package/dist/presentation/routes/install.js

@@ -0,0 +1,77 @@
+import { AUTH_USER, requireUserContext, requireWorkspaceAccess } from '@shipfox/api-auth-context';
+import { createGithubInstallBodySchema, createGithubInstallResponseSchema, githubCallbackQuerySchema, githubCallbackResponseSchema } from '@shipfox/api-integration-github-dto';
+import { requireWorkspaceMembership } from '@shipfox/api-workspaces';
+import { defineRoute } from '@shipfox/node-fastify';
+import { config } from '#config.js';
+import { handleGithubCallback } from '#core/install.js';
+import { signGithubInstallState } from '#core/state.js';
+import { toIntegrationConnectionDto } from '#presentation/dto/integrations.js';
+import { githubRouteErrorHandler } from './errors.js';
+export function createGithubIntegrationRoutes({ github, getExistingGithubConnection, connectGithubInstallation }) {
+    const createInstallRoute = defineRoute({
+        method: 'POST',
+        path: '/install',
+        auth: AUTH_USER,
+        description: 'Create a GitHub App installation URL for a workspace.',
+        schema: {
+            body: createGithubInstallBodySchema,
+            response: {
+                200: createGithubInstallResponseSchema
+            }
+        },
+        handler: (request)=>{
+            const { workspace_id: workspaceId } = request.body;
+            const actor = requireUserContext(request);
+            requireWorkspaceAccess({
+                request,
+                workspaceId
+            });
+            const state = signGithubInstallState({
+                workspaceId,
+                userId: actor.userId
+            });
+            const installUrl = new URL(`https://github.com/apps/${config.GITHUB_APP_SLUG}/installations/new`);
+            installUrl.searchParams.set('state', state);
+            return {
+                install_url: installUrl.toString()
+            };
+        }
+    });
+    const callbackApiRoute = defineRoute({
+        method: 'GET',
+        path: '/callback/api',
+        auth: AUTH_USER,
+        description: 'Handle the GitHub App installation callback.',
+        schema: {
+            querystring: githubCallbackQuerySchema,
+            response: {
+                200: githubCallbackResponseSchema
+            }
+        },
+        errorHandler: githubRouteErrorHandler,
+        handler: async (request)=>{
+            const actor = requireUserContext(request);
+            const connection = await handleGithubCallback({
+                github,
+                code: request.query.code,
+                installationId: request.query.installation_id,
+                state: request.query.state,
+                sessionUserId: actor.userId,
+                sessionMemberships: actor.memberships,
+                requireWorkspaceMembership,
+                getExistingGithubConnection,
+                connectGithubInstallation
+            });
+            return toIntegrationConnectionDto(connection);
+        }
+    });
+    return {
+        prefix: '/integrations/github',
+        routes: [
+            createInstallRoute,
+            callbackApiRoute
+        ]
+    };
+}
+
+//# sourceMappingURL=install.js.map

package/dist/presentation/routes/install.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/routes/install.ts"],"sourcesContent":["import {AUTH_USER, requireUserContext, requireWorkspaceAccess} from '@shipfox/api-auth-context';\nimport type {IntegrationConnection} from '@shipfox/api-integration-core-dto';\nimport {\n  createGithubInstallBodySchema,\n  createGithubInstallResponseSchema,\n  githubCallbackQuerySchema,\n  githubCallbackResponseSchema,\n} from '@shipfox/api-integration-github-dto';\nimport {requireWorkspaceMembership} from '@shipfox/api-workspaces';\nimport {defineRoute, type RouteGroup} from '@shipfox/node-fastify';\nimport type {GithubApiClient} from '#api/client.js';\nimport {config} from '#config.js';\nimport {type ConnectGithubInstallationInput, handleGithubCallback} from '#core/install.js';\nimport {signGithubInstallState} from '#core/state.js';\nimport {toIntegrationConnectionDto} from '#presentation/dto/integrations.js';\nimport {githubRouteErrorHandler} from './errors.js';\n\nexport interface CreateGithubIntegrationRoutesOptions {\n  github: GithubApiClient;\n  getExistingGithubConnection: (input: {\n    installationId: string;\n  }) => Promise<IntegrationConnection<'github'> | undefined>;\n  connectGithubInstallation: (\n    input: ConnectGithubInstallationInput,\n  ) => Promise<IntegrationConnection<'github'>>;\n}\n\nexport function createGithubIntegrationRoutes({\n  github,\n  getExistingGithubConnection,\n  connectGithubInstallation,\n}: CreateGithubIntegrationRoutesOptions): RouteGroup {\n  const createInstallRoute = defineRoute({\n    method: 'POST',\n    path: '/install',\n    auth: AUTH_USER,\n    description: 'Create a GitHub App installation URL for a workspace.',\n    schema: {\n      body: createGithubInstallBodySchema,\n      response: {\n        200: createGithubInstallResponseSchema,\n      },\n    },\n    handler: (request) => {\n      const {workspace_id: workspaceId} = request.body;\n      const actor = requireUserContext(request);\n\n      requireWorkspaceAccess({request, workspaceId});\n      const state = signGithubInstallState({workspaceId, userId: actor.userId});\n      const installUrl = new URL(\n        `https://github.com/apps/${config.GITHUB_APP_SLUG}/installations/new`,\n      );\n      installUrl.searchParams.set('state', state);\n\n      return {install_url: installUrl.toString()};\n    },\n  });\n\n  const callbackApiRoute = defineRoute({\n    method: 'GET',\n    path: '/callback/api',\n    auth: AUTH_USER,\n    description: 'Handle the GitHub App installation callback.',\n    schema: {\n      querystring: githubCallbackQuerySchema,\n      response: {\n        200: githubCallbackResponseSchema,\n      },\n    },\n    errorHandler: githubRouteErrorHandler,\n    handler: async (request) => {\n      const actor = requireUserContext(request);\n      const connection = await handleGithubCallback({\n        github,\n        code: request.query.code,\n        installationId: request.query.installation_id,\n        state: request.query.state,\n        sessionUserId: actor.userId,\n        sessionMemberships: actor.memberships,\n        requireWorkspaceMembership,\n        getExistingGithubConnection,\n        connectGithubInstallation,\n      });\n\n      return toIntegrationConnectionDto(connection);\n    },\n  });\n\n  return {\n    prefix: '/integrations/github',\n    routes: [createInstallRoute, callbackApiRoute],\n  };\n}\n"],"names":["AUTH_USER","requireUserContext","requireWorkspaceAccess","createGithubInstallBodySchema","createGithubInstallResponseSchema","githubCallbackQuerySchema","githubCallbackResponseSchema","requireWorkspaceMembership","defineRoute","config","handleGithubCallback","signGithubInstallState","toIntegrationConnectionDto","githubRouteErrorHandler","createGithubIntegrationRoutes","github","getExistingGithubConnection","connectGithubInstallation","createInstallRoute","method","path","auth","description","schema","body","response","handler","request","workspace_id","workspaceId","actor","state","userId","installUrl","URL","GITHUB_APP_SLUG","searchParams","set","install_url","toString","callbackApiRoute","querystring","errorHandler","connection","code","query","installationId","installation_id","sessionUserId","sessionMemberships","memberships","prefix","routes"],"mappings":"AAAA,SAAQA,SAAS,EAAEC,kBAAkB,EAAEC,sBAAsB,QAAO,4BAA4B;AAEhG,SACEC,6BAA6B,EAC7BC,iCAAiC,EACjCC,yBAAyB,EACzBC,4BAA4B,QACvB,sCAAsC;AAC7C,SAAQC,0BAA0B,QAAO,0BAA0B;AACnE,SAAQC,WAAW,QAAwB,wBAAwB;AAEnE,SAAQC,MAAM,QAAO,aAAa;AAClC,SAA6CC,oBAAoB,QAAO,mBAAmB;AAC3F,SAAQC,sBAAsB,QAAO,iBAAiB;AACtD,SAAQC,0BAA0B,QAAO,oCAAoC;AAC7E,SAAQC,uBAAuB,QAAO,cAAc;AAYpD,OAAO,SAASC,8BAA8B,EAC5CC,MAAM,EACNC,2BAA2B,EAC3BC,yBAAyB,EACY;IACrC,MAAMC,qBAAqBV,YAAY;QACrCW,QAAQ;QACRC,MAAM;QACNC,MAAMrB;QACNsB,aAAa;QACbC,QAAQ;YACNC,MAAMrB;YACNsB,UAAU;gBACR,KAAKrB;YACP;QACF;QACAsB,SAAS,CAACC;YACR,MAAM,EAACC,cAAcC,WAAW,EAAC,GAAGF,QAAQH,IAAI;YAChD,MAAMM,QAAQ7B,mBAAmB0B;YAEjCzB,uBAAuB;gBAACyB;gBAASE;YAAW;YAC5C,MAAME,QAAQpB,uBAAuB;gBAACkB;gBAAaG,QAAQF,MAAME,MAAM;YAAA;YACvE,MAAMC,aAAa,IAAIC,IACrB,CAAC,wBAAwB,EAAEzB,OAAO0B,eAAe,CAAC,kBAAkB,CAAC;YAEvEF,WAAWG,YAAY,CAACC,GAAG,CAAC,SAASN;YAErC,OAAO;gBAACO,aAAaL,WAAWM,QAAQ;YAAE;QAC5C;IACF;IAEA,MAAMC,mBAAmBhC,YAAY;QACnCW,QAAQ;QACRC,MAAM;QACNC,MAAMrB;QACNsB,aAAa;QACbC,QAAQ;YACNkB,aAAapC;YACboB,UAAU;gBACR,KAAKnB;YACP;QACF;QACAoC,cAAc7B;QACda,SAAS,OAAOC;YACd,MAAMG,QAAQ7B,mBAAmB0B;YACjC,MAAMgB,aAAa,MAAMjC,qBAAqB;gBAC5CK;gBACA6B,MAAMjB,QAAQkB,KAAK,CAACD,IAAI;gBACxBE,gBAAgBnB,QAAQkB,KAAK,CAACE,eAAe;gBAC7ChB,OAAOJ,QAAQkB,KAAK,CAACd,KAAK;gBAC1BiB,eAAelB,MAAME,MAAM;gBAC3BiB,oBAAoBnB,MAAMoB,WAAW;gBACrC3C;gBACAS;gBACAC;YACF;YAEA,OAAOL,2BAA2B+B;QACpC;IACF;IAEA,OAAO;QACLQ,QAAQ;QACRC,QAAQ;YAAClC;YAAoBsB;SAAiB;IAChD;AACF"}

package/dist/presentation/routes/webhooks.d.ts

@@ -0,0 +1,16 @@
+import type { GetIntegrationConnectionByIdFn, PublishIntegrationEventReceivedFn, PublishSourcePushFn, RecordDeliveryOnlyFn } from '@shipfox/api-integration-core-dto';
+import { type RouteGroup } from '@shipfox/node-fastify';
+import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
+export interface CreateGithubWebhookRoutesOptions {
+    coreDb: () => NodePgDatabase<Record<string, unknown>>;
+    publishIntegrationEventReceived: PublishIntegrationEventReceivedFn;
+    publishSourcePush: PublishSourcePushFn;
+    recordDeliveryOnly: RecordDeliveryOnlyFn;
+    getIntegrationConnectionById: GetIntegrationConnectionByIdFn;
+    deleteInstallationTokenSecret?: ((params: {
+        workspaceId: string;
+        installationId: number;
+    }) => Promise<unknown>) | undefined;
+}
+export declare function createGithubWebhookRoutes(options: CreateGithubWebhookRoutesOptions): RouteGroup;
+//# sourceMappingURL=webhooks.d.ts.map

package/dist/presentation/routes/webhooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/webhooks.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,8BAA8B,EAC9B,iCAAiC,EACjC,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAEL,KAAK,UAAU,EAGhB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,2BAA2B,CAAC;AAQ9D,MAAM,WAAW,gCAAgC;IAC/C,MAAM,EAAE,MAAM,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACtD,+BAA+B,EAAE,iCAAiC,CAAC;IACnE,iBAAiB,EAAE,mBAAmB,CAAC;IACvC,kBAAkB,EAAE,oBAAoB,CAAC;IACzC,4BAA4B,EAAE,8BAA8B,CAAC;IAC7D,6BAA6B,CAAC,EAC1B,CAAC,CAAC,MAAM,EAAE;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,GAC7E,SAAS,CAAC;CACf;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,gCAAgC,GAAG,UAAU,CAgF/F"}

package/dist/presentation/routes/webhooks.js

@@ -0,0 +1,110 @@
+import { Buffer } from 'node:buffer';
+import { Webhooks } from '@octokit/webhooks';
+import { defineRoute, rawBodyPlugin, WEBHOOK_BODY_LIMIT } from '@shipfox/node-fastify';
+import { logger } from '@shipfox/node-opentelemetry';
+import { config } from '#config.js';
+import { handleGithubEvent } from '#core/webhook.js';
+const SIGNATURE_HEADER = 'x-hub-signature-256';
+const EVENT_HEADER = 'x-github-event';
+const DELIVERY_HEADER = 'x-github-delivery';
+export function createGithubWebhookRoutes(options) {
+    const webhooks = new Webhooks({
+        secret: config.GITHUB_APP_WEBHOOK_SECRET
+    });
+    const pushRoute = defineRoute({
+        method: 'POST',
+        path: '/',
+        auth: [],
+        description: 'GitHub App webhook receiver.',
+        options: {
+            bodyLimit: WEBHOOK_BODY_LIMIT
+        },
+        handler: async (request, reply)=>{
+            const deliveryId = request.headers[DELIVERY_HEADER];
+            const signature = request.headers[SIGNATURE_HEADER];
+            const event = request.headers[EVENT_HEADER];
+            if (typeof deliveryId !== 'string' || !deliveryId) {
+                reply.code(400);
+                return {
+                    error: 'missing X-GitHub-Delivery header'
+                };
+            }
+            if (typeof signature !== 'string' || !signature) {
+                reply.code(401);
+                return {
+                    error: 'missing X-Hub-Signature-256 header'
+                };
+            }
+            if (typeof event !== 'string' || !event) {
+                reply.code(400);
+                return {
+                    error: 'missing X-GitHub-Event header'
+                };
+            }
+            const body = request.body;
+            if (!Buffer.isBuffer(body)) {
+                reply.code(400);
+                return {
+                    error: 'expected raw JSON body'
+                };
+            }
+            const rawBody = body.toString('utf8');
+            let verified;
+            try {
+                verified = await webhooks.verify(rawBody, signature);
+            } catch (error) {
+                logger().warn({
+                    deliveryId,
+                    err: error
+                }, 'github webhook signature verification threw');
+                verified = false;
+            }
+            if (!verified) {
+                reply.code(401);
+                return {
+                    error: 'invalid signature'
+                };
+            }
+            let parsedJson;
+            try {
+                parsedJson = JSON.parse(rawBody);
+            } catch (error) {
+                logger().warn({
+                    deliveryId,
+                    err: error
+                }, 'github webhook payload JSON parse failed');
+                reply.code(400);
+                return {
+                    error: 'malformed JSON'
+                };
+            }
+            await options.coreDb().transaction(async (tx)=>{
+                await handleGithubEvent({
+                    tx,
+                    deliveryId,
+                    event,
+                    payload: parsedJson,
+                    publishIntegrationEventReceived: options.publishIntegrationEventReceived,
+                    publishSourcePush: options.publishSourcePush,
+                    recordDeliveryOnly: options.recordDeliveryOnly,
+                    getIntegrationConnectionById: options.getIntegrationConnectionById,
+                    deleteInstallationTokenSecret: options.deleteInstallationTokenSecret
+                });
+            });
+            reply.code(204);
+            return null;
+        }
+    });
+    return {
+        prefix: '/webhooks/integrations/github',
+        auth: [],
+        plugins: [
+            rawBodyPlugin
+        ],
+        routes: [
+            pushRoute
+        ]
+    };
+}
+
+//# sourceMappingURL=webhooks.js.map

package/dist/presentation/routes/webhooks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/routes/webhooks.ts"],"sourcesContent":["import {Buffer} from 'node:buffer';\nimport {Webhooks} from '@octokit/webhooks';\nimport type {\n  GetIntegrationConnectionByIdFn,\n  PublishIntegrationEventReceivedFn,\n  PublishSourcePushFn,\n  RecordDeliveryOnlyFn,\n} from '@shipfox/api-integration-core-dto';\nimport {\n  defineRoute,\n  type RouteGroup,\n  rawBodyPlugin,\n  WEBHOOK_BODY_LIMIT,\n} from '@shipfox/node-fastify';\nimport {logger} from '@shipfox/node-opentelemetry';\nimport type {NodePgDatabase} from 'drizzle-orm/node-postgres';\nimport {config} from '#config.js';\nimport {handleGithubEvent} from '#core/webhook.js';\n\nconst SIGNATURE_HEADER = 'x-hub-signature-256';\nconst EVENT_HEADER = 'x-github-event';\nconst DELIVERY_HEADER = 'x-github-delivery';\n\nexport interface CreateGithubWebhookRoutesOptions {\n  coreDb: () => NodePgDatabase<Record<string, unknown>>;\n  publishIntegrationEventReceived: PublishIntegrationEventReceivedFn;\n  publishSourcePush: PublishSourcePushFn;\n  recordDeliveryOnly: RecordDeliveryOnlyFn;\n  getIntegrationConnectionById: GetIntegrationConnectionByIdFn;\n  deleteInstallationTokenSecret?:\n    | ((params: {workspaceId: string; installationId: number}) => Promise<unknown>)\n    | undefined;\n}\n\nexport function createGithubWebhookRoutes(options: CreateGithubWebhookRoutesOptions): RouteGroup {\n  const webhooks = new Webhooks({secret: config.GITHUB_APP_WEBHOOK_SECRET});\n\n  const pushRoute = defineRoute({\n    method: 'POST',\n    path: '/',\n    auth: [],\n    description: 'GitHub App webhook receiver.',\n    options: {bodyLimit: WEBHOOK_BODY_LIMIT},\n    handler: async (request, reply) => {\n      const deliveryId = request.headers[DELIVERY_HEADER];\n      const signature = request.headers[SIGNATURE_HEADER];\n      const event = request.headers[EVENT_HEADER];\n\n      if (typeof deliveryId !== 'string' || !deliveryId) {\n        reply.code(400);\n        return {error: 'missing X-GitHub-Delivery header'};\n      }\n      if (typeof signature !== 'string' || !signature) {\n        reply.code(401);\n        return {error: 'missing X-Hub-Signature-256 header'};\n      }\n      if (typeof event !== 'string' || !event) {\n        reply.code(400);\n        return {error: 'missing X-GitHub-Event header'};\n      }\n\n      const body = request.body;\n      if (!Buffer.isBuffer(body)) {\n        reply.code(400);\n        return {error: 'expected raw JSON body'};\n      }\n      const rawBody = body.toString('utf8');\n\n      let verified: boolean;\n      try {\n        verified = await webhooks.verify(rawBody, signature);\n      } catch (error) {\n        logger().warn({deliveryId, err: error}, 'github webhook signature verification threw');\n        verified = false;\n      }\n      if (!verified) {\n        reply.code(401);\n        return {error: 'invalid signature'};\n      }\n\n      let parsedJson: unknown;\n      try {\n        parsedJson = JSON.parse(rawBody);\n      } catch (error) {\n        logger().warn({deliveryId, err: error}, 'github webhook payload JSON parse failed');\n        reply.code(400);\n        return {error: 'malformed JSON'};\n      }\n\n      await options.coreDb().transaction(async (tx) => {\n        await handleGithubEvent({\n          tx,\n          deliveryId,\n          event,\n          payload: parsedJson,\n          publishIntegrationEventReceived: options.publishIntegrationEventReceived,\n          publishSourcePush: options.publishSourcePush,\n          recordDeliveryOnly: options.recordDeliveryOnly,\n          getIntegrationConnectionById: options.getIntegrationConnectionById,\n          deleteInstallationTokenSecret: options.deleteInstallationTokenSecret,\n        });\n      });\n\n      reply.code(204);\n      return null;\n    },\n  });\n\n  return {\n    prefix: '/webhooks/integrations/github',\n    auth: [],\n    plugins: [rawBodyPlugin],\n    routes: [pushRoute],\n  };\n}\n"],"names":["Buffer","Webhooks","defineRoute","rawBodyPlugin","WEBHOOK_BODY_LIMIT","logger","config","handleGithubEvent","SIGNATURE_HEADER","EVENT_HEADER","DELIVERY_HEADER","createGithubWebhookRoutes","options","webhooks","secret","GITHUB_APP_WEBHOOK_SECRET","pushRoute","method","path","auth","description","bodyLimit","handler","request","reply","deliveryId","headers","signature","event","code","error","body","isBuffer","rawBody","toString","verified","verify","warn","err","parsedJson","JSON","parse","coreDb","transaction","tx","payload","publishIntegrationEventReceived","publishSourcePush","recordDeliveryOnly","getIntegrationConnectionById","deleteInstallationTokenSecret","prefix","plugins","routes"],"mappings":"AAAA,SAAQA,MAAM,QAAO,cAAc;AACnC,SAAQC,QAAQ,QAAO,oBAAoB;AAO3C,SACEC,WAAW,EAEXC,aAAa,EACbC,kBAAkB,QACb,wBAAwB;AAC/B,SAAQC,MAAM,QAAO,8BAA8B;AAEnD,SAAQC,MAAM,QAAO,aAAa;AAClC,SAAQC,iBAAiB,QAAO,mBAAmB;AAEnD,MAAMC,mBAAmB;AACzB,MAAMC,eAAe;AACrB,MAAMC,kBAAkB;AAaxB,OAAO,SAASC,0BAA0BC,OAAyC;IACjF,MAAMC,WAAW,IAAIZ,SAAS;QAACa,QAAQR,OAAOS,yBAAyB;IAAA;IAEvE,MAAMC,YAAYd,YAAY;QAC5Be,QAAQ;QACRC,MAAM;QACNC,MAAM,EAAE;QACRC,aAAa;QACbR,SAAS;YAACS,WAAWjB;QAAkB;QACvCkB,SAAS,OAAOC,SAASC;YACvB,MAAMC,aAAaF,QAAQG,OAAO,CAAChB,gBAAgB;YACnD,MAAMiB,YAAYJ,QAAQG,OAAO,CAAClB,iBAAiB;YACnD,MAAMoB,QAAQL,QAAQG,OAAO,CAACjB,aAAa;YAE3C,IAAI,OAAOgB,eAAe,YAAY,CAACA,YAAY;gBACjDD,MAAMK,IAAI,CAAC;gBACX,OAAO;oBAACC,OAAO;gBAAkC;YACnD;YACA,IAAI,OAAOH,cAAc,YAAY,CAACA,WAAW;gBAC/CH,MAAMK,IAAI,CAAC;gBACX,OAAO;oBAACC,OAAO;gBAAoC;YACrD;YACA,IAAI,OAAOF,UAAU,YAAY,CAACA,OAAO;gBACvCJ,MAAMK,IAAI,CAAC;gBACX,OAAO;oBAACC,OAAO;gBAA+B;YAChD;YAEA,MAAMC,OAAOR,QAAQQ,IAAI;YACzB,IAAI,CAAC/B,OAAOgC,QAAQ,CAACD,OAAO;gBAC1BP,MAAMK,IAAI,CAAC;gBACX,OAAO;oBAACC,OAAO;gBAAwB;YACzC;YACA,MAAMG,UAAUF,KAAKG,QAAQ,CAAC;YAE9B,IAAIC;YACJ,IAAI;gBACFA,WAAW,MAAMtB,SAASuB,MAAM,CAACH,SAASN;YAC5C,EAAE,OAAOG,OAAO;gBACdzB,SAASgC,IAAI,CAAC;oBAACZ;oBAAYa,KAAKR;gBAAK,GAAG;gBACxCK,WAAW;YACb;YACA,IAAI,CAACA,UAAU;gBACbX,MAAMK,IAAI,CAAC;gBACX,OAAO;oBAACC,OAAO;gBAAmB;YACpC;YAEA,IAAIS;YACJ,IAAI;gBACFA,aAAaC,KAAKC,KAAK,CAACR;YAC1B,EAAE,OAAOH,OAAO;gBACdzB,SAASgC,IAAI,CAAC;oBAACZ;oBAAYa,KAAKR;gBAAK,GAAG;gBACxCN,MAAMK,IAAI,CAAC;gBACX,OAAO;oBAACC,OAAO;gBAAgB;YACjC;YAEA,MAAMlB,QAAQ8B,MAAM,GAAGC,WAAW,CAAC,OAAOC;gBACxC,MAAMrC,kBAAkB;oBACtBqC;oBACAnB;oBACAG;oBACAiB,SAASN;oBACTO,iCAAiClC,QAAQkC,+BAA+B;oBACxEC,mBAAmBnC,QAAQmC,iBAAiB;oBAC5CC,oBAAoBpC,QAAQoC,kBAAkB;oBAC9CC,8BAA8BrC,QAAQqC,4BAA4B;oBAClEC,+BAA+BtC,QAAQsC,6BAA6B;gBACtE;YACF;YAEA1B,MAAMK,IAAI,CAAC;YACX,OAAO;QACT;IACF;IAEA,OAAO;QACLsB,QAAQ;QACRhC,MAAM,EAAE;QACRiC,SAAS;YAACjD;SAAc;QACxBkD,QAAQ;YAACrC;SAAU;IACrB;AACF"}