@shipfox/api-integration-jira 4.0.0

package/src/db/installations.ts

@@ -0,0 +1,125 @@
+import {eq, sql} from 'drizzle-orm';
+import {JiraInstallationSiteMismatchError} from '#core/errors.js';
+import {db} from './db.js';
+import {jiraInstallations, toJiraInstallation} from './schema/installations.js';
+
+export type JiraInstallationStatus = 'installed' | 'revoked';
+
+export interface JiraInstallation {
+  id: string;
+  connectionId: string;
+  cloudId: string;
+  siteUrl: string;
+  siteName: string;
+  authorizingAccountId: string;
+  scopes: string[];
+  webhookIds: number[];
+  webhookExpiresAt: Date | null;
+  status: JiraInstallationStatus;
+  tokenExpiresAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface UpsertJiraInstallationParams {
+  connectionId: string;
+  cloudId: string;
+  siteUrl: string;
+  siteName: string;
+  authorizingAccountId: string;
+  scopes: string[];
+  webhookIds?: number[] | undefined;
+  webhookExpiresAt?: Date | null | undefined;
+  status: JiraInstallationStatus;
+  tokenExpiresAt?: Date | null | undefined;
+}
+
+type JiraDb = ReturnType<typeof db>;
+type JiraTx = Parameters<Parameters<JiraDb['transaction']>[0]>[0];
+
+export async function upsertJiraInstallation(
+  params: UpsertJiraInstallationParams,
+  options: {tx?: unknown} = {},
+): Promise<JiraInstallation> {
+  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: {
+        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();
+
+  if (!row) throw new JiraInstallationSiteMismatchError(params.connectionId, params.cloudId);
+  return toJiraInstallation(row);
+}
+
+export async function getJiraInstallationByConnectionId(
+  connectionId: 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.connectionId, connectionId))
+    .limit(1);
+  const row = rows[0];
+  if (!row) return undefined;
+  return toJiraInstallation(row);
+}
+
+export async function getJiraInstallationByWebhookId(
+  webhookId: number,
+  options: {tx?: unknown} = {},
+): Promise<JiraInstallation | undefined> {
+  const executor = (options.tx ?? db()) as JiraDb | JiraTx;
+  const rows = await executor
+    .select()
+    .from(jiraInstallations)
+    .where(sql`${jiraInstallations.webhookIds} @> ${JSON.stringify([webhookId])}::jsonb`)
+    .limit(1);
+  const row = rows[0];
+  if (!row) return undefined;
+  return toJiraInstallation(row);
+}
+
+export async function markJiraInstallationRevoked(
+  connectionId: string,
+  options: {tx?: unknown} = {},
+): Promise<JiraInstallation | undefined> {
+  const executor = (options.tx ?? db()) as JiraDb | JiraTx;
+  const [row] = await executor
+    .update(jiraInstallations)
+    .set({status: 'revoked', updatedAt: new Date()})
+    .where(eq(jiraInstallations.connectionId, connectionId))
+    .returning();
+  if (!row) return undefined;
+  return toJiraInstallation(row);
+}

package/src/db/migrations.ts

@@ -0,0 +1,4 @@
+import {dirname, resolve} from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+export const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');

package/src/db/schema/common.ts

@@ -0,0 +1,3 @@
+import {pgTableCreator} from 'drizzle-orm/pg-core';
+
+export const pgTable = pgTableCreator((name) => `integrations_jira_${name}`);

package/src/db/schema/installations.ts

@@ -0,0 +1,48 @@
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {index, jsonb, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import type {JiraInstallation} from '#db/installations.js';
+import {pgTable} from './common.js';
+
+export const jiraInstallations = pgTable(
+  'installations',
+  {
+    id: uuidv7PrimaryKey(),
+    connectionId: uuid('connection_id').notNull(),
+    cloudId: text('cloud_id').notNull(),
+    siteUrl: text('site_url').notNull(),
+    siteName: text('site_name').notNull(),
+    authorizingAccountId: text('authorizing_account_id').notNull(),
+    scopes: jsonb('scopes').$type<string[]>().notNull(),
+    webhookIds: jsonb('webhook_ids').$type<number[]>().notNull().default([]),
+    webhookExpiresAt: timestamp('webhook_expires_at', {withTimezone: true}),
+    status: text('status').notNull().$type<JiraInstallation['status']>(),
+    tokenExpiresAt: timestamp('token_expires_at', {withTimezone: true}),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('integrations_jira_installations_connection_unique').on(table.connectionId),
+    index('integrations_jira_installations_cloud_id_idx').on(table.cloudId),
+  ],
+);
+
+export type JiraInstallationDb = typeof jiraInstallations.$inferSelect;
+export type JiraInstallationCreateDb = typeof jiraInstallations.$inferInsert;
+
+export function toJiraInstallation(row: JiraInstallationDb): JiraInstallation {
+  return {
+    id: row.id,
+    connectionId: row.connectionId,
+    cloudId: row.cloudId,
+    siteUrl: row.siteUrl,
+    siteName: row.siteName,
+    authorizingAccountId: row.authorizingAccountId,
+    scopes: row.scopes,
+    webhookIds: row.webhookIds,
+    webhookExpiresAt: row.webhookExpiresAt,
+    status: row.status,
+    tokenExpiresAt: row.tokenExpiresAt,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}

package/src/index.test.ts

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

package/src/index.ts

@@ -0,0 +1,36 @@
+import {JIRA_PROVIDER} from '@shipfox/api-integration-jira-dto';
+import {config} from '#config.js';
+import {closeDb, db} from '#db/db.js';
+import {migrationsPath} from '#db/migrations.js';
+
+export type {JiraProvider} from '@shipfox/api-integration-jira-dto';
+export {
+  JiraAccessTokenMissingError,
+  JiraConnectionNotFoundError,
+  JiraInstallationSiteMismatchError,
+} from '#core/errors.js';
+export type {
+  CreateJiraTokenStoreParams,
+  GetJiraAccessTokenParams,
+  JiraConnectionResolverResult,
+  JiraSecretsStore,
+  JiraTokenStore,
+  StoreJiraTokensParams,
+} from '#core/tokens.js';
+export {createJiraTokenStore, jiraSecretsNamespace} from '#core/tokens.js';
+export type {
+  JiraInstallation,
+  JiraInstallationStatus,
+  UpsertJiraInstallationParams,
+} from '#db/installations.js';
+export {
+  getJiraInstallationByConnectionId,
+  getJiraInstallationByWebhookId,
+  markJiraInstallationRevoked,
+  upsertJiraInstallation,
+} from '#db/installations.js';
+export {closeDb, config, db, migrationsPath};
+
+export function createJiraIntegrationProvider() {
+  return {provider: JIRA_PROVIDER, displayName: 'Jira'};
+}

package/test/api-secrets.d.ts

@@ -0,0 +1,26 @@
+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 const secretsModule: {
+    database?:
+      | {
+          db(): NodePgDatabase<Record<string, unknown>>;
+          migrationsPath: string;
+        }
+      | unknown[]
+      | undefined;
+  };
+}

package/test/env.ts

@@ -0,0 +1,15 @@
+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.JIRA_OAUTH_CLIENT_ID = 'test-client-id';
+process.env.JIRA_OAUTH_CLIENT_SECRET = 'test-client-secret';
+process.env.JIRA_OAUTH_REDIRECT_URL = 'https://shipfox.example.com/integrations/jira/callback';
+process.env.JIRA_WEBHOOK_SIGNING_SECRET = 'test-signing-secret';
+process.env.JIRA_WEBHOOK_BASE_URL = 'https://shipfox.example.com';
+process.env.JIRA_API_BASE_URL = 'http://127.0.0.1:0';
+process.env.JIRA_AUTH_BASE_URL = 'http://127.0.0.1:0';
+process.env.SECRETS_ENCRYPTION_KEK = 'ZmVkY2JhOTg3NjU0MzIxMGZlZGNiYTk4NzY1NDMyMTA=';

package/test/factories/index.ts

@@ -0,0 +1 @@
+export {jiraInstallationFactory} from './jira-installation.js';

package/test/factories/jira-installation.ts

@@ -0,0 +1,35 @@
+import {Factory} from 'fishery';
+import {type JiraInstallation, upsertJiraInstallation} from '#db/installations.js';
+
+export const jiraInstallationFactory = Factory.define<JiraInstallation>(({sequence, onCreate}) => {
+  onCreate((installation) =>
+    upsertJiraInstallation({
+      connectionId: installation.connectionId,
+      cloudId: installation.cloudId,
+      siteUrl: installation.siteUrl,
+      siteName: installation.siteName,
+      authorizingAccountId: installation.authorizingAccountId,
+      scopes: installation.scopes,
+      webhookIds: installation.webhookIds,
+      webhookExpiresAt: installation.webhookExpiresAt,
+      status: installation.status,
+      tokenExpiresAt: installation.tokenExpiresAt,
+    }),
+  );
+
+  return {
+    id: crypto.randomUUID(),
+    connectionId: crypto.randomUUID(),
+    cloudId: crypto.randomUUID(),
+    siteUrl: 'https://acme.atlassian.net',
+    siteName: 'Acme',
+    authorizingAccountId: crypto.randomUUID(),
+    scopes: ['read:jira-work'],
+    webhookIds: [sequence + 1],
+    webhookExpiresAt: null,
+    status: 'installed',
+    tokenExpiresAt: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+});

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_jira');
+  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 {jiraInstallationFactory} from './factories/jira-installation.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"]
+}