@shipfox/api-integration-jira 12.1.0 → 12.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-integration-jira",
   "license": "MIT",
-  "version": "12.1.0",
+  "version": "12.2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -27,15 +27,15 @@
     "drizzle-orm": "^0.45.2",
     "ky": "^2.0.0",
     "zod": "^4.4.3",
-    "@shipfox/api-auth-context": "12.0.0",
-    "@shipfox/api-integration-spi": "1.0.0",
-    "@shipfox/api-integration-jira-dto": "12.0.0",
+    "@shipfox/api-auth-context": "12.2.0",
+    "@shipfox/api-integration-spi": "1.0.1",
+    "@shipfox/api-integration-jira-dto": "12.2.0",
     "@shipfox/config": "1.2.4",
     "@shipfox/node-drizzle": "0.3.5",
-    "@shipfox/node-fastify": "0.4.1",
+    "@shipfox/node-fastify": "0.4.2",
     "@shipfox/node-jwt": "0.4.0",
-    "@shipfox/node-module": "1.0.5",
-    "@shipfox/node-opentelemetry": "0.6.3",
+    "@shipfox/node-module": "1.0.6",
+    "@shipfox/node-opentelemetry": "0.6.4",
     "@shipfox/node-postgres": "0.5.0"
   },
   "imports": {

package/src/api/client.test.ts

@@ -2,7 +2,18 @@ import {HTTPError} from 'ky';
 import type {JiraIntegrationProviderError} from '#core/errors.js';
 import {mapJiraError} from './client.js';
 
-const mocks = vi.hoisted(() => ({delete: vi.fn(), post: vi.fn(), request: vi.fn()}));
+const mocks = vi.hoisted(() => ({
+  delete: vi.fn(),
+  post: vi.fn(),
+  request: vi.fn(),
+  warn: vi.fn(),
+}));
+
+vi.mock('@shipfox/node-opentelemetry', () => ({
+  logger: () => ({
+    warn: mocks.warn,
+  }),
+}));
 
 vi.mock('ky', () => {
   class MockHTTPError extends Error {
@@ -77,6 +88,7 @@ describe('Jira dynamic webhook API', () => {
     mocks.delete.mockReset();
     mocks.post.mockReset();
     mocks.request.mockReset();
+    mocks.warn.mockReset();
   });
 
   it('registers the six curated events with the access token', async () => {
@@ -133,6 +145,165 @@ describe('Jira dynamic webhook API', () => {
     ).rejects.toMatchObject({reason: 'malformed-provider-response'});
   });
 
+  it('logs provider validation errors before rejecting registration', async () => {
+    mocks.post.mockReturnValue(
+      resolves({
+        webhookRegistrationResult: [
+          {createdWebhookId: 123, errors: ['Webhook URL is not approved', 'Invalid JQL filter']},
+        ],
+      }),
+    );
+    const {createJiraApiClient} = await import('./client.js');
+
+    await expect(
+      createJiraApiClient().registerDynamicWebhook({
+        accessToken: 'access-token',
+        cloudId: 'cloud-1',
+        url: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+      }),
+    ).rejects.toMatchObject({reason: 'malformed-provider-response'});
+
+    expect(mocks.warn).toHaveBeenCalledTimes(1);
+    expect(mocks.warn).toHaveBeenCalledWith(
+      {
+        operation: 'register-dynamic-webhook',
+        providerErrors: ['Webhook URL is not approved', 'Invalid JQL filter'],
+        providerErrorCount: 2,
+      },
+      'Jira dynamic webhook registration rejected',
+    );
+  });
+
+  it('limits logged provider errors to five values', async () => {
+    mocks.post.mockReturnValue(
+      resolves({
+        webhookRegistrationResult: [
+          {
+            errors: ['one', 'two', 'three', 'four', 'five', 'six'],
+          },
+        ],
+      }),
+    );
+    const {createJiraApiClient} = await import('./client.js');
+
+    await expect(
+      createJiraApiClient().registerDynamicWebhook({
+        accessToken: 'access-token',
+        cloudId: 'cloud-1',
+        url: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+      }),
+    ).rejects.toMatchObject({reason: 'malformed-provider-response'});
+
+    expect(mocks.warn).toHaveBeenCalledWith(
+      {
+        operation: 'register-dynamic-webhook',
+        providerErrors: ['one', 'two', 'three', 'four', 'five'],
+        providerErrorCount: 6,
+      },
+      'Jira dynamic webhook registration rejected',
+    );
+  });
+
+  it('limits each logged provider error to 500 characters', async () => {
+    const longError = 'x'.repeat(501);
+    mocks.post.mockReturnValue(resolves({webhookRegistrationResult: [{errors: [longError]}]}));
+    const {createJiraApiClient} = await import('./client.js');
+
+    await expect(
+      createJiraApiClient().registerDynamicWebhook({
+        accessToken: 'access-token',
+        cloudId: 'cloud-1',
+        url: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+      }),
+    ).rejects.toMatchObject({reason: 'malformed-provider-response'});
+
+    expect(mocks.warn).toHaveBeenCalledWith(
+      {
+        operation: 'register-dynamic-webhook',
+        providerErrors: ['x'.repeat(500)],
+        providerErrorCount: 1,
+      },
+      'Jira dynamic webhook registration rejected',
+    );
+  });
+
+  it('omits non-string provider errors from the warning', async () => {
+    mocks.post.mockReturnValue(
+      resolves({
+        webhookRegistrationResult: [
+          {errors: ['valid message', 42, null, {message: 'raw response'}, true]},
+        ],
+      }),
+    );
+    const {createJiraApiClient} = await import('./client.js');
+
+    await expect(
+      createJiraApiClient().registerDynamicWebhook({
+        accessToken: 'access-token',
+        cloudId: 'cloud-1',
+        url: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+      }),
+    ).rejects.toMatchObject({reason: 'malformed-provider-response'});
+
+    expect(mocks.warn).toHaveBeenCalledWith(
+      {
+        operation: 'register-dynamic-webhook',
+        providerErrors: ['valid message'],
+        providerErrorCount: 5,
+      },
+      'Jira dynamic webhook registration rejected',
+    );
+  });
+
+  it('accepts an empty provider errors array without logging a rejection', async () => {
+    mocks.post.mockReturnValue(
+      resolves({webhookRegistrationResult: [{createdWebhookId: 123, errors: []}]}),
+    );
+    const {createJiraApiClient} = await import('./client.js');
+
+    await expect(
+      createJiraApiClient().registerDynamicWebhook({
+        accessToken: 'access-token',
+        cloudId: 'cloud-1',
+        url: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+      }),
+    ).resolves.toEqual({webhookId: 123});
+    expect(mocks.warn).not.toHaveBeenCalled();
+  });
+
+  it('rejects a non-array provider errors value without logging it', async () => {
+    mocks.post.mockReturnValue(
+      resolves({
+        webhookRegistrationResult: [{createdWebhookId: 123, errors: {message: 'do not log me'}}],
+      }),
+    );
+    const {createJiraApiClient} = await import('./client.js');
+
+    await expect(
+      createJiraApiClient().registerDynamicWebhook({
+        accessToken: 'access-token',
+        cloudId: 'cloud-1',
+        url: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+      }),
+    ).rejects.toMatchObject({reason: 'malformed-provider-response'});
+    expect(mocks.warn).not.toHaveBeenCalled();
+  });
+
+  it('keeps the malformed provider response reason for a Jira rejection', async () => {
+    mocks.post.mockReturnValue(
+      resolves({webhookRegistrationResult: [{errors: ['Provider rejected the webhook']}]}),
+    );
+    const {createJiraApiClient} = await import('./client.js');
+
+    await expect(
+      createJiraApiClient().registerDynamicWebhook({
+        accessToken: 'access-token',
+        cloudId: 'cloud-1',
+        url: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+      }),
+    ).rejects.toMatchObject({reason: 'malformed-provider-response'});
+  });
+
   it('deletes a dynamic webhook by id', async () => {
     mocks.delete.mockResolvedValue(undefined);
     const {createJiraApiClient} = await import('./client.js');

package/src/api/client.ts

@@ -282,7 +282,21 @@ function parseDynamicWebhookRegistration(
     createdWebhookId?: unknown;
     errors?: unknown;
   };
-  if (errors !== undefined && (!Array.isArray(errors) || errors.length > 0)) {
+  if (errors !== undefined && !Array.isArray(errors)) {
+    throw malformed('Jira webhook registration returned errors');
+  }
+  if (Array.isArray(errors) && errors.length > 0) {
+    logger().warn(
+      {
+        operation: 'register-dynamic-webhook',
+        providerErrors: errors
+          .filter((error): error is string => typeof error === 'string')
+          .slice(0, 5)
+          .map((error) => error.slice(0, 500)),
+        providerErrorCount: errors.length,
+      },
+      'Jira dynamic webhook registration rejected',
+    );
     throw malformed('Jira webhook registration returned errors');
   }
   if (

package/src/index.test.ts

@@ -31,6 +31,17 @@ describe('createJiraIntegrationProvider', () => {
       }),
     ).toThrow('requires all webhook receiver dependencies');
   });
+
+  it('exposes explicit connection cleanup without requiring routes', () => {
+    const deleteConnectionRecords = vi.fn(() => Promise.resolve());
+    const deleteConnectionSecrets = vi.fn(() => Promise.resolve());
+    const provider = createJiraIntegrationProvider({
+      cleanup: {deleteConnectionRecords, deleteConnectionSecrets},
+    });
+
+    expect(provider.deleteConnectionRecords).toBe(deleteConnectionRecords);
+    expect(provider.deleteConnectionSecrets).toBe(deleteConnectionSecrets);
+  });
 });
 
 describe('createJiraMaintenanceWorker', () => {

package/src/index.ts

@@ -126,6 +126,7 @@ export {
   updateJiraInstallationWebhook,
   upsertJiraInstallation,
   withJiraRefreshLock,
+  withJiraRefreshLockAndWait,
   withJiraWebhookRegistrationLock,
 } from '#db/installations.js';
 export type {CreateJiraWebhookRoutesOptions} from '#presentation/routes/webhooks.js';
@@ -142,6 +143,15 @@ export interface CreateJiraIntegrationProviderOptions {
       }
     | undefined;
   getJiraInstallationByConnectionId?: typeof getJiraInstallationByConnectionId | undefined;
+  cleanup?:
+    | {
+        deleteConnectionRecords?: (
+          connection: {id: string},
+          options: {tx: unknown},
+        ) => Promise<void>;
+        deleteConnectionSecrets?: (connection: {id: string; workspaceId: string}) => Promise<void>;
+      }
+    | undefined;
   routes?: JiraIntegrationProviderRoutesOptions | undefined;
 }
 
@@ -210,6 +220,7 @@ export function createJiraIntegrationProvider(options: CreateJiraIntegrationProv
     async connectionExternalUrl(connection: {id: string}): Promise<string | undefined> {
       return (await getInstallationByConnectionId(connection.id))?.siteUrl;
     },
+    ...options.cleanup,
     routes,
     webhookProcessors: webhookProcessor
       ? [{routeIds: ['jira'] as const, processor: webhookProcessor}]