@shipfox/api-integration-jira 4.0.0 → 6.0.0

package/src/core/tokens.ts

@@ -1,7 +1,20 @@
-import {JiraAccessTokenMissingError, JiraConnectionNotFoundError} from '#core/errors.js';
+import {createJiraApiClient, type JiraApiClient} from '#api/client.js';
+import {
+  JiraAccessTokenMissingError,
+  JiraConnectionNotFoundError,
+  JiraIntegrationProviderError,
+  JiraTokenUnrefreshableError,
+} from '#core/errors.js';
+import {
+  getJiraInstallationByConnectionId,
+  updateJiraInstallationTokenExpiry,
+  withJiraRefreshLock,
+} from '#db/installations.js';
 
 const ACCESS_TOKEN_KEY = 'ACCESS_TOKEN';
 const REFRESH_TOKEN_KEY = 'REFRESH_TOKEN';
+const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000;
+const tokenRefreshes = new Map<string, Promise<string>>();
 
 export interface JiraConnectionResolverResult {
   workspaceId: string;
@@ -20,6 +33,8 @@ export interface JiraSecretsStore {
 export interface CreateJiraTokenStoreParams {
   resolveConnection(connectionId: string): Promise<JiraConnectionResolverResult | undefined>;
   secrets: JiraSecretsStore;
+  client?: JiraApiClient | undefined;
+  markConnectionError?: (params: {connectionId: string}) => Promise<void>;
 }
 
 export interface StoreJiraTokensParams {
@@ -31,6 +46,7 @@ export interface StoreJiraTokensParams {
 
 export interface GetJiraAccessTokenParams {
   connectionId: string;
+  forceRefresh?: boolean | undefined;
 }
 
 export interface JiraTokenStore {
@@ -43,18 +59,28 @@ export function jiraSecretsNamespace(connectionId: string): string {
 }
 
 export function createJiraTokenStore(params: CreateJiraTokenStoreParams): JiraTokenStore {
+  const client = params.client ?? createJiraApiClient();
   async function resolveWorkspaceId(connectionId: string): Promise<string> {
     const connection = await params.resolveConnection(connectionId);
     if (!connection) throw new JiraConnectionNotFoundError(connectionId);
     return connection.workspaceId;
   }
+  const readSecretToken = (
+    workspaceId: string,
+    connectionId: string,
+    key: typeof ACCESS_TOKEN_KEY | typeof REFRESH_TOKEN_KEY,
+  ) => params.secrets.getSecret({workspaceId, namespace: jiraSecretsNamespace(connectionId), key});
+  async function readAccessToken(workspaceId: string, connectionId: string): Promise<string> {
+    const token = await readSecretToken(workspaceId, connectionId, ACCESS_TOKEN_KEY);
+    if (!token) throw new JiraAccessTokenMissingError(connectionId);
+    return token;
+  }
 
   return {
     async storeTokens(input) {
       const workspaceId = await resolveWorkspaceId(input.connectionId);
       const values: Record<string, string> = {[ACCESS_TOKEN_KEY]: input.accessToken};
       if (input.refreshToken) values[REFRESH_TOKEN_KEY] = input.refreshToken;
-
       await params.secrets.setSecrets({
         workspaceId,
         namespace: jiraSecretsNamespace(input.connectionId),
@@ -62,16 +88,127 @@ export function createJiraTokenStore(params: CreateJiraTokenStoreParams): JiraTo
         editedBy: input.editedBy,
       });
     },
-
     async getAccessToken(input) {
       const workspaceId = await resolveWorkspaceId(input.connectionId);
-      const token = await params.secrets.getSecret({
+      const accessToken = await readAccessToken(workspaceId, input.connectionId);
+      if (
+        !input.forceRefresh &&
+        !shouldRefresh(
+          (await getJiraInstallationByConnectionId(input.connectionId))?.tokenExpiresAt ?? null,
+        )
+      )
+        return accessToken;
+      const inFlight = tokenRefreshes.get(input.connectionId);
+      if (inFlight) return inFlight;
+      const refresh = refreshAccessTokenWithLock({
+        connectionId: input.connectionId,
         workspaceId,
-        namespace: jiraSecretsNamespace(input.connectionId),
-        key: ACCESS_TOKEN_KEY,
+        originalAccessToken: accessToken,
+        forceRefresh: input.forceRefresh === true,
+        client,
+        secrets: params.secrets,
+        readAccessToken,
+        readSecretToken,
+        markConnectionError: params.markConnectionError,
       });
-      if (!token) throw new JiraAccessTokenMissingError(input.connectionId);
-      return token;
+      tokenRefreshes.set(input.connectionId, refresh);
+      void refresh.then(
+        () => clearTokenRefresh(input.connectionId, refresh),
+        () => clearTokenRefresh(input.connectionId, refresh),
+      );
+      return refresh;
     },
   };
 }
+
+function shouldRefresh(expiresAt: Date | null): boolean {
+  return expiresAt !== null && expiresAt.getTime() <= Date.now() + TOKEN_REFRESH_MARGIN_MS;
+}
+
+function clearTokenRefresh(connectionId: string, refresh: Promise<string>): void {
+  if (tokenRefreshes.get(connectionId) === refresh) tokenRefreshes.delete(connectionId);
+}
+
+async function refreshAccessTokenWithLock(params: {
+  connectionId: string;
+  workspaceId: string;
+  originalAccessToken: string;
+  forceRefresh: boolean;
+  client: JiraApiClient;
+  secrets: JiraSecretsStore;
+  readAccessToken(workspaceId: string, connectionId: string): Promise<string>;
+  readSecretToken(
+    workspaceId: string,
+    connectionId: string,
+    key: typeof ACCESS_TOKEN_KEY | typeof REFRESH_TOKEN_KEY,
+  ): Promise<string | null>;
+  markConnectionError?: ((params: {connectionId: string}) => Promise<void>) | undefined;
+}): Promise<string> {
+  const lock = await withJiraRefreshLock(params.connectionId, () =>
+    refreshAccessTokenForConnection(params),
+  );
+  if (lock.acquired) return lock.value;
+  const reread = await params.readAccessToken(params.workspaceId, params.connectionId);
+  if (reread !== params.originalAccessToken) return reread;
+  throw new JiraIntegrationProviderError(
+    'provider-unavailable',
+    'Jira token refresh is already in progress',
+  );
+}
+
+async function refreshAccessTokenForConnection(params: {
+  connectionId: string;
+  workspaceId: string;
+  originalAccessToken: string;
+  forceRefresh: boolean;
+  client: JiraApiClient;
+  secrets: JiraSecretsStore;
+  readAccessToken(workspaceId: string, connectionId: string): Promise<string>;
+  readSecretToken(
+    workspaceId: string,
+    connectionId: string,
+    key: typeof ACCESS_TOKEN_KEY | typeof REFRESH_TOKEN_KEY,
+  ): Promise<string | null>;
+  markConnectionError?: ((params: {connectionId: string}) => Promise<void>) | undefined;
+}): Promise<string> {
+  const current = await params.readAccessToken(params.workspaceId, params.connectionId);
+  const installation = await getJiraInstallationByConnectionId(params.connectionId);
+  if (
+    current !== params.originalAccessToken ||
+    (!params.forceRefresh && !shouldRefresh(installation?.tokenExpiresAt ?? null))
+  )
+    return current;
+  const refreshToken = await params.readSecretToken(
+    params.workspaceId,
+    params.connectionId,
+    REFRESH_TOKEN_KEY,
+  );
+  if (!refreshToken) {
+    if (params.forceRefresh || shouldRefresh(installation?.tokenExpiresAt ?? null))
+      throw new JiraTokenUnrefreshableError(params.connectionId);
+    return current;
+  }
+  try {
+    const refreshed = await params.client.refreshAccessToken({refreshToken});
+    if (!refreshed.refreshToken) throw new JiraTokenUnrefreshableError(params.connectionId);
+    await params.secrets.setSecrets({
+      workspaceId: params.workspaceId,
+      namespace: jiraSecretsNamespace(params.connectionId),
+      values: {
+        [ACCESS_TOKEN_KEY]: refreshed.accessToken,
+        [REFRESH_TOKEN_KEY]: refreshed.refreshToken,
+      },
+    });
+    await updateJiraInstallationTokenExpiry({
+      connectionId: params.connectionId,
+      tokenExpiresAt: refreshed.expiresAt ?? null,
+      scopes: refreshed.scopes.length > 0 ? refreshed.scopes : undefined,
+    });
+    return refreshed.accessToken;
+  } catch (error) {
+    if (error instanceof JiraIntegrationProviderError && error.reason === 'access-denied') {
+      await params.markConnectionError?.({connectionId: params.connectionId});
+    }
+    throw error;
+  }
+}

package/src/db/db.ts

@@ -1,8 +1,9 @@
 import {drizzle, type NodePgDatabase} from '@shipfox/node-drizzle';
 import {pgClient} from '@shipfox/node-postgres';
 import {jiraInstallations} from './schema/installations.js';
+import {jiraPendingSelections} from './schema/pending-selections.js';
 
-export const schema = {jiraInstallations};
+export const schema = {jiraInstallations, jiraPendingSelections};
 
 let database: NodePgDatabase<typeof schema> | undefined;
 

package/src/db/installations.test.ts

@@ -1,8 +1,14 @@
-import {JiraInstallationSiteMismatchError} from '#core/errors.js';
 import {
+  JiraInstallationAlreadyLinkedError,
+  JiraInstallationSiteMismatchError,
+} from '#core/errors.js';
+import {
+  deleteJiraInstallationByConnectionId,
+  getJiraInstallationByCloudId,
   getJiraInstallationByConnectionId,
   getJiraInstallationByWebhookId,
   markJiraInstallationRevoked,
+  updateJiraInstallationTokenExpiry,
   upsertJiraInstallation,
 } from './installations.js';
 
@@ -69,6 +75,36 @@ describe('jira installations', () => {
     });
   });
 
+  it('refuses to link the same Jira site to a second connection', async () => {
+    const first = createInstallationInput();
+    await upsertJiraInstallation(first);
+    const second = createInstallationInput({cloudId: first.cloudId});
+
+    const result = upsertJiraInstallation(second);
+
+    await expect(result).rejects.toBeInstanceOf(JiraInstallationAlreadyLinkedError);
+    await expect(getJiraInstallationByCloudId(first.cloudId)).resolves.toMatchObject({
+      connectionId: first.connectionId,
+    });
+  });
+
+  it('updates token metadata and deletes an installation', async () => {
+    const input = createInstallationInput();
+    await upsertJiraInstallation(input);
+    const tokenExpiresAt = new Date('2030-01-01T00:00:00.000Z');
+
+    const updated = await updateJiraInstallationTokenExpiry({
+      connectionId: input.connectionId,
+      tokenExpiresAt,
+      scopes: ['read:jira-work', 'write:jira-work'],
+    });
+    const deleted = await deleteJiraInstallationByConnectionId(input.connectionId);
+
+    expect(updated).toMatchObject({tokenExpiresAt, scopes: ['read:jira-work', 'write:jira-work']});
+    expect(deleted).toBe(true);
+    await expect(getJiraInstallationByConnectionId(input.connectionId)).resolves.toBeUndefined();
+  });
+
   it('returns undefined for unknown connection and webhook ids', async () => {
     const connectionId = crypto.randomUUID();
     const webhookId = Number.MAX_SAFE_INTEGER;

package/src/db/installations.ts

@@ -1,5 +1,11 @@
+import {isUniqueViolation} from '@shipfox/node-drizzle';
+import {pgClient} from '@shipfox/node-postgres';
 import {eq, sql} from 'drizzle-orm';
-import {JiraInstallationSiteMismatchError} from '#core/errors.js';
+import {
+  JiraConnectionAlreadyLinkedError,
+  JiraInstallationAlreadyLinkedError,
+  JiraInstallationSiteMismatchError,
+} from '#core/errors.js';
 import {db} from './db.js';
 import {jiraInstallations, toJiraInstallation} from './schema/installations.js';
 
@@ -34,6 +40,12 @@ export interface UpsertJiraInstallationParams {
   tokenExpiresAt?: Date | null | undefined;
 }
 
+export interface UpdateJiraInstallationTokenExpiryParams {
+  connectionId: string;
+  tokenExpiresAt: Date | null;
+  scopes?: string[] | undefined;
+}
+
 type JiraDb = ReturnType<typeof db>;
 type JiraTx = Parameters<Parameters<JiraDb['transaction']>[0]>[0];
 
@@ -44,24 +56,12 @@ export async function upsertJiraInstallation(
   const executor = (options.tx ?? db()) as JiraDb | JiraTx;
   const now = new Date();
   const webhookIds = params.webhookIds ?? [];
-  const [row] = await executor
-    .insert(jiraInstallations)
-    .values({
-      connectionId: params.connectionId,
-      cloudId: params.cloudId,
-      siteUrl: params.siteUrl,
-      siteName: params.siteName,
-      authorizingAccountId: params.authorizingAccountId,
-      scopes: params.scopes,
-      webhookIds,
-      webhookExpiresAt: params.webhookExpiresAt ?? null,
-      status: params.status,
-      tokenExpiresAt: params.tokenExpiresAt ?? null,
-    })
-    .onConflictDoUpdate({
-      target: jiraInstallations.connectionId,
-      setWhere: eq(jiraInstallations.cloudId, params.cloudId),
-      set: {
+  let row: typeof jiraInstallations.$inferSelect | undefined;
+  try {
+    [row] = await executor
+      .insert(jiraInstallations)
+      .values({
+        connectionId: params.connectionId,
         cloudId: params.cloudId,
         siteUrl: params.siteUrl,
         siteName: params.siteName,
@@ -71,15 +71,112 @@ export async function upsertJiraInstallation(
         webhookExpiresAt: params.webhookExpiresAt ?? null,
         status: params.status,
         tokenExpiresAt: params.tokenExpiresAt ?? null,
-        updatedAt: now,
-      },
-    })
-    .returning();
+      })
+      .onConflictDoUpdate({
+        target: jiraInstallations.connectionId,
+        setWhere: eq(jiraInstallations.cloudId, params.cloudId),
+        set: {
+          cloudId: params.cloudId,
+          siteUrl: params.siteUrl,
+          siteName: params.siteName,
+          authorizingAccountId: params.authorizingAccountId,
+          scopes: params.scopes,
+          webhookIds,
+          webhookExpiresAt: params.webhookExpiresAt ?? null,
+          status: params.status,
+          tokenExpiresAt: params.tokenExpiresAt ?? null,
+          updatedAt: now,
+        },
+      })
+      .returning();
+  } catch (error) {
+    if (isUniqueViolation(error, 'integrations_jira_installations_connection_unique')) {
+      throw new JiraConnectionAlreadyLinkedError(params.connectionId);
+    }
+    if (isUniqueViolation(error, 'integrations_jira_installations_cloud_id_unique')) {
+      throw new JiraInstallationAlreadyLinkedError(params.cloudId);
+    }
+    throw error;
+  }
 
   if (!row) throw new JiraInstallationSiteMismatchError(params.connectionId, params.cloudId);
   return toJiraInstallation(row);
 }
 
+export async function getJiraInstallationByCloudId(
+  cloudId: string,
+  options: {tx?: unknown} = {},
+): Promise<JiraInstallation | undefined> {
+  const executor = (options.tx ?? db()) as JiraDb | JiraTx;
+  const rows = await executor
+    .select()
+    .from(jiraInstallations)
+    .where(eq(jiraInstallations.cloudId, cloudId))
+    .limit(1);
+  const row = rows[0];
+  return row ? toJiraInstallation(row) : undefined;
+}
+
+export async function updateJiraInstallationTokenExpiry(
+  params: UpdateJiraInstallationTokenExpiryParams,
+  options: {tx?: unknown} = {},
+): Promise<JiraInstallation | undefined> {
+  const executor = (options.tx ?? db()) as JiraDb | JiraTx;
+  const [row] = await executor
+    .update(jiraInstallations)
+    .set({
+      tokenExpiresAt: params.tokenExpiresAt,
+      ...(params.scopes === undefined ? {} : {scopes: params.scopes}),
+      updatedAt: new Date(),
+    })
+    .where(eq(jiraInstallations.connectionId, params.connectionId))
+    .returning();
+  return row ? toJiraInstallation(row) : undefined;
+}
+
+export async function deleteJiraInstallationByConnectionId(
+  connectionId: string,
+  options: {tx?: unknown} = {},
+): Promise<boolean> {
+  const executor = (options.tx ?? db()) as JiraDb | JiraTx;
+  const result = await executor
+    .delete(jiraInstallations)
+    .where(eq(jiraInstallations.connectionId, connectionId));
+  return (result.rowCount ?? 0) > 0;
+}
+
+export type JiraRefreshLockResult<T> = {acquired: true; value: T} | {acquired: false};
+
+export function withJiraRefreshLock<T>(
+  connectionId: string,
+  fn: () => Promise<T>,
+): Promise<JiraRefreshLockResult<T>> {
+  return withJiraRefreshLockClient(connectionId, fn);
+}
+
+async function withJiraRefreshLockClient<T>(
+  connectionId: string,
+  fn: () => Promise<T>,
+): Promise<JiraRefreshLockResult<T>> {
+  const client = await pgClient().connect();
+  let acquired = false;
+  try {
+    const lock = await client.query<{acquired: boolean}>(
+      'SELECT pg_try_advisory_lock(hashtext($1)) AS acquired',
+      [connectionId],
+    );
+    acquired = lock.rows[0]?.acquired === true;
+    if (!acquired) return {acquired: false};
+    return {acquired: true, value: await fn()};
+  } finally {
+    try {
+      if (acquired) await client.query('SELECT pg_advisory_unlock(hashtext($1))', [connectionId]);
+    } finally {
+      client.release();
+    }
+  }
+}
+
 export async function getJiraInstallationByConnectionId(
   connectionId: string,
   options: {tx?: unknown} = {},

package/src/db/pending-selections.ts

@@ -0,0 +1,55 @@
+import {and, eq, lt} from 'drizzle-orm';
+import {db} from './db.js';
+import {jiraPendingSelections, toJiraPendingSelection} from './schema/pending-selections.js';
+
+export async function saveJiraPendingSelection(params: {
+  stateHash: string;
+  workspaceId: string;
+  expiresAt: Date;
+  sites: typeof jiraPendingSelections.$inferInsert.sites;
+}): Promise<void> {
+  await db()
+    .insert(jiraPendingSelections)
+    .values(params)
+    .onConflictDoUpdate({
+      target: jiraPendingSelections.stateHash,
+      set: {workspaceId: params.workspaceId, expiresAt: params.expiresAt, sites: params.sites},
+    });
+}
+
+export async function getJiraPendingSelection(params: {stateHash: string; workspaceId: string}) {
+  const rows = await db()
+    .select()
+    .from(jiraPendingSelections)
+    .where(
+      and(
+        eq(jiraPendingSelections.stateHash, params.stateHash),
+        eq(jiraPendingSelections.workspaceId, params.workspaceId),
+      ),
+    )
+    .limit(1);
+  const row = rows[0];
+  return row ? toJiraPendingSelection(row) : undefined;
+}
+
+export async function deleteJiraPendingSelection(params: {
+  stateHash: string;
+  workspaceId: string;
+}): Promise<void> {
+  await db()
+    .delete(jiraPendingSelections)
+    .where(
+      and(
+        eq(jiraPendingSelections.stateHash, params.stateHash),
+        eq(jiraPendingSelections.workspaceId, params.workspaceId),
+      ),
+    );
+}
+
+export async function listExpiredJiraPendingSelections(now: Date) {
+  const rows = await db()
+    .select()
+    .from(jiraPendingSelections)
+    .where(lt(jiraPendingSelections.expiresAt, now));
+  return rows.map(toJiraPendingSelection);
+}

package/src/db/schema/installations.ts

@@ -1,5 +1,5 @@
 import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
-import {index, jsonb, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import {jsonb, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
 import type {JiraInstallation} from '#db/installations.js';
 import {pgTable} from './common.js';
 
@@ -22,7 +22,7 @@ export const jiraInstallations = pgTable(
   },
   (table) => [
     uniqueIndex('integrations_jira_installations_connection_unique').on(table.connectionId),
-    index('integrations_jira_installations_cloud_id_idx').on(table.cloudId),
+    uniqueIndex('integrations_jira_installations_cloud_id_unique').on(table.cloudId),
   ],
 );
 

package/src/db/schema/pending-selections.ts

@@ -0,0 +1,31 @@
+import {jsonb, text, timestamp, uuid} from 'drizzle-orm/pg-core';
+import type {JiraAccessibleResource} from '#api/client.js';
+import {pgTable} from './common.js';
+
+export const jiraPendingSelections = pgTable('pending_selections', {
+  stateHash: text('state_hash').primaryKey(),
+  workspaceId: uuid('workspace_id').notNull(),
+  expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),
+  sites: jsonb('sites').$type<JiraAccessibleResource[]>().notNull(),
+  createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+});
+
+export type JiraPendingSelectionDb = typeof jiraPendingSelections.$inferSelect;
+
+export interface JiraPendingSelection {
+  stateHash: string;
+  workspaceId: string;
+  expiresAt: Date;
+  sites: JiraAccessibleResource[];
+  createdAt: Date;
+}
+
+export function toJiraPendingSelection(row: JiraPendingSelectionDb): JiraPendingSelection {
+  return {
+    stateHash: row.stateHash,
+    workspaceId: row.workspaceId,
+    expiresAt: row.expiresAt,
+    sites: row.sites,
+    createdAt: row.createdAt,
+  };
+}

package/src/index.test.ts

@@ -1,9 +1,14 @@
 import {createJiraIntegrationProvider} from '#index.js';
 
 describe('createJiraIntegrationProvider', () => {
-  it('creates the minimal Jira provider', () => {
+  it('creates the Jira provider', () => {
     const provider = createJiraIntegrationProvider();
 
-    expect(provider).toEqual({provider: 'jira', displayName: 'Jira'});
+    expect(provider).toMatchObject({
+      provider: 'jira',
+      displayName: 'Jira',
+      adapters: {},
+      routes: [],
+    });
   });
 });

package/src/index.ts

@@ -1,14 +1,54 @@
 import {JIRA_PROVIDER} from '@shipfox/api-integration-jira-dto';
+import {createJiraApiClient, type JiraApiClient} from '#api/client.js';
 import {config} from '#config.js';
 import {closeDb, db} from '#db/db.js';
+import {getJiraInstallationByConnectionId} from '#db/installations.js';
 import {migrationsPath} from '#db/migrations.js';
+import {
+  type CreateJiraIntegrationRoutesOptions,
+  createJiraIntegrationRoutes,
+} from '#presentation/routes/install.js';
 
 export type {JiraProvider} from '@shipfox/api-integration-jira-dto';
+export type {
+  JiraAccessibleResource,
+  JiraApiClient,
+  JiraAuthorization,
+  JiraIdentity,
+} from '#api/client.js';
+export {createJiraApiClient, mapJiraError} from '#api/client.js';
+export type {DisconnectJiraInstallationParams} from '#core/disconnect.js';
+export {disconnectJiraInstallation} from '#core/disconnect.js';
 export {
   JiraAccessTokenMissingError,
+  JiraAuthorizationScopeMismatchError,
+  JiraConnectionAlreadyLinkedError,
   JiraConnectionNotFoundError,
+  JiraInstallationAlreadyLinkedError,
   JiraInstallationSiteMismatchError,
+  JiraInstallStateActorMismatchError,
+  JiraInstallStateError,
+  JiraIntegrationProviderError,
+  JiraOAuthCallbackError,
+  JiraOfflineAccessNotGrantedError,
+  JiraPendingSelectionNotFoundError,
+  JiraSiteSelectionMismatchError,
+  JiraTokenUnrefreshableError,
 } from '#core/errors.js';
+export type {ConnectJiraInstallationInput, HandleJiraCallbackParams} from '#core/install.js';
+export {
+  handleJiraCallback,
+  handleJiraOAuthCallbackError,
+  handleJiraSiteSelection,
+} from '#core/install.js';
+export type {JiraPendingSelectionSecretsStore, JiraPendingSelectionStore} from '#core/pending.js';
+export {createJiraPendingSelectionStore, jiraPendingSecretsNamespace} from '#core/pending.js';
+export {
+  assertJiraAuthorizationScopes,
+  formatJiraOAuthScopes,
+  JIRA_OAUTH_SCOPES,
+} from '#core/scopes.js';
+export {signJiraInstallState, verifyJiraInstallState} from '#core/state.js';
 export type {
   CreateJiraTokenStoreParams,
   GetJiraAccessTokenParams,
@@ -24,13 +64,37 @@ export type {
   UpsertJiraInstallationParams,
 } from '#db/installations.js';
 export {
+  deleteJiraInstallationByConnectionId,
+  getJiraInstallationByCloudId,
   getJiraInstallationByConnectionId,
   getJiraInstallationByWebhookId,
   markJiraInstallationRevoked,
+  updateJiraInstallationTokenExpiry,
   upsertJiraInstallation,
+  withJiraRefreshLock,
 } from '#db/installations.js';
 export {closeDb, config, db, migrationsPath};
 
-export function createJiraIntegrationProvider() {
-  return {provider: JIRA_PROVIDER, displayName: 'Jira'};
+export interface CreateJiraIntegrationProviderOptions {
+  jira?: JiraApiClient | undefined;
+  getJiraInstallationByConnectionId?: typeof getJiraInstallationByConnectionId | undefined;
+  routes?: Omit<CreateJiraIntegrationRoutesOptions, 'jira' | 'connectionCapabilities'> | undefined;
+}
+
+export function createJiraIntegrationProvider(options: CreateJiraIntegrationProviderOptions = {}) {
+  const jira = options.jira ?? createJiraApiClient();
+  const getInstallationByConnectionId =
+    options.getJiraInstallationByConnectionId ?? getJiraInstallationByConnectionId;
+  const routes = options.routes
+    ? [createJiraIntegrationRoutes({jira, connectionCapabilities: [], ...options.routes})]
+    : [];
+  return {
+    provider: JIRA_PROVIDER,
+    displayName: 'Jira',
+    adapters: {},
+    async connectionExternalUrl(connection: {id: string}): Promise<string | undefined> {
+      return (await getInstallationByConnectionId(connection.id))?.siteUrl;
+    },
+    routes,
+  };
 }

package/src/presentation/dto/integrations.ts

@@ -0,0 +1 @@
+export {toIntegrationConnectionDto} from '@shipfox/api-integration-core-dto';