@shipfox/api-integration-jira 10.2.0 → 12.0.0

package/src/core/webhook-registration.test.ts

@@ -0,0 +1,375 @@
+import {JIRA_WEBHOOK_TTL_MS, registerJiraWebhook} from './webhook-registration.js';
+
+const runInlineRegistrationLock = <T>(_lockKey: string, fn: () => Promise<T>) => fn();
+
+describe('registerJiraWebhook', () => {
+  it('persists the returned id with a 30-day expiry', async () => {
+    const registerDynamicWebhook = vi.fn().mockResolvedValue({webhookId: 123});
+    const deleteDynamicWebhook = vi.fn().mockResolvedValue(undefined);
+    const updateInstallation = vi.fn().mockResolvedValue({id: 'installation-1'});
+    const getInstallation = vi.fn().mockResolvedValue(undefined);
+    const now = new Date('2030-01-01T00:00:00.000Z');
+
+    const result = await registerJiraWebhook({
+      jira: {registerDynamicWebhook, deleteDynamicWebhook},
+      connectionId: 'connection-1',
+      cloudId: 'cloud-1',
+      accessToken: 'access-token',
+      webhookUrl: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+      now: () => now,
+      getInstallation,
+      updateInstallation,
+      withRegistrationLock: (_lockKey, fn) => fn(),
+    });
+
+    expect(registerDynamicWebhook).toHaveBeenCalledWith({
+      accessToken: 'access-token',
+      cloudId: 'cloud-1',
+      url: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+    });
+    expect(getInstallation).toHaveBeenCalledWith('connection-1');
+    expect(updateInstallation).toHaveBeenCalledWith({
+      connectionId: 'connection-1',
+      webhookIds: [123],
+      webhookExpiresAt: new Date(now.getTime() + JIRA_WEBHOOK_TTL_MS),
+    });
+    expect(result.webhookId).toBe(123);
+    expect(deleteDynamicWebhook).not.toHaveBeenCalled();
+  });
+
+  it('deletes the remote webhook when local metadata persistence fails', async () => {
+    const registerDynamicWebhook = vi.fn().mockResolvedValue({webhookId: 456});
+    const deleteDynamicWebhook = vi.fn().mockResolvedValue(undefined);
+    const persistenceError = new Error('database unavailable');
+
+    await expect(
+      registerJiraWebhook({
+        jira: {registerDynamicWebhook, deleteDynamicWebhook},
+        connectionId: 'connection-1',
+        cloudId: 'cloud-1',
+        accessToken: 'access-token',
+        webhookUrl: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+        getInstallation: vi.fn().mockResolvedValue(undefined),
+        updateInstallation: vi.fn().mockRejectedValue(persistenceError),
+        withRegistrationLock: runInlineRegistrationLock,
+      }),
+    ).rejects.toBe(persistenceError);
+
+    expect(deleteDynamicWebhook).toHaveBeenCalledWith({
+      accessToken: 'access-token',
+      cloudId: 'cloud-1',
+      webhookId: 456,
+    });
+  });
+
+  it('does not mask the metadata error when remote cleanup fails', async () => {
+    const persistenceError = new Error('database unavailable');
+    const cleanupError = new Error('provider unavailable');
+
+    await expect(
+      registerJiraWebhook({
+        jira: {
+          registerDynamicWebhook: vi.fn().mockResolvedValue({webhookId: 789}),
+          deleteDynamicWebhook: vi.fn().mockRejectedValue(cleanupError),
+        },
+        connectionId: 'connection-1',
+        cloudId: 'cloud-1',
+        accessToken: 'access-token',
+        webhookUrl: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+        getInstallation: vi.fn().mockResolvedValue(undefined),
+        updateInstallation: vi.fn().mockRejectedValue(persistenceError),
+        withRegistrationLock: runInlineRegistrationLock,
+      }),
+    ).rejects.toBe(persistenceError);
+  });
+
+  it('compensates and restores metadata when activation rejects', async () => {
+    const activationError = new Error('connection status update failed');
+    const previousExpiry = new Date('2030-01-01T00:00:00.000Z');
+    const updateInstallation = vi
+      .fn()
+      .mockResolvedValueOnce({id: 'installation-1'})
+      .mockResolvedValueOnce({id: 'installation-1'});
+    const deleteDynamicWebhook = vi.fn().mockResolvedValue(undefined);
+
+    await expect(
+      registerJiraWebhook({
+        jira: {
+          registerDynamicWebhook: vi.fn().mockResolvedValue({webhookId: 456}),
+          deleteDynamicWebhook,
+        },
+        connectionId: 'connection-1',
+        cloudId: 'cloud-1',
+        accessToken: 'access-token',
+        webhookUrl: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+        getInstallation: vi.fn().mockResolvedValue({
+          webhookIds: [123],
+          webhookExpiresAt: previousExpiry,
+        }),
+        updateInstallation,
+        withRegistrationLock: runInlineRegistrationLock,
+        onRegistrationSuccess: vi.fn().mockRejectedValue(activationError),
+      }),
+    ).rejects.toBe(activationError);
+
+    expect(deleteDynamicWebhook).toHaveBeenCalledWith({
+      accessToken: 'access-token',
+      cloudId: 'cloud-1',
+      webhookId: 456,
+    });
+    expect(updateInstallation).toHaveBeenNthCalledWith(2, {
+      connectionId: 'connection-1',
+      webhookIds: [123],
+      webhookExpiresAt: previousExpiry,
+    });
+  });
+
+  it('compensates after the lock wrapper rejects while committing a successful registration', async () => {
+    const commitError = new Error('transaction commit failed');
+    const previousExpiry = new Date('2030-01-01T00:00:00.000Z');
+    const updateInstallation = vi
+      .fn()
+      .mockResolvedValueOnce({id: 'installation-1'})
+      .mockResolvedValueOnce({id: 'installation-1'});
+    const deleteDynamicWebhook = vi.fn().mockResolvedValue(undefined);
+    const withRegistrationLock = async <T>(_lockKey: string, fn: () => Promise<T>) => {
+      await fn();
+      throw commitError;
+    };
+
+    await expect(
+      registerJiraWebhook({
+        jira: {
+          registerDynamicWebhook: vi.fn().mockResolvedValue({webhookId: 789}),
+          deleteDynamicWebhook,
+        },
+        connectionId: 'connection-1',
+        cloudId: 'cloud-1',
+        accessToken: 'access-token',
+        webhookUrl: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+        getInstallation: vi.fn().mockResolvedValue({
+          webhookIds: [123],
+          webhookExpiresAt: previousExpiry,
+        }),
+        updateInstallation,
+        withRegistrationLock,
+      }),
+    ).rejects.toBe(commitError);
+
+    expect(deleteDynamicWebhook).toHaveBeenCalledWith({
+      accessToken: 'access-token',
+      cloudId: 'cloud-1',
+      webhookId: 789,
+    });
+    expect(deleteDynamicWebhook).toHaveBeenCalledTimes(1);
+    expect(updateInstallation).toHaveBeenNthCalledWith(2, {
+      connectionId: 'connection-1',
+      webhookIds: [123],
+      webhookExpiresAt: previousExpiry,
+    });
+  });
+
+  it('runs the error-state transition before releasing the registration lock', async () => {
+    let lockCallbackCompleted = false;
+    const withRegistrationLock = async <T>(_lockKey: string, fn: () => Promise<T>) => {
+      try {
+        return await fn();
+      } finally {
+        lockCallbackCompleted = true;
+      }
+    };
+    const onRegistrationFailure = vi.fn().mockResolvedValue(undefined);
+
+    await expect(
+      registerJiraWebhook({
+        jira: {
+          registerDynamicWebhook: vi.fn().mockRejectedValue(new Error('provider unavailable')),
+          deleteDynamicWebhook: vi.fn(),
+        },
+        connectionId: 'connection-1',
+        cloudId: 'cloud-1',
+        accessToken: 'access-token',
+        webhookUrl: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+        getInstallation: vi.fn().mockResolvedValue(undefined),
+        updateInstallation: vi.fn(),
+        withRegistrationLock,
+        onRegistrationFailure,
+      }),
+    ).rejects.toThrow('provider unavailable');
+
+    expect(lockCallbackCompleted).toBe(true);
+    expect(onRegistrationFailure).toHaveBeenCalledWith({});
+  });
+
+  it('persists the replacement before deleting all superseded remote webhooks', async () => {
+    const calls: string[] = [];
+    const updateInstallation = vi.fn().mockImplementation(() => {
+      calls.push('persist');
+      return Promise.resolve({id: 'installation-1'});
+    });
+    const deleteDynamicWebhook = vi.fn().mockImplementation(({webhookId}) => {
+      calls.push(`delete:${webhookId}`);
+      return Promise.resolve();
+    });
+    const result = await registerJiraWebhook({
+      jira: {
+        registerDynamicWebhook: vi.fn().mockImplementation(() => {
+          calls.push('register');
+          return Promise.resolve({webhookId: 456});
+        }),
+        deleteDynamicWebhook,
+      },
+      connectionId: 'connection-1',
+      cloudId: 'cloud-1',
+      accessToken: 'access-token',
+      webhookUrl: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+      getInstallation: vi.fn().mockResolvedValue({webhookIds: [123, 234]}),
+      updateInstallation,
+      withRegistrationLock: runInlineRegistrationLock,
+    });
+
+    expect(result.webhookId).toBe(456);
+    expect(calls).toEqual(['register', 'persist', 'delete:123', 'delete:234', 'persist']);
+    expect(updateInstallation).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({webhookIds: [456, 123, 234]}),
+    );
+    expect(updateInstallation).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({webhookIds: [456]}),
+    );
+    expect(deleteDynamicWebhook).toHaveBeenCalledTimes(2);
+  });
+
+  it('retains failed superseded webhook cleanup ids for a later retry', async () => {
+    const deleteDynamicWebhook = vi
+      .fn()
+      .mockImplementation(({webhookId}) =>
+        webhookId === 234 ? Promise.reject(new Error('provider unavailable')) : Promise.resolve(),
+      );
+    const updateInstallation = vi
+      .fn()
+      .mockResolvedValueOnce({id: 'installation-1'})
+      .mockResolvedValueOnce({id: 'installation-1'});
+
+    await expect(
+      registerJiraWebhook({
+        jira: {
+          registerDynamicWebhook: vi.fn().mockResolvedValue({webhookId: 456}),
+          deleteDynamicWebhook,
+        },
+        connectionId: 'connection-1',
+        cloudId: 'cloud-1',
+        accessToken: 'access-token',
+        webhookUrl: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+        getInstallation: vi.fn().mockResolvedValue({webhookIds: [123, 234]}),
+        updateInstallation,
+        withRegistrationLock: runInlineRegistrationLock,
+      }),
+    ).resolves.toMatchObject({webhookId: 456});
+
+    expect(updateInstallation).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({webhookIds: [456, 234]}),
+    );
+    expect(deleteDynamicWebhook).toHaveBeenCalledTimes(2);
+  });
+
+  it('keeps conservative metadata when failed cleanup cannot be persisted', async () => {
+    const updateInstallation = vi
+      .fn()
+      .mockResolvedValueOnce({id: 'installation-1'})
+      .mockRejectedValueOnce(new Error('database unavailable'));
+
+    await expect(
+      registerJiraWebhook({
+        jira: {
+          registerDynamicWebhook: vi.fn().mockResolvedValue({webhookId: 456}),
+          deleteDynamicWebhook: vi
+            .fn()
+            .mockImplementation(({webhookId}) =>
+              webhookId === 234
+                ? Promise.reject(new Error('provider unavailable'))
+                : Promise.resolve(),
+            ),
+        },
+        connectionId: 'connection-1',
+        cloudId: 'cloud-1',
+        accessToken: 'access-token',
+        webhookUrl: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+        getInstallation: vi.fn().mockResolvedValue({webhookIds: [123, 234]}),
+        updateInstallation,
+        withRegistrationLock: runInlineRegistrationLock,
+      }),
+    ).resolves.toMatchObject({webhookId: 456});
+
+    expect(updateInstallation).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({webhookIds: [456, 123, 234]}),
+    );
+  });
+
+  it('serializes concurrent replacement and lifecycle transitions per connection', async () => {
+    let releaseFirstRegistration!: (error: Error) => void;
+    const firstRegistration = new Promise<never>((_, reject) => {
+      releaseFirstRegistration = reject;
+    });
+    const registration = vi
+      .fn()
+      .mockReturnValueOnce(firstRegistration)
+      .mockResolvedValueOnce({webhookId: 456});
+    const updateInstallation = vi.fn().mockResolvedValue({id: 'installation-1'});
+    const events: string[] = [];
+    let lockTail = Promise.resolve();
+    const withRegistrationLock = async <T>(_lockKey: string, fn: () => Promise<T>) => {
+      const predecessor = lockTail;
+      let release!: () => void;
+      lockTail = new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      await predecessor;
+      try {
+        return await fn();
+      } finally {
+        release();
+      }
+    };
+
+    const common = {
+      jira: {
+        registerDynamicWebhook: registration,
+        deleteDynamicWebhook: vi.fn().mockResolvedValue(undefined),
+      },
+      connectionId: 'connection-1',
+      cloudId: 'cloud-1',
+      accessToken: 'access-token',
+      webhookUrl: 'https://shipfox.example.com/webhooks/integrations/jira/connection-1',
+      getInstallation: vi.fn().mockResolvedValue(undefined),
+      updateInstallation,
+      withRegistrationLock,
+    };
+
+    const first = registerJiraWebhook({
+      ...common,
+      onRegistrationFailure: () => {
+        events.push('first-failure');
+        return Promise.resolve();
+      },
+    });
+    const second = registerJiraWebhook({
+      ...common,
+      onRegistrationSuccess: () => {
+        events.push('second-success');
+        return Promise.resolve();
+      },
+    });
+
+    await vi.waitFor(() => expect(registration).toHaveBeenCalledOnce());
+    releaseFirstRegistration(new Error('first registration failed'));
+
+    await expect(first).rejects.toThrow('first registration failed');
+    await expect(second).resolves.toMatchObject({webhookId: 456});
+    expect(events).toEqual(['first-failure', 'second-success']);
+    expect(updateInstallation).toHaveBeenCalledOnce();
+  });
+});

package/src/core/webhook-registration.ts

@@ -0,0 +1,216 @@
+import {logger} from '@shipfox/node-opentelemetry';
+import type {JiraApiClient} from '#api/client.js';
+import {
+  getJiraInstallationByConnectionId,
+  type JiraInstallationLock,
+  updateJiraInstallationWebhook,
+  withJiraInstallationLock,
+} from '#db/installations.js';
+
+export const JIRA_WEBHOOK_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+
+export interface RegisterJiraWebhookParams {
+  jira: Pick<JiraApiClient, 'registerDynamicWebhook' | 'deleteDynamicWebhook'>;
+  connectionId: string;
+  cloudId: string;
+  accessToken: string;
+  webhookUrl: string;
+  now?: () => Date;
+  getInstallation?: typeof getJiraInstallationByConnectionId;
+  updateInstallation?: typeof updateJiraInstallationWebhook;
+  withRegistrationLock?: JiraInstallationLock;
+  onRegistrationSuccess?: (input: {tx?: unknown}) => Promise<void>;
+  onRegistrationFailure?: (input: {tx?: unknown}) => Promise<void>;
+}
+
+/** Register Jira's curated webhook and replace local metadata as one serialized state transition. */
+export async function registerJiraWebhook(
+  params: RegisterJiraWebhookParams,
+): Promise<{webhookId: number; webhookExpiresAt: Date}> {
+  const withRegistrationLock = params.withRegistrationLock ?? withJiraInstallationLock;
+  let callbackFailed = false;
+  let registeredWebhookId: number | undefined;
+  let previous: Awaited<ReturnType<typeof getJiraInstallationByConnectionId>>;
+  let metadataPersisted = false;
+  let cleanupSupersededWebhooks: (() => Promise<void>) | undefined;
+  let result: {webhookId: number; webhookExpiresAt: Date};
+  try {
+    result = await withRegistrationLock(params.cloudId, async () => {
+      try {
+        const getInstallation = params.getInstallation ?? getJiraInstallationByConnectionId;
+        previous = await getInstallation(params.connectionId);
+        const registration = await params.jira.registerDynamicWebhook({
+          accessToken: params.accessToken,
+          cloudId: params.cloudId,
+          url: params.webhookUrl,
+        });
+        registeredWebhookId = registration.webhookId;
+        const now = params.now ?? (() => new Date());
+        const webhookExpiresAt = new Date(now().getTime() + JIRA_WEBHOOK_TTL_MS);
+
+        const updateInstallation = params.updateInstallation ?? updateJiraInstallationWebhook;
+        const updateInput = {
+          connectionId: params.connectionId,
+          webhookIds: [...new Set([registration.webhookId, ...(previous?.webhookIds ?? [])])],
+          webhookExpiresAt,
+        };
+        const installation = await updateInstallation(updateInput);
+        if (!installation)
+          throw new Error('Jira webhook registration lost its installation record');
+        metadataPersisted = true;
+        await params.onRegistrationSuccess?.({});
+
+        cleanupSupersededWebhooks = () =>
+          finishSupersededWebhookCleanup(
+            params,
+            previous,
+            registration.webhookId,
+            webhookExpiresAt,
+          );
+        return {webhookId: registration.webhookId, webhookExpiresAt};
+      } catch (error) {
+        callbackFailed = true;
+        if (registeredWebhookId !== undefined) {
+          const deleted = await deleteNewWebhookAfterPersistenceFailure(
+            params,
+            registeredWebhookId,
+          );
+          if (metadataPersisted || !deleted) {
+            await restorePreviousWebhookMetadata(
+              params,
+              previous,
+              deleted ? undefined : registeredWebhookId,
+            );
+          }
+        } else if (metadataPersisted) {
+          await restorePreviousWebhookMetadata(params, previous);
+        }
+        await bestEffortRegistrationFailure(params);
+        throw error;
+      }
+    });
+  } catch (error) {
+    if (!callbackFailed) {
+      if (registeredWebhookId !== undefined) {
+        const deleted = await deleteNewWebhookAfterPersistenceFailure(params, registeredWebhookId);
+        if (metadataPersisted || !deleted) {
+          await restorePreviousWebhookMetadata(
+            params,
+            previous,
+            deleted ? undefined : registeredWebhookId,
+          );
+        }
+      } else if (metadataPersisted) {
+        await restorePreviousWebhookMetadata(params, previous);
+      }
+      await bestEffortRegistrationFailure(params);
+    }
+    throw error;
+  }
+
+  if (cleanupSupersededWebhooks) {
+    try {
+      await withRegistrationLock(params.cloudId, cleanupSupersededWebhooks);
+    } catch (error) {
+      logger().warn(
+        {err: error, connectionId: params.connectionId},
+        'Jira superseded webhook cleanup persistence failed',
+      );
+    }
+  }
+
+  return result;
+}
+
+async function finishSupersededWebhookCleanup(
+  params: RegisterJiraWebhookParams,
+  previous: Awaited<ReturnType<typeof getJiraInstallationByConnectionId>>,
+  registeredWebhookId: number,
+  webhookExpiresAt: Date,
+): Promise<void> {
+  const supersededWebhookIds = (previous?.webhookIds ?? []).filter(
+    (webhookId) => webhookId !== registeredWebhookId,
+  );
+  if (supersededWebhookIds.length === 0) return;
+
+  const failedCleanupIds: number[] = [];
+  for (const webhookId of supersededWebhookIds) {
+    try {
+      await params.jira.deleteDynamicWebhook({
+        accessToken: params.accessToken,
+        cloudId: params.cloudId,
+        webhookId,
+      });
+    } catch (error) {
+      failedCleanupIds.push(webhookId);
+      logger().warn(
+        {err: error, connectionId: params.connectionId, webhookId},
+        'Jira superseded webhook cleanup failed',
+      );
+    }
+  }
+
+  const retainedWebhookIds = [registeredWebhookId, ...failedCleanupIds];
+  const updateInstallation = params.updateInstallation ?? updateJiraInstallationWebhook;
+  const cleanupMetadata = await updateInstallation({
+    connectionId: params.connectionId,
+    webhookIds: retainedWebhookIds,
+    webhookExpiresAt,
+  });
+  if (!cleanupMetadata)
+    throw new Error('Jira webhook cleanup metadata persistence returned no installation');
+}
+
+async function bestEffortRegistrationFailure(params: RegisterJiraWebhookParams): Promise<void> {
+  try {
+    await params.onRegistrationFailure?.({});
+  } catch (error) {
+    logger().warn(
+      {err: error, connectionId: params.connectionId},
+      'Jira connection error-state update failed after webhook registration rejection',
+    );
+  }
+}
+
+async function restorePreviousWebhookMetadata(
+  params: RegisterJiraWebhookParams,
+  previous: Awaited<ReturnType<typeof getJiraInstallationByConnectionId>>,
+  retainedWebhookId?: number,
+): Promise<void> {
+  try {
+    const updateInstallation = params.updateInstallation ?? updateJiraInstallationWebhook;
+    await updateInstallation({
+      connectionId: params.connectionId,
+      webhookIds: [
+        ...(retainedWebhookId === undefined ? [] : [retainedWebhookId]),
+        ...(previous?.webhookIds ?? []).filter((webhookId) => webhookId !== retainedWebhookId),
+      ],
+      webhookExpiresAt: previous?.webhookExpiresAt ?? null,
+    });
+  } catch (error) {
+    logger().warn(
+      {err: error, connectionId: params.connectionId},
+      'Jira webhook metadata restoration failed after registration rejection',
+    );
+  }
+}
+
+async function deleteNewWebhookAfterPersistenceFailure(
+  params: RegisterJiraWebhookParams,
+  webhookId: number,
+): Promise<boolean> {
+  try {
+    await params.jira.deleteDynamicWebhook({
+      accessToken: params.accessToken,
+      cloudId: params.cloudId,
+      webhookId,
+    });
+    return true;
+  } catch (cleanupError) {
+    logger().warn(
+      {err: cleanupError, connectionId: params.connectionId, webhookId},
+      'Jira webhook cleanup failed after metadata persistence rejection',
+    );
+    return false;
+  }
+}

package/src/core/webhook.ts

@@ -0,0 +1,69 @@
+import type {JiraWebhookEnvelopeDto} from '@shipfox/api-integration-jira-dto';
+import type {
+  IntegrationConnection,
+  IntegrationTx,
+  PublishIntegrationEventReceivedFn,
+  RecordDeliveryOnlyFn,
+} from '@shipfox/api-integration-spi';
+import type {JiraInstallation} from '#db/installations.js';
+
+const JIRA_PROVIDER = 'jira';
+
+export interface HandleJiraWebhookParams {
+  tx: IntegrationTx;
+  deliveryId: string;
+  receivedAt: string;
+  rawPayload: JiraWebhookEnvelopeDto;
+  cloudId: string;
+  connection: IntegrationConnection<'jira'>;
+  authorizingAccountId: string;
+  publishIntegrationEventReceived: PublishIntegrationEventReceivedFn;
+  recordDeliveryOnly: RecordDeliveryOnlyFn;
+}
+
+export type HandleJiraWebhookResult = 'published' | 'duplicate' | 'discarded';
+
+export async function handleJiraWebhook(
+  params: HandleJiraWebhookParams,
+): Promise<HandleJiraWebhookResult> {
+  if (isSelfAuthoredEvent(params.rawPayload, params.authorizingAccountId)) {
+    await params.recordDeliveryOnly({
+      tx: params.tx,
+      provider: JIRA_PROVIDER,
+      deliveryId: params.deliveryId,
+    });
+    return 'discarded';
+  }
+
+  const payload = {...params.rawPayload, cloudId: params.cloudId};
+  const result = await params.publishIntegrationEventReceived({
+    tx: params.tx,
+    event: {
+      provider: JIRA_PROVIDER,
+      source: params.connection.slug,
+      event: params.rawPayload.webhookEvent,
+      workspaceId: params.connection.workspaceId,
+      connectionId: params.connection.id,
+      connectionName: params.connection.displayName,
+      deliveryId: params.deliveryId,
+      receivedAt: params.receivedAt,
+      payload,
+    },
+  });
+  return result.published ? 'published' : 'duplicate';
+}
+
+function isSelfAuthoredEvent(payload: JiraWebhookEnvelopeDto, authorizingAccountId: string) {
+  return (
+    (payload.webhookEvent === 'comment_created' ||
+      payload.webhookEvent === 'comment_updated' ||
+      payload.webhookEvent === 'jira:issue_updated') &&
+    payload.user.accountId === authorizingAccountId
+  );
+}
+
+export function isJiraInstallationUsable(
+  installation: JiraInstallation | undefined,
+): installation is JiraInstallation {
+  return installation?.status === 'installed';
+}