@shipfox/api-integration-jira 12.2.0 → 12.3.0

package/src/temporal/activities/renew-jira-webhooks.ts

@@ -0,0 +1,144 @@
+import type {IntegrationConnection} from '@shipfox/api-integration-spi';
+import {logger} from '@shipfox/node-opentelemetry';
+import type {JiraApiClient} from '#api/client.js';
+import type {JiraTokenStore} from '#core/tokens.js';
+import {registerJiraWebhook} from '#core/webhook-registration.js';
+import {
+  type JiraInstallation,
+  listJiraInstallationsDueForWebhookRenewal,
+  updateJiraInstallationWebhookIfUnchanged,
+} from '#db/installations.js';
+import {
+  JIRA_WEBHOOK_RENEWAL_SWEEP_BATCH_SIZE,
+  JIRA_WEBHOOK_RENEWAL_THRESHOLD_MS,
+} from '#temporal/constants.js';
+
+const JIRA_WEBHOOK_HEARTBEAT_INTERVAL_MS = 15_000;
+
+export interface JiraWebhookRenewalActivityResult {
+  renewed: number;
+  reregistered: number;
+  skipped: number;
+  failed: number;
+}
+
+export interface CreateJiraWebhookRenewalActivitiesOptions {
+  tokenStore: Pick<JiraTokenStore, 'getAccessToken'>;
+  jira?:
+    | Pick<
+        JiraApiClient,
+        'refreshDynamicWebhooks' | 'registerDynamicWebhook' | 'deleteDynamicWebhook'
+      >
+    | undefined;
+  webhookUrlForConnection?: ((connectionId: string) => string) | undefined;
+  resolveConnection(
+    connectionId: string,
+  ): Promise<Pick<IntegrationConnection, 'lifecycleStatus'> | undefined>;
+  listInstallations?: typeof listJiraInstallationsDueForWebhookRenewal | undefined;
+  updateInstallation?: typeof updateJiraInstallationWebhookIfUnchanged | undefined;
+  registerWebhook?: typeof registerJiraWebhook | undefined;
+  now?: (() => Date) | undefined;
+  heartbeat?: (() => void) | undefined;
+}
+
+export function createJiraWebhookRenewalActivities(
+  options: CreateJiraWebhookRenewalActivitiesOptions,
+) {
+  const listInstallations = options.listInstallations ?? listJiraInstallationsDueForWebhookRenewal;
+  const updateInstallation = options.updateInstallation ?? updateJiraInstallationWebhookIfUnchanged;
+  const registerWebhook = options.registerWebhook ?? registerJiraWebhook;
+  const now = options.now ?? (() => new Date());
+  const heartbeat = options.heartbeat ?? (() => undefined);
+
+  return {
+    async renewJiraWebhooksActivity(): Promise<JiraWebhookRenewalActivityResult> {
+      const renewalDeadline = new Date(now().getTime() + JIRA_WEBHOOK_RENEWAL_THRESHOLD_MS);
+      const installations = await listInstallations({
+        before: renewalDeadline,
+        limit: JIRA_WEBHOOK_RENEWAL_SWEEP_BATCH_SIZE,
+      });
+      let renewed = 0;
+      let reregistered = 0;
+      let skipped = 0;
+      let failed = 0;
+
+      for (const installation of installations) {
+        const heartbeatInterval = setInterval(heartbeat, JIRA_WEBHOOK_HEARTBEAT_INTERVAL_MS);
+        try {
+          heartbeat();
+          if (!isDueForRenewal(installation, renewalDeadline)) {
+            skipped += 1;
+            continue;
+          }
+
+          const connection = await options.resolveConnection(installation.connectionId);
+          if (connection?.lifecycleStatus !== 'active') {
+            skipped += 1;
+            continue;
+          }
+
+          if (!options.jira || !options.webhookUrlForConnection) {
+            throw new Error('Jira webhook renewal dependencies are not configured');
+          }
+
+          const accessToken = await options.tokenStore.getAccessToken({
+            connectionId: installation.connectionId,
+          });
+          const webhookExpiresAt =
+            installation.webhookIds.length === 0
+              ? undefined
+              : await options.jira.refreshDynamicWebhooks({
+                  accessToken,
+                  cloudId: installation.cloudId,
+                  webhookIds: installation.webhookIds,
+                });
+
+          if (webhookExpiresAt === undefined) {
+            await registerWebhook({
+              jira: options.jira,
+              connectionId: installation.connectionId,
+              cloudId: installation.cloudId,
+              accessToken,
+              webhookUrl: options.webhookUrlForConnection(installation.connectionId),
+              now,
+              replaceExistingWebhooks: true,
+            });
+            reregistered += 1;
+          } else {
+            const updated = await updateInstallation({
+              connectionId: installation.connectionId,
+              webhookIds: installation.webhookIds,
+              webhookExpiresAt,
+              expectedWebhookIds: installation.webhookIds,
+              expectedWebhookExpiresAt: installation.webhookExpiresAt,
+            });
+            if (!updated) {
+              skipped += 1;
+              continue;
+            }
+            renewed += 1;
+          }
+        } catch (error) {
+          failed += 1;
+          logger().warn(
+            {err: error, connectionId: installation.connectionId},
+            'Jira webhook renewal failed',
+          );
+        } finally {
+          clearInterval(heartbeatInterval);
+          heartbeat();
+        }
+      }
+
+      return {renewed, reregistered, skipped, failed};
+    },
+  };
+}
+
+function isDueForRenewal(installation: JiraInstallation, renewalDeadline: Date): boolean {
+  return (
+    installation.status === 'installed' &&
+    installation.webhookExpiresAt !== null &&
+    installation.webhookExpiresAt.getTime() <= renewalDeadline.getTime()
+  );
+}

package/src/temporal/constants.ts

@@ -1,5 +1,7 @@
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 
+export const JIRA_WEBHOOK_RENEWAL_THRESHOLD_MS = 7 * MS_PER_DAY;
+export const JIRA_WEBHOOK_RENEWAL_SWEEP_BATCH_SIZE = 20;
 export const JIRA_REFRESH_TOKEN_IDLE_WINDOW_MS = 90 * MS_PER_DAY;
 export const JIRA_REFRESH_TOKEN_REFRESH_LEAD_TIME_MS = 14 * MS_PER_DAY;
 export const JIRA_REFRESH_TOKEN_PROACTIVE_REFRESH_AFTER_MS =

package/src/temporal/worker.ts

@@ -3,6 +3,7 @@ import {fileURLToPath} from 'node:url';
 import type {IntegrationConnection} from '@shipfox/api-integration-spi';
 import type {ModuleWorker} from '@shipfox/node-module';
 import {Context} from '@temporalio/activity';
+import type {JiraApiClient} from '#api/client.js';
 import type {JiraTokenStore} from '#core/tokens.js';
 import {createJiraMaintenanceActivities} from '#temporal/activities/index.js';
 import {JIRA_MAINTENANCE_TASK_QUEUE} from '#temporal/constants.js';
@@ -12,6 +13,11 @@ const workflowsPath = resolve(packageRoot, 'dist/temporal/workflows/index.js');
 
 export interface CreateJiraMaintenanceWorkerOptions {
   tokenStore: Pick<JiraTokenStore, 'getAccessToken'>;
+  jira: Pick<
+    JiraApiClient,
+    'refreshDynamicWebhooks' | 'registerDynamicWebhook' | 'deleteDynamicWebhook'
+  >;
+  webhookUrlForConnection: (connectionId: string) => string;
   resolveConnection(
     connectionId: string,
   ): Promise<Pick<IntegrationConnection, 'lifecycleStatus'> | undefined>;
@@ -34,6 +40,11 @@ export function createJiraMaintenanceWorker(
         id: 'jira-refresh-tokens',
         cronSchedule: '0 */6 * * *',
       },
+      {
+        name: 'renewJiraWebhooksCron',
+        id: 'jira-renew-webhooks',
+        cronSchedule: '0 */6 * * *',
+      },
     ],
   };
 }

package/src/temporal/workflows/index.ts

@@ -1 +1,2 @@
 export {refreshJiraTokensCron} from './refresh-jira-tokens-cron.js';
+export {renewJiraWebhooksCron} from './renew-jira-webhooks-cron.js';

package/src/temporal/workflows/renew-jira-webhooks-cron.ts

@@ -0,0 +1,17 @@
+import {log, proxyActivities} from '@temporalio/workflow';
+import type {createJiraMaintenanceActivities} from '../activities/index.js';
+
+const {renewJiraWebhooksActivity} = proxyActivities<
+  ReturnType<typeof createJiraMaintenanceActivities>
+>({
+  startToCloseTimeout: '5 minutes',
+  heartbeatTimeout: '1 minute',
+  retry: {maximumAttempts: 1},
+});
+
+export async function renewJiraWebhooksCron(): Promise<void> {
+  const result = await renewJiraWebhooksActivity();
+  if (result.renewed > 0 || result.reregistered > 0 || result.failed > 0 || result.skipped > 0) {
+    log.info('Completed Jira webhook renewal', {...result});
+  }
+}