@shipfox/api-integration-github 2.0.0

package/dist/db/db.d.ts

@@ -0,0 +1,433 @@
+import { type NodePgDatabase } from '@shipfox/node-drizzle';
+export declare const schema: {
+    githubInstallations: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "installations";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            connectionId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "connection_id";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            installationId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "installation_id";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            accountLogin: import("drizzle-orm/pg-core").PgColumn<{
+                name: "account_login";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            accountType: import("drizzle-orm/pg-core").PgColumn<{
+                name: "account_type";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            repositorySelection: import("drizzle-orm/pg-core").PgColumn<{
+                name: "repository_selection";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            suspendedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "suspended_at";
+                tableName: "installations";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            deletedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "deleted_at";
+                tableName: "installations";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            latestEvent: import("drizzle-orm/pg-core").PgColumn<{
+                name: "latest_event";
+                tableName: "installations";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, unknown>;
+                driverParam: unknown;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+            installerUserId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "installer_user_id";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "created_at";
+                tableName: "installations";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "updated_at";
+                tableName: "installations";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
+};
+export declare function db(): NodePgDatabase<{
+    githubInstallations: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "installations";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            connectionId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "connection_id";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            installationId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "installation_id";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            accountLogin: import("drizzle-orm/pg-core").PgColumn<{
+                name: "account_login";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            accountType: import("drizzle-orm/pg-core").PgColumn<{
+                name: "account_type";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            repositorySelection: import("drizzle-orm/pg-core").PgColumn<{
+                name: "repository_selection";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            suspendedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "suspended_at";
+                tableName: "installations";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            deletedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "deleted_at";
+                tableName: "installations";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            latestEvent: import("drizzle-orm/pg-core").PgColumn<{
+                name: "latest_event";
+                tableName: "installations";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, unknown>;
+                driverParam: unknown;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+            installerUserId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "installer_user_id";
+                tableName: "installations";
+                dataType: "string";
+                columnType: "PgUUID";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "created_at";
+                tableName: "installations";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "updated_at";
+                tableName: "installations";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
+}>;
+export declare function closeDb(): void;
+//# sourceMappingURL=db.d.ts.map

package/dist/db/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAInE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAElB,CAAC;AAIF,wBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGjB;AAED,wBAAgB,OAAO,IAAI,IAAI,CAE9B"}

package/dist/db/db.js

@@ -0,0 +1,18 @@
+import { drizzle } from '@shipfox/node-drizzle';
+import { pgClient } from '@shipfox/node-postgres';
+import { githubInstallations } from './schema/installations.js';
+export const schema = {
+    githubInstallations
+};
+let _db;
+export function db() {
+    if (!_db) _db = drizzle(pgClient(), {
+        schema
+    });
+    return _db;
+}
+export function closeDb() {
+    _db = undefined;
+}
+
+//# sourceMappingURL=db.js.map

package/dist/db/db.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/db.ts"],"sourcesContent":["import {drizzle, type NodePgDatabase} from '@shipfox/node-drizzle';\nimport {pgClient} from '@shipfox/node-postgres';\nimport {githubInstallations} from './schema/installations.js';\n\nexport const schema = {\n  githubInstallations,\n};\n\nlet _db: NodePgDatabase<typeof schema> | undefined;\n\nexport function db() {\n  if (!_db) _db = drizzle(pgClient(), {schema});\n  return _db;\n}\n\nexport function closeDb(): void {\n  _db = undefined;\n}\n"],"names":["drizzle","pgClient","githubInstallations","schema","_db","db","closeDb","undefined"],"mappings":"AAAA,SAAQA,OAAO,QAA4B,wBAAwB;AACnE,SAAQC,QAAQ,QAAO,yBAAyB;AAChD,SAAQC,mBAAmB,QAAO,4BAA4B;AAE9D,OAAO,MAAMC,SAAS;IACpBD;AACF,EAAE;AAEF,IAAIE;AAEJ,OAAO,SAASC;IACd,IAAI,CAACD,KAAKA,MAAMJ,QAAQC,YAAY;QAACE;IAAM;IAC3C,OAAOC;AACT;AAEA,OAAO,SAASE;IACdF,MAAMG;AACR"}

package/dist/db/installation-token-lock.d.ts

@@ -0,0 +1,8 @@
+export type InstallationTokenLockResult<T> = {
+    acquired: true;
+    value: T;
+} | {
+    acquired: false;
+};
+export declare function withInstallationTokenLock<T>(installationId: number, fn: () => Promise<T>): Promise<InstallationTokenLockResult<T>>;
+//# sourceMappingURL=installation-token-lock.d.ts.map

package/dist/db/installation-token-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installation-token-lock.d.ts","sourceRoot":"","sources":["../../src/db/installation-token-lock.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,2BAA2B,CAAC,CAAC,IAAI;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAC,GAAG;IAAC,QAAQ,EAAE,KAAK,CAAA;CAAC,CAAC;AAE5F,wBAAgB,yBAAyB,CAAC,CAAC,EACzC,cAAc,EAAE,MAAM,EACtB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC,CAoBzC"}

package/dist/db/installation-token-lock.js

@@ -0,0 +1,37 @@
+import { sql } from 'drizzle-orm';
+import { recordInstallationTokenLockWait } from '#metrics/index.js';
+import { db } from './db.js';
+export function withInstallationTokenLock(installationId, fn) {
+    const lockKey = installationTokenLockKey(installationId);
+    return db().transaction(async (tx)=>{
+        const startedAt = Date.now();
+        const lock = await tx.execute(sql`
+      SELECT pg_try_advisory_xact_lock(${lockKey}::bigint) AS acquired
+    `);
+        const acquired = lock.rows[0]?.acquired === true;
+        if (!acquired) {
+            recordInstallationTokenLockWait(Date.now() - startedAt);
+            return {
+                acquired: false
+            };
+        }
+        try {
+            const value = await fn();
+            return {
+                acquired: true,
+                value
+            };
+        } finally{
+            recordInstallationTokenLockWait(Date.now() - startedAt);
+        }
+    });
+}
+function installationTokenLockKey(installationId) {
+    if (!Number.isSafeInteger(installationId) || installationId < 0) {
+        throw new Error(`Invalid GitHub installation id for advisory lock: ${installationId}`);
+    }
+    // Keep these exact per-installation keys away from positive advisory-lock ids.
+    return String(-BigInt(installationId) - 1n);
+}
+
+//# sourceMappingURL=installation-token-lock.js.map

package/dist/db/installation-token-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/installation-token-lock.ts"],"sourcesContent":["import {sql} from 'drizzle-orm';\nimport {recordInstallationTokenLockWait} from '#metrics/index.js';\nimport {db} from './db.js';\n\nexport type InstallationTokenLockResult<T> = {acquired: true; value: T} | {acquired: false};\n\nexport function withInstallationTokenLock<T>(\n  installationId: number,\n  fn: () => Promise<T>,\n): Promise<InstallationTokenLockResult<T>> {\n  const lockKey = installationTokenLockKey(installationId);\n  return db().transaction(async (tx) => {\n    const startedAt = Date.now();\n    const lock = await tx.execute<{acquired: boolean}>(sql`\n      SELECT pg_try_advisory_xact_lock(${lockKey}::bigint) AS acquired\n    `);\n    const acquired = lock.rows[0]?.acquired === true;\n    if (!acquired) {\n      recordInstallationTokenLockWait(Date.now() - startedAt);\n      return {acquired: false};\n    }\n\n    try {\n      const value = await fn();\n      return {acquired: true, value};\n    } finally {\n      recordInstallationTokenLockWait(Date.now() - startedAt);\n    }\n  });\n}\n\nfunction installationTokenLockKey(installationId: number): string {\n  if (!Number.isSafeInteger(installationId) || installationId < 0) {\n    throw new Error(`Invalid GitHub installation id for advisory lock: ${installationId}`);\n  }\n\n  // Keep these exact per-installation keys away from positive advisory-lock ids.\n  return String(-BigInt(installationId) - 1n);\n}\n"],"names":["sql","recordInstallationTokenLockWait","db","withInstallationTokenLock","installationId","fn","lockKey","installationTokenLockKey","transaction","tx","startedAt","Date","now","lock","execute","acquired","rows","value","Number","isSafeInteger","Error","String","BigInt"],"mappings":"AAAA,SAAQA,GAAG,QAAO,cAAc;AAChC,SAAQC,+BAA+B,QAAO,oBAAoB;AAClE,SAAQC,EAAE,QAAO,UAAU;AAI3B,OAAO,SAASC,0BACdC,cAAsB,EACtBC,EAAoB;IAEpB,MAAMC,UAAUC,yBAAyBH;IACzC,OAAOF,KAAKM,WAAW,CAAC,OAAOC;QAC7B,MAAMC,YAAYC,KAAKC,GAAG;QAC1B,MAAMC,OAAO,MAAMJ,GAAGK,OAAO,CAAsBd,GAAG,CAAC;uCACpB,EAAEM,QAAQ;IAC7C,CAAC;QACD,MAAMS,WAAWF,KAAKG,IAAI,CAAC,EAAE,EAAED,aAAa;QAC5C,IAAI,CAACA,UAAU;YACbd,gCAAgCU,KAAKC,GAAG,KAAKF;YAC7C,OAAO;gBAACK,UAAU;YAAK;QACzB;QAEA,IAAI;YACF,MAAME,QAAQ,MAAMZ;YACpB,OAAO;gBAACU,UAAU;gBAAME;YAAK;QAC/B,SAAU;YACRhB,gCAAgCU,KAAKC,GAAG,KAAKF;QAC/C;IACF;AACF;AAEA,SAASH,yBAAyBH,cAAsB;IACtD,IAAI,CAACc,OAAOC,aAAa,CAACf,mBAAmBA,iBAAiB,GAAG;QAC/D,MAAM,IAAIgB,MAAM,CAAC,kDAAkD,EAAEhB,gBAAgB;IACvF;IAEA,+EAA+E;IAC/E,OAAOiB,OAAO,CAACC,OAAOlB,kBAAkB,EAAE;AAC5C"}

package/dist/db/installations.d.ts

@@ -0,0 +1,33 @@
+export interface GithubInstallation {
+    id: string;
+    connectionId: string;
+    installationId: string;
+    accountLogin: string;
+    accountType: string;
+    repositorySelection: string;
+    suspendedAt: Date | null;
+    deletedAt: Date | null;
+    latestEvent: Record<string, unknown>;
+    installerUserId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface UpsertGithubInstallationParams {
+    connectionId: string;
+    installationId: string;
+    accountLogin: string;
+    accountType: string;
+    repositorySelection: string;
+    suspendedAt?: Date | null | undefined;
+    deletedAt?: Date | null | undefined;
+    latestEvent: Record<string, unknown>;
+    installerUserId?: string | null | undefined;
+}
+export declare function upsertGithubInstallation(params: UpsertGithubInstallationParams, options?: {
+    tx?: unknown;
+}): Promise<GithubInstallation>;
+export declare function getGithubInstallationByConnectionId(connectionId: string): Promise<GithubInstallation | undefined>;
+export declare function getGithubInstallationByInstallationId(installationId: string, options?: {
+    tx?: unknown;
+}): Promise<GithubInstallation | undefined>;
+//# sourceMappingURL=installations.d.ts.map

package/dist/db/installations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installations.d.ts","sourceRoot":"","sources":["../../src/db/installations.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,8BAA8B;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,WAAW,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC,SAAS,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAC7C;AAKD,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,8BAA8B,EACtC,OAAO,GAAE;IAAC,EAAE,CAAC,EAAE,OAAO,CAAA;CAAM,GAC3B,OAAO,CAAC,kBAAkB,CAAC,CAyC7B;AAED,wBAAsB,mCAAmC,CACvD,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC,CASzC;AAED,wBAAsB,qCAAqC,CACzD,cAAc,EAAE,MAAM,EACtB,OAAO,GAAE;IAAC,EAAE,CAAC,EAAE,OAAO,CAAA;CAAM,GAC3B,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC,CAUzC"}

package/dist/db/installations.js

@@ -0,0 +1,56 @@
+import { eq } from 'drizzle-orm';
+import { GithubInstallationAlreadyLinkedError } from '#core/errors.js';
+import { db } from './db.js';
+import { githubInstallations, toGithubInstallation } from './schema/installations.js';
+export async function upsertGithubInstallation(params, options = {}) {
+    const executor = options.tx ?? db();
+    const now = new Date();
+    const [row] = await executor.insert(githubInstallations).values({
+        connectionId: params.connectionId,
+        installationId: params.installationId,
+        accountLogin: params.accountLogin,
+        accountType: params.accountType,
+        repositorySelection: params.repositorySelection,
+        suspendedAt: params.suspendedAt ?? null,
+        deletedAt: params.deletedAt ?? null,
+        latestEvent: params.latestEvent,
+        installerUserId: params.installerUserId ?? null
+    }).onConflictDoUpdate({
+        target: githubInstallations.installationId,
+        // TOCTOU guard: only (re)point this installation at the connection that
+        // already owns it. A concurrent connect of the same installation to a
+        // different workspace inserts its own connection row, so its connectionId
+        // differs here; the predicate is false, Postgres updates nothing, and the
+        // empty RETURNING below rolls the losing transaction back instead of
+        // silently repointing the installation (cross-tenant event misroute).
+        setWhere: eq(githubInstallations.connectionId, params.connectionId),
+        set: {
+            connectionId: params.connectionId,
+            accountLogin: params.accountLogin,
+            accountType: params.accountType,
+            repositorySelection: params.repositorySelection,
+            suspendedAt: params.suspendedAt ?? null,
+            deletedAt: params.deletedAt ?? null,
+            latestEvent: params.latestEvent,
+            installerUserId: params.installerUserId ?? null,
+            updatedAt: now
+        }
+    }).returning();
+    if (!row) throw new GithubInstallationAlreadyLinkedError(params.installationId);
+    return toGithubInstallation(row);
+}
+export async function getGithubInstallationByConnectionId(connectionId) {
+    const rows = await db().select().from(githubInstallations).where(eq(githubInstallations.connectionId, connectionId)).limit(1);
+    const row = rows[0];
+    if (!row) return undefined;
+    return toGithubInstallation(row);
+}
+export async function getGithubInstallationByInstallationId(installationId, options = {}) {
+    const executor = options.tx ?? db();
+    const rows = await executor.select().from(githubInstallations).where(eq(githubInstallations.installationId, installationId)).limit(1);
+    const row = rows[0];
+    if (!row) return undefined;
+    return toGithubInstallation(row);
+}
+
+//# sourceMappingURL=installations.js.map

package/dist/db/installations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/installations.ts"],"sourcesContent":["import {eq} from 'drizzle-orm';\nimport {GithubInstallationAlreadyLinkedError} from '#core/errors.js';\nimport {db} from './db.js';\nimport {githubInstallations, toGithubInstallation} from './schema/installations.js';\n\nexport interface GithubInstallation {\n  id: string;\n  connectionId: string;\n  installationId: string;\n  accountLogin: string;\n  accountType: string;\n  repositorySelection: string;\n  suspendedAt: Date | null;\n  deletedAt: Date | null;\n  latestEvent: Record<string, unknown>;\n  installerUserId: string | null;\n  createdAt: Date;\n  updatedAt: Date;\n}\n\nexport interface UpsertGithubInstallationParams {\n  connectionId: string;\n  installationId: string;\n  accountLogin: string;\n  accountType: string;\n  repositorySelection: string;\n  suspendedAt?: Date | null | undefined;\n  deletedAt?: Date | null | undefined;\n  latestEvent: Record<string, unknown>;\n  installerUserId?: string | null | undefined;\n}\n\ntype GithubDb = ReturnType<typeof db>;\ntype GithubTx = Parameters<Parameters<GithubDb['transaction']>[0]>[0];\n\nexport async function upsertGithubInstallation(\n  params: UpsertGithubInstallationParams,\n  options: {tx?: unknown} = {},\n): Promise<GithubInstallation> {\n  const executor = (options.tx ?? db()) as GithubDb | GithubTx;\n  const now = new Date();\n  const [row] = await executor\n    .insert(githubInstallations)\n    .values({\n      connectionId: params.connectionId,\n      installationId: params.installationId,\n      accountLogin: params.accountLogin,\n      accountType: params.accountType,\n      repositorySelection: params.repositorySelection,\n      suspendedAt: params.suspendedAt ?? null,\n      deletedAt: params.deletedAt ?? null,\n      latestEvent: params.latestEvent,\n      installerUserId: params.installerUserId ?? null,\n    })\n    .onConflictDoUpdate({\n      target: githubInstallations.installationId,\n      // TOCTOU guard: only (re)point this installation at the connection that\n      // already owns it. A concurrent connect of the same installation to a\n      // different workspace inserts its own connection row, so its connectionId\n      // differs here; the predicate is false, Postgres updates nothing, and the\n      // empty RETURNING below rolls the losing transaction back instead of\n      // silently repointing the installation (cross-tenant event misroute).\n      setWhere: eq(githubInstallations.connectionId, params.connectionId),\n      set: {\n        connectionId: params.connectionId,\n        accountLogin: params.accountLogin,\n        accountType: params.accountType,\n        repositorySelection: params.repositorySelection,\n        suspendedAt: params.suspendedAt ?? null,\n        deletedAt: params.deletedAt ?? null,\n        latestEvent: params.latestEvent,\n        installerUserId: params.installerUserId ?? null,\n        updatedAt: now,\n      },\n    })\n    .returning();\n\n  if (!row) throw new GithubInstallationAlreadyLinkedError(params.installationId);\n  return toGithubInstallation(row);\n}\n\nexport async function getGithubInstallationByConnectionId(\n  connectionId: string,\n): Promise<GithubInstallation | undefined> {\n  const rows = await db()\n    .select()\n    .from(githubInstallations)\n    .where(eq(githubInstallations.connectionId, connectionId))\n    .limit(1);\n  const row = rows[0];\n  if (!row) return undefined;\n  return toGithubInstallation(row);\n}\n\nexport async function getGithubInstallationByInstallationId(\n  installationId: string,\n  options: {tx?: unknown} = {},\n): Promise<GithubInstallation | undefined> {\n  const executor = (options.tx ?? db()) as GithubDb | GithubTx;\n  const rows = await executor\n    .select()\n    .from(githubInstallations)\n    .where(eq(githubInstallations.installationId, installationId))\n    .limit(1);\n  const row = rows[0];\n  if (!row) return undefined;\n  return toGithubInstallation(row);\n}\n"],"names":["eq","GithubInstallationAlreadyLinkedError","db","githubInstallations","toGithubInstallation","upsertGithubInstallation","params","options","executor","tx","now","Date","row","insert","values","connectionId","installationId","accountLogin","accountType","repositorySelection","suspendedAt","deletedAt","latestEvent","installerUserId","onConflictDoUpdate","target","setWhere","set","updatedAt","returning","getGithubInstallationByConnectionId","rows","select","from","where","limit","undefined","getGithubInstallationByInstallationId"],"mappings":"AAAA,SAAQA,EAAE,QAAO,cAAc;AAC/B,SAAQC,oCAAoC,QAAO,kBAAkB;AACrE,SAAQC,EAAE,QAAO,UAAU;AAC3B,SAAQC,mBAAmB,EAAEC,oBAAoB,QAAO,4BAA4B;AAgCpF,OAAO,eAAeC,yBACpBC,MAAsC,EACtCC,UAA0B,CAAC,CAAC;IAE5B,MAAMC,WAAYD,QAAQE,EAAE,IAAIP;IAChC,MAAMQ,MAAM,IAAIC;IAChB,MAAM,CAACC,IAAI,GAAG,MAAMJ,SACjBK,MAAM,CAACV,qBACPW,MAAM,CAAC;QACNC,cAAcT,OAAOS,YAAY;QACjCC,gBAAgBV,OAAOU,cAAc;QACrCC,cAAcX,OAAOW,YAAY;QACjCC,aAAaZ,OAAOY,WAAW;QAC/BC,qBAAqBb,OAAOa,mBAAmB;QAC/CC,aAAad,OAAOc,WAAW,IAAI;QACnCC,WAAWf,OAAOe,SAAS,IAAI;QAC/BC,aAAahB,OAAOgB,WAAW;QAC/BC,iBAAiBjB,OAAOiB,eAAe,IAAI;IAC7C,GACCC,kBAAkB,CAAC;QAClBC,QAAQtB,oBAAoBa,cAAc;QAC1C,wEAAwE;QACxE,sEAAsE;QACtE,0EAA0E;QAC1E,0EAA0E;QAC1E,qEAAqE;QACrE,sEAAsE;QACtEU,UAAU1B,GAAGG,oBAAoBY,YAAY,EAAET,OAAOS,YAAY;QAClEY,KAAK;YACHZ,cAAcT,OAAOS,YAAY;YACjCE,cAAcX,OAAOW,YAAY;YACjCC,aAAaZ,OAAOY,WAAW;YAC/BC,qBAAqBb,OAAOa,mBAAmB;YAC/CC,aAAad,OAAOc,WAAW,IAAI;YACnCC,WAAWf,OAAOe,SAAS,IAAI;YAC/BC,aAAahB,OAAOgB,WAAW;YAC/BC,iBAAiBjB,OAAOiB,eAAe,IAAI;YAC3CK,WAAWlB;QACb;IACF,GACCmB,SAAS;IAEZ,IAAI,CAACjB,KAAK,MAAM,IAAIX,qCAAqCK,OAAOU,cAAc;IAC9E,OAAOZ,qBAAqBQ;AAC9B;AAEA,OAAO,eAAekB,oCACpBf,YAAoB;IAEpB,MAAMgB,OAAO,MAAM7B,KAChB8B,MAAM,GACNC,IAAI,CAAC9B,qBACL+B,KAAK,CAAClC,GAAGG,oBAAoBY,YAAY,EAAEA,eAC3CoB,KAAK,CAAC;IACT,MAAMvB,MAAMmB,IAAI,CAAC,EAAE;IACnB,IAAI,CAACnB,KAAK,OAAOwB;IACjB,OAAOhC,qBAAqBQ;AAC9B;AAEA,OAAO,eAAeyB,sCACpBrB,cAAsB,EACtBT,UAA0B,CAAC,CAAC;IAE5B,MAAMC,WAAYD,QAAQE,EAAE,IAAIP;IAChC,MAAM6B,OAAO,MAAMvB,SAChBwB,MAAM,GACNC,IAAI,CAAC9B,qBACL+B,KAAK,CAAClC,GAAGG,oBAAoBa,cAAc,EAAEA,iBAC7CmB,KAAK,CAAC;IACT,MAAMvB,MAAMmB,IAAI,CAAC,EAAE;IACnB,IAAI,CAACnB,KAAK,OAAOwB;IACjB,OAAOhC,qBAAqBQ;AAC9B"}

package/dist/db/migrations.d.ts

@@ -0,0 +1,2 @@
+export declare const migrationsPath: string;
+//# sourceMappingURL=migrations.d.ts.map

package/dist/db/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../src/db/migrations.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,QAAoE,CAAC"}

package/dist/db/migrations.js

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

package/dist/db/migrations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/migrations.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nexport const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');\n"],"names":["dirname","resolve","fileURLToPath","migrationsPath","url"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAY;AAC3C,SAAQC,aAAa,QAAO,WAAW;AAEvC,OAAO,MAAMC,iBAAiBF,QAAQD,QAAQE,cAAc,YAAYE,GAAG,IAAI,iBAAiB"}

package/dist/db/schema/common.d.ts

@@ -0,0 +1,2 @@
+export declare const pgTable: import("drizzle-orm/pg-core").PgTableFn<undefined>;
+//# sourceMappingURL=common.d.ts.map

package/dist/db/schema/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/db/schema/common.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,oDAA0D,CAAC"}

package/dist/db/schema/common.js

@@ -0,0 +1,4 @@
+import { pgTableCreator } from 'drizzle-orm/pg-core';
+export const pgTable = pgTableCreator((name)=>`integrations_github_${name}`);
+
+//# sourceMappingURL=common.js.map

package/dist/db/schema/common.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/common.ts"],"sourcesContent":["import {pgTableCreator} from 'drizzle-orm/pg-core';\n\nexport const pgTable = pgTableCreator((name) => `integrations_github_${name}`);\n"],"names":["pgTableCreator","pgTable","name"],"mappings":"AAAA,SAAQA,cAAc,QAAO,sBAAsB;AAEnD,OAAO,MAAMC,UAAUD,eAAe,CAACE,OAAS,CAAC,oBAAoB,EAAEA,MAAM,EAAE"}