@shipfox/api-integration-linear 2.0.0

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

@@ -0,0 +1,407 @@
+import {createHmac, randomUUID} from 'node:crypto';
+import type {IntegrationConnection} from '@shipfox/api-integration-core-dto';
+import {closeApp, createApp} from '@shipfox/node-fastify';
+import type {FastifyInstance} from 'fastify';
+import {db} from '#db/db.js';
+import {upsertLinearInstallation} from '#db/installations.js';
+import {linearInstallations} from '#db/schema/installations.js';
+import {createLinearWebhookRoutes} from './webhooks.js';
+
+const WEBHOOK_SECRET = 'test-webhook-secret';
+
+function fakeConnection(overrides: Partial<IntegrationConnection> = {}): IntegrationConnection {
+  return {
+    id: randomUUID(),
+    workspaceId: randomUUID(),
+    provider: 'linear',
+    externalAccountId: 'org-1',
+    slug: 'Linear_Acme',
+    displayName: 'Linear Acme',
+    lifecycleStatus: 'active',
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    ...overrides,
+  };
+}
+
+function linearPayload(overrides: Record<string, unknown> = {}) {
+  return {
+    action: 'create',
+    type: 'Issue',
+    organizationId: `org-${randomUUID()}`,
+    webhookTimestamp: Date.now(),
+    data: {id: 'issue-1'},
+    ...overrides,
+  };
+}
+
+function agentSessionPayload(overrides: Record<string, unknown> = {}) {
+  return {
+    action: 'created',
+    type: 'AgentSessionEvent',
+    organizationId: `org-${randomUUID()}`,
+    appUserId: 'app-user-1',
+    webhookTimestamp: Date.now(),
+    agentSession: {id: 'session-1'},
+    ...overrides,
+  };
+}
+
+function signedHeaders(rawBody: string, event: string, deliveryId: string) {
+  const signature = createHmac('sha256', WEBHOOK_SECRET).update(rawBody).digest('hex');
+  return {
+    'content-type': 'application/json',
+    'linear-delivery': deliveryId,
+    'linear-event': event,
+    'linear-signature': signature,
+  };
+}
+
+interface TestApp {
+  app: FastifyInstance;
+  publishIntegrationEventReceived: ReturnType<typeof vi.fn>;
+  recordDeliveryOnly: ReturnType<typeof vi.fn>;
+  getIntegrationConnectionById: ReturnType<typeof vi.fn>;
+}
+
+async function createTestApp(
+  options: {connection?: IntegrationConnection | undefined} = {},
+): Promise<TestApp> {
+  const publishIntegrationEventReceived = vi.fn(() => Promise.resolve({published: true}));
+  const recordDeliveryOnly = vi.fn(() => Promise.resolve());
+  const getIntegrationConnectionById = vi.fn(() =>
+    Promise.resolve(options.connection ?? fakeConnection()),
+  );
+  const routes = createLinearWebhookRoutes({
+    coreDb: db,
+    publishIntegrationEventReceived,
+    recordDeliveryOnly,
+    getIntegrationConnectionById,
+  });
+  const app = await createApp({routes: [routes], swagger: false});
+  await app.ready();
+  return {app, publishIntegrationEventReceived, recordDeliveryOnly, getIntegrationConnectionById};
+}
+
+async function seedInstallation(input: {
+  connectionId: string;
+  organizationId: string;
+}): Promise<void> {
+  await upsertLinearInstallation({
+    connectionId: input.connectionId,
+    organizationId: input.organizationId,
+    organizationUrlKey: 'acme',
+    appUserId: 'app-user-1',
+    scopes: ['read', 'write'],
+    status: 'installed',
+  });
+}
+
+describe('Linear webhook route', () => {
+  beforeEach(async () => {
+    await closeApp();
+    await db().delete(linearInstallations);
+  });
+
+  afterEach(async () => {
+    await closeApp();
+  });
+
+  it('publishes a supported signed data webhook', async () => {
+    const connection = fakeConnection();
+    const {app, publishIntegrationEventReceived, recordDeliveryOnly} = await createTestApp({
+      connection,
+    });
+    const deliveryId = randomUUID();
+    const rawPayload = linearPayload({organizationId: 'org-active'});
+    await seedInstallation({connectionId: connection.id, organizationId: 'org-active'});
+    const body = JSON.stringify(rawPayload);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers: signedHeaders(body, 'Issue', deliveryId),
+      payload: body,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(recordDeliveryOnly).not.toHaveBeenCalled();
+    expect(publishIntegrationEventReceived).toHaveBeenCalledTimes(1);
+    expect(publishIntegrationEventReceived.mock.calls[0]?.[0]).toMatchObject({
+      event: {
+        provider: 'linear',
+        source: connection.slug,
+        event: 'Issue.create',
+        workspaceId: connection.workspaceId,
+        connectionId: connection.id,
+        connectionName: connection.displayName,
+        deliveryId,
+        payload: rawPayload,
+      },
+    });
+  });
+
+  it('uses the Linear-Delivery header as the delivery dedup key', async () => {
+    const connection = fakeConnection();
+    const {app, publishIntegrationEventReceived} = await createTestApp({connection});
+    const rawPayload = linearPayload({organizationId: 'org-dedup'});
+    await seedInstallation({connectionId: connection.id, organizationId: 'org-dedup'});
+    const body = JSON.stringify(rawPayload);
+
+    const first = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers: signedHeaders(body, 'Issue', 'linear-delivery-a'),
+      payload: body,
+    });
+    const second = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers: signedHeaders(body, 'Issue', 'linear-delivery-b'),
+      payload: body,
+    });
+
+    expect(first.statusCode).toBe(200);
+    expect(second.statusCode).toBe(200);
+    expect(
+      publishIntegrationEventReceived.mock.calls.map(([call]) => call.event.deliveryId),
+    ).toEqual(['linear-delivery-a', 'linear-delivery-b']);
+  });
+
+  it.each([
+    ['an assignment', {agentSession: {id: 'session-1', issueId: 'issue-1'}}],
+    [
+      'a comment mention',
+      {agentSession: {id: 'session-1', commentId: 'comment-1', sourceCommentId: 'comment-1'}},
+    ],
+  ])('publishes %s as agentSession.created', async (_context, details) => {
+    const connection = fakeConnection();
+    const {app, publishIntegrationEventReceived} = await createTestApp({connection});
+    const deliveryId = randomUUID();
+    const rawPayload = agentSessionPayload({
+      organizationId: `org-${deliveryId}`,
+      promptContext: '<issue identifier="ENG-879">Route the complete payload</issue>',
+      ...details,
+    });
+    await seedInstallation({connectionId: connection.id, organizationId: `org-${deliveryId}`});
+    const body = JSON.stringify(rawPayload);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers: signedHeaders(body, 'AgentSessionEvent', deliveryId),
+      payload: body,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(publishIntegrationEventReceived).toHaveBeenCalledWith(
+      expect.objectContaining({
+        event: expect.objectContaining({event: 'agentSession.created', payload: rawPayload}),
+      }),
+    );
+  });
+
+  it('publishes prompted AgentSessionEvent deliveries without an agent response', async () => {
+    const connection = fakeConnection();
+    const {app, publishIntegrationEventReceived} = await createTestApp({connection});
+    const deliveryId = randomUUID();
+    const rawPayload = agentSessionPayload({
+      action: 'prompted',
+      organizationId: `org-${deliveryId}`,
+      agentSession: {id: 'session-1', issueId: 'issue-1'},
+    });
+    await seedInstallation({connectionId: connection.id, organizationId: `org-${deliveryId}`});
+    const body = JSON.stringify(rawPayload);
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers: signedHeaders(body, 'AgentSessionEvent', deliveryId),
+      payload: body,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(publishIntegrationEventReceived).toHaveBeenCalledWith(
+      expect.objectContaining({event: expect.objectContaining({event: 'agentSession.prompted'})}),
+    );
+  });
+
+  it.each([
+    ['linear-delivery', 'missing Linear-Delivery header'],
+    ['linear-event', 'missing Linear-Event header'],
+    ['linear-signature', 'missing Linear-Signature header'],
+  ])('rejects requests missing the %s header', async (headerName, error) => {
+    const {app, publishIntegrationEventReceived, recordDeliveryOnly} = await createTestApp();
+    const body = JSON.stringify(linearPayload());
+    const headers = signedHeaders(body, 'Issue', randomUUID());
+    delete headers[headerName as keyof typeof headers];
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers,
+      payload: body,
+    });
+
+    expect(res.statusCode).toBe(headerName === 'linear-signature' ? 401 : 400);
+    expect(res.json()).toEqual({error});
+    expect(publishIntegrationEventReceived).not.toHaveBeenCalled();
+    expect(recordDeliveryOnly).not.toHaveBeenCalled();
+  });
+
+  it('rejects an invalid signature before publishing or recording', async () => {
+    const {app, publishIntegrationEventReceived, recordDeliveryOnly} = await createTestApp();
+    const body = JSON.stringify(linearPayload());
+    const headers = signedHeaders(body, 'Issue', randomUUID());
+    headers['linear-signature'] = 'bad-signature';
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers,
+      payload: body,
+    });
+
+    expect(res.statusCode).toBe(401);
+    expect(publishIntegrationEventReceived).not.toHaveBeenCalled();
+    expect(recordDeliveryOnly).not.toHaveBeenCalled();
+  });
+
+  it('rejects malformed JSON after signature verification', async () => {
+    const {app, publishIntegrationEventReceived, recordDeliveryOnly} = await createTestApp();
+    const body = '{"type":';
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers: signedHeaders(body, 'Issue', randomUUID()),
+      payload: body,
+    });
+
+    expect(res.statusCode).toBe(400);
+    expect(publishIntegrationEventReceived).not.toHaveBeenCalled();
+    expect(recordDeliveryOnly).not.toHaveBeenCalled();
+  });
+
+  it('records and drops signed JSON that does not match the base webhook envelope', async () => {
+    const {app, publishIntegrationEventReceived, recordDeliveryOnly, getIntegrationConnectionById} =
+      await createTestApp();
+    const deliveryId = randomUUID();
+    const body = JSON.stringify({
+      action: 'create',
+      type: 'AppUserNotification',
+      organizationId: 'org-notification',
+      webhookTimestamp: Date.now(),
+      notification: {id: 'notification-1'},
+    });
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers: signedHeaders(body, 'AppUserNotification', deliveryId),
+      payload: body,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(getIntegrationConnectionById).not.toHaveBeenCalled();
+    expect(publishIntegrationEventReceived).not.toHaveBeenCalled();
+    expect(recordDeliveryOnly).toHaveBeenCalledWith(
+      expect.objectContaining({provider: 'linear', deliveryId}),
+    );
+  });
+
+  it('rejects stale webhook timestamps before publishing or recording', async () => {
+    const {app, publishIntegrationEventReceived, recordDeliveryOnly} = await createTestApp();
+    const body = JSON.stringify(linearPayload({webhookTimestamp: Date.now() - 61_000}));
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers: signedHeaders(body, 'Issue', randomUUID()),
+      payload: body,
+    });
+
+    expect(res.statusCode).toBe(401);
+    expect(publishIntegrationEventReceived).not.toHaveBeenCalled();
+    expect(recordDeliveryOnly).not.toHaveBeenCalled();
+  });
+
+  it('rejects future webhook timestamps before publishing or recording', async () => {
+    const {app, publishIntegrationEventReceived, recordDeliveryOnly} = await createTestApp();
+    const body = JSON.stringify(linearPayload({webhookTimestamp: Date.now() + 61_000}));
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers: signedHeaders(body, 'Issue', randomUUID()),
+      payload: body,
+    });
+
+    expect(res.statusCode).toBe(401);
+    expect(publishIntegrationEventReceived).not.toHaveBeenCalled();
+    expect(recordDeliveryOnly).not.toHaveBeenCalled();
+  });
+
+  it('records and drops when the Linear-Event header disagrees with the signed payload type', async () => {
+    const {app, publishIntegrationEventReceived, recordDeliveryOnly} = await createTestApp();
+    const deliveryId = randomUUID();
+    const body = JSON.stringify(linearPayload({type: 'Issue'}));
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers: signedHeaders(body, 'Comment', deliveryId),
+      payload: body,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(publishIntegrationEventReceived).not.toHaveBeenCalled();
+    expect(recordDeliveryOnly).toHaveBeenCalledWith(
+      expect.objectContaining({provider: 'linear', deliveryId}),
+    );
+  });
+
+  it('records and drops a signed webhook for an unknown organization', async () => {
+    const {app, publishIntegrationEventReceived, recordDeliveryOnly, getIntegrationConnectionById} =
+      await createTestApp();
+    const deliveryId = randomUUID();
+    const body = JSON.stringify(linearPayload({organizationId: 'org-missing'}));
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers: signedHeaders(body, 'Issue', deliveryId),
+      payload: body,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(getIntegrationConnectionById).not.toHaveBeenCalled();
+    expect(publishIntegrationEventReceived).not.toHaveBeenCalled();
+    expect(recordDeliveryOnly).toHaveBeenCalledWith(
+      expect.objectContaining({provider: 'linear', deliveryId}),
+    );
+  });
+
+  it('records and drops signed unsupported resource events', async () => {
+    const connection = fakeConnection();
+    const {app, publishIntegrationEventReceived, recordDeliveryOnly} = await createTestApp({
+      connection,
+    });
+    const deliveryId = randomUUID();
+    await seedInstallation({connectionId: connection.id, organizationId: 'org-reaction'});
+    const body = JSON.stringify(linearPayload({organizationId: 'org-reaction', type: 'Reaction'}));
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/linear',
+      headers: signedHeaders(body, 'Reaction', deliveryId),
+      payload: body,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(publishIntegrationEventReceived).not.toHaveBeenCalled();
+    expect(recordDeliveryOnly).toHaveBeenCalledWith(
+      expect.objectContaining({provider: 'linear', deliveryId}),
+    );
+  });
+});

package/src/presentation/routes/webhooks.ts

@@ -0,0 +1,154 @@
+import {Buffer} from 'node:buffer';
+import type {
+  GetIntegrationConnectionByIdFn,
+  IntegrationTx,
+  PublishIntegrationEventReceivedFn,
+  RecordDeliveryOnlyFn,
+} from '@shipfox/api-integration-core-dto';
+import {
+  LINEAR_PROVIDER,
+  linearWebhookBaseEnvelopeSchema,
+} from '@shipfox/api-integration-linear-dto';
+import {
+  defineRoute,
+  type RouteGroup,
+  rawBodyPlugin,
+  verifyHexHmacSignature,
+  WEBHOOK_BODY_LIMIT,
+} from '@shipfox/node-fastify';
+import {logger} from '@shipfox/node-opentelemetry';
+import type {NodePgDatabase} from 'drizzle-orm/node-postgres';
+import {config} from '#config.js';
+import {handleLinearWebhook} from '#core/webhook.js';
+
+const DELIVERY_HEADER = 'linear-delivery';
+const EVENT_HEADER = 'linear-event';
+const SIGNATURE_HEADER = 'linear-signature';
+const WEBHOOK_REPLAY_WINDOW_MS = 60_000;
+
+export interface CreateLinearWebhookRoutesOptions {
+  coreDb: () => NodePgDatabase<Record<string, unknown>>;
+  publishIntegrationEventReceived: PublishIntegrationEventReceivedFn;
+  recordDeliveryOnly: RecordDeliveryOnlyFn;
+  getIntegrationConnectionById: GetIntegrationConnectionByIdFn;
+}
+
+export function createLinearWebhookRoutes(options: CreateLinearWebhookRoutesOptions): RouteGroup {
+  const webhookRoute = defineRoute({
+    method: 'POST',
+    path: '/',
+    auth: [],
+    description: 'Linear webhook receiver.',
+    options: {bodyLimit: WEBHOOK_BODY_LIMIT},
+    handler: async (request, reply) => {
+      const deliveryHeader = request.headers[DELIVERY_HEADER];
+      const event = request.headers[EVENT_HEADER];
+      const signature = request.headers[SIGNATURE_HEADER];
+
+      if (typeof deliveryHeader !== 'string' || !deliveryHeader) {
+        reply.code(400);
+        return {error: 'missing Linear-Delivery header'};
+      }
+      if (typeof event !== 'string' || !event) {
+        reply.code(400);
+        return {error: 'missing Linear-Event header'};
+      }
+      if (typeof signature !== 'string' || !signature) {
+        reply.code(401);
+        return {error: 'missing Linear-Signature header'};
+      }
+
+      const body = request.body;
+      if (!Buffer.isBuffer(body)) {
+        reply.code(400);
+        return {error: 'expected raw JSON body'};
+      }
+      const rawBody = body.toString('utf8');
+
+      if (
+        !verifyHexHmacSignature({
+          rawBody,
+          signature,
+          secret: config.LINEAR_WEBHOOK_SIGNING_SECRET,
+        })
+      ) {
+        reply.code(401);
+        return {error: 'invalid signature'};
+      }
+
+      let parsedJson: unknown;
+      try {
+        parsedJson = JSON.parse(rawBody);
+      } catch (error) {
+        logger().warn(
+          {deliveryId: deliveryHeader, err: error},
+          'linear webhook payload JSON parse failed',
+        );
+        reply.code(400);
+        return {error: 'malformed JSON'};
+      }
+
+      const payload = linearWebhookBaseEnvelopeSchema.safeParse(parsedJson);
+      if (!payload.success) {
+        logger().warn(
+          {deliveryId: deliveryHeader, issues: payload.error.issues},
+          'linear webhook envelope failed schema validation',
+        );
+        await recordSignedDeliveryOnly(options, deliveryHeader);
+        reply.code(200);
+        return null;
+      }
+
+      if (Math.abs(Date.now() - payload.data.webhookTimestamp) > WEBHOOK_REPLAY_WINDOW_MS) {
+        reply.code(401);
+        return {error: 'stale webhook timestamp'};
+      }
+
+      if (event !== payload.data.type) {
+        logger().warn(
+          {deliveryId: deliveryHeader, event, type: payload.data.type},
+          'linear webhook event header did not match payload type',
+        );
+        await recordSignedDeliveryOnly(options, deliveryHeader);
+        reply.code(200);
+        return null;
+      }
+
+      await options.coreDb().transaction(async (tx) => {
+        await handleLinearWebhook({
+          tx,
+          // Linear documents this header as the delivery UUID; the signed timestamp is per-send.
+          deliveryId: deliveryHeader,
+          payload: payload.data,
+          rawPayload: parsedJson,
+          publishIntegrationEventReceived: options.publishIntegrationEventReceived,
+          recordDeliveryOnly: options.recordDeliveryOnly,
+          getIntegrationConnectionById: options.getIntegrationConnectionById,
+        });
+      });
+
+      reply.code(200);
+      return null;
+    },
+  });
+
+  return {
+    prefix: '/webhooks/integrations/linear',
+    auth: [],
+    plugins: [rawBodyPlugin],
+    routes: [webhookRoute],
+  };
+}
+
+async function recordSignedDeliveryOnly(
+  options: Pick<CreateLinearWebhookRoutesOptions, 'coreDb' | 'recordDeliveryOnly'>,
+  deliveryId: string,
+): Promise<void> {
+  await options.coreDb().transaction(async (tx: IntegrationTx) => {
+    await options.recordDeliveryOnly({
+      tx,
+      provider: LINEAR_PROVIDER,
+      deliveryId,
+    });
+  });
+}

package/test/api-secrets.d.ts

@@ -0,0 +1,28 @@
+declare module '@shipfox/api-secrets' {
+  import type {NodePgDatabase} from '@shipfox/node-drizzle';
+
+  export function getSecret(params: {
+    workspaceId: string;
+    namespace: string;
+    key: string;
+  }): Promise<string | null>;
+
+  export function setSecrets(params: {
+    workspaceId: string;
+    namespace: string;
+    values: Record<string, string>;
+    editedBy?: string | null | undefined;
+  }): Promise<void>;
+
+  export function deleteSecrets(params: {workspaceId: string; namespace: string}): Promise<number>;
+
+  export const secretsModule: {
+    database?:
+      | {
+          db(): NodePgDatabase<Record<string, unknown>>;
+          migrationsPath: string;
+        }
+      | unknown[]
+      | undefined;
+  };
+}

package/test/env.ts

@@ -0,0 +1,13 @@
+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.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 = 'http://127.0.0.1:0/mcp';
+process.env.SECRETS_ENCRYPTION_KEK = 'ZmVkY2JhOTg3NjU0MzIxMGZlZGNiYTk4NzY1NDMyMTA=';

package/test/factories/index.ts

@@ -0,0 +1 @@
+export {};

package/test/globalSetup.ts

@@ -0,0 +1,23 @@
+import './env.js';
+import {runMigrations} from '@shipfox/node-drizzle';
+import {closePostgresClient, createPostgresClient} from '@shipfox/node-postgres';
+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_linear');
+  const {secretsModule} = await import('@shipfox/api-secrets');
+  if (!secretsModule.database || Array.isArray(secretsModule.database)) {
+    throw new Error('Secrets module database is not configured');
+  }
+  await runMigrations(
+    secretsModule.database.db(),
+    secretsModule.database.migrationsPath,
+    '__drizzle_migrations_secrets',
+  );
+
+  closeDb();
+  await closePostgresClient();
+}

package/test/index.ts

@@ -0,0 +1 @@
+export * from './factories/index.js';

package/test/setup.ts

@@ -0,0 +1,17 @@
+import './env.js';
+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();
+  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"]
+}