@moneypot/hub 1.19.10 → 1.19.11

package/dist/cli/db-migrate.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { resolve } from "path";
+import { Client } from "pg";
 function printUsage() {
     console.error("\nUsage:");
     console.error("  db-migrate [userDatabaseMigrationsPath]");
@@ -22,13 +23,21 @@ async function main() {
     }
     await import("dotenv/config");
     const { runMigrations } = await import("../src/index.js");
+    const connectionString = process.env.SUPERUSER_DATABASE_URL;
+    if (!connectionString) {
+        console.error("❌ SUPERUSER_DATABASE_URL environment variable is not set");
+        process.exit(1);
+    }
     console.log("Running database migrations...");
     console.log("Hub core migrations: ✓");
     if (userDatabaseMigrationsPath) {
         console.log(`User migrations: ${userDatabaseMigrationsPath}`);
     }
+    const pgClient = new Client({ connectionString });
     try {
+        await pgClient.connect();
         await runMigrations({
+            pgClient,
             userDatabaseMigrationsPath,
         });
         console.log("✅ Database migrations completed successfully");
@@ -39,5 +48,8 @@ async function main() {
         console.error(error);
         process.exit(1);
     }
+    finally {
+        await pgClient.end();
+    }
 }
 main();

package/dist/src/db/transaction.d.ts

@@ -1,10 +1,15 @@
 import * as pg from "pg";
 declare const PgClientInTransactionBrand: unique symbol;
-export type PgClientInTransaction = pg.PoolClient & {
+export declare class RollbackFailedError extends Error {
+    readonly originalError: unknown;
+    readonly rollbackError: unknown;
+    constructor(originalError: unknown, rollbackError: unknown);
+}
+export type PgClientInTransaction = pg.ClientBase & {
     readonly [PgClientInTransactionBrand]: true;
 };
-export declare function isInTransaction(pgClient: pg.PoolClient): pgClient is PgClientInTransaction;
-export declare function assertInTransaction(pgClient: pg.PoolClient): asserts pgClient is PgClientInTransaction;
+export declare function isInTransaction(pgClient: pg.ClientBase): pgClient is PgClientInTransaction;
+export declare function assertInTransaction(pgClient: pg.ClientBase): asserts pgClient is PgClientInTransaction;
 export declare function getIsolationLevel(pgClient: PgClientInTransaction): IsolationLevel | null;
 export declare const IsolationLevel: {
     readonly READ_COMMITTED: "READ COMMITTED";
@@ -12,6 +17,8 @@ export declare const IsolationLevel: {
     readonly SERIALIZABLE: "SERIALIZABLE";
 };
 export type IsolationLevel = (typeof IsolationLevel)[keyof typeof IsolationLevel];
+export declare function withPgClientTransaction<T>(pgClient: pg.ClientBase, callback: (pgClient: PgClientInTransaction) => Promise<T>): Promise<T>;
+export declare function withPgClientTransaction<T>(pgClient: pg.ClientBase, isolationLevel: IsolationLevel, callback: (pgClient: PgClientInTransaction) => Promise<T>): Promise<T>;
 export declare function withPgPoolTransaction<T>(pool: pg.Pool, callback: (pgClient: PgClientInTransaction) => Promise<T>, retryCount?: number, maxRetries?: number): Promise<T>;
 export declare function withPgPoolTransaction<T>(pool: pg.Pool, isolationLevel: IsolationLevel, callback: (pgClient: PgClientInTransaction) => Promise<T>, retryCount?: number, maxRetries?: number): Promise<T>;
 export {};

package/dist/src/db/transaction.js

@@ -2,6 +2,16 @@ import * as pg from "pg";
 import { logger } from "../logger.js";
 import { setTimeout } from "node:timers/promises";
 const PgClientInTransactionBrand = Symbol("PgClientInTransaction");
+export class RollbackFailedError extends Error {
+    originalError;
+    rollbackError;
+    constructor(originalError, rollbackError) {
+        super("Transaction rollback failed");
+        this.originalError = originalError;
+        this.rollbackError = rollbackError;
+        this.name = "RollbackFailedError";
+    }
+}
 const PG_ERROR_CODE = {
     deadlock: "40P01",
     serializationFailure: "40001",
@@ -23,25 +33,20 @@ export const IsolationLevel = {
     REPEATABLE_READ: "REPEATABLE READ",
     SERIALIZABLE: "SERIALIZABLE",
 };
-export async function withPgPoolTransaction(pool, callbackOrIsolationLevel, callbackOrRetryCount, retryCountOrMaxRetries = 0, maxRetries = 3) {
+export async function withPgClientTransaction(pgClient, callbackOrIsolationLevel, maybeCallback) {
     let callback;
     let isolationLevel = IsolationLevel.READ_COMMITTED;
-    let retryCount = 0;
     if (typeof callbackOrIsolationLevel === "function") {
         callback = callbackOrIsolationLevel;
-        if (typeof callbackOrRetryCount === "number") {
-            retryCount = callbackOrRetryCount;
-            maxRetries = retryCountOrMaxRetries;
-        }
     }
     else {
         isolationLevel = callbackOrIsolationLevel;
-        callback = callbackOrRetryCount;
-        retryCount = retryCountOrMaxRetries;
+        if (typeof maybeCallback !== "function") {
+            throw new Error("withPgClientTransaction requires a callback function");
+        }
+        callback = maybeCallback;
     }
-    let pgClient = null;
     try {
-        pgClient = await pool.connect();
         if (isolationLevel === IsolationLevel.READ_COMMITTED) {
             await pgClient.query("BEGIN");
         }
@@ -55,39 +60,65 @@ export async function withPgPoolTransaction(pool, callbackOrIsolationLevel, call
         return result;
     }
     catch (error) {
-        if (pgClient) {
+        if (SIDECAR.has(pgClient)) {
             try {
                 await pgClient.query("ROLLBACK");
             }
             catch (rollbackError) {
                 logger.error(error, "Original error");
                 logger.error(rollbackError, "Rollback failed");
-                SIDECAR.delete(pgClient);
-                pgClient.release(true);
-                pgClient = null;
-                throw error;
-            }
-            if (retryCount < maxRetries &&
-                error instanceof pg.DatabaseError &&
-                (error.code === PG_ERROR_CODE.deadlock ||
-                    error.code === PG_ERROR_CODE.serializationFailure)) {
-                const backoffMs = Math.min(100 * Math.pow(2, retryCount), 2000);
-                logger.warn(`Retrying transaction in ${Math.floor(backoffMs)}ms (attempt ${retryCount + 2}/${maxRetries + 1}) due to pg error code ${error.code}: ${error.message}`);
-                await setTimeout(backoffMs);
-                if (isolationLevel === IsolationLevel.READ_COMMITTED) {
-                    return withPgPoolTransaction(pool, callback, retryCount + 1, maxRetries);
-                }
-                else {
-                    return withPgPoolTransaction(pool, isolationLevel, callback, retryCount + 1, maxRetries);
-                }
+                throw new RollbackFailedError(error, rollbackError);
             }
         }
         throw error;
     }
     finally {
-        if (pgClient) {
-            SIDECAR.delete(pgClient);
+        SIDECAR.delete(pgClient);
+    }
+}
+export async function withPgPoolTransaction(pool, callbackOrIsolationLevel, callbackOrRetryCount, retryCountOrMaxRetries = 0, maxRetries = 3) {
+    let callback;
+    let isolationLevel = IsolationLevel.READ_COMMITTED;
+    let retryCount = 0;
+    if (typeof callbackOrIsolationLevel === "function") {
+        callback = callbackOrIsolationLevel;
+        if (typeof callbackOrRetryCount === "number") {
+            retryCount = callbackOrRetryCount;
+            maxRetries = retryCountOrMaxRetries;
+        }
+    }
+    else {
+        isolationLevel = callbackOrIsolationLevel;
+        if (typeof callbackOrRetryCount !== "function") {
+            throw new Error("withPgPoolTransaction requires a callback function");
+        }
+        callback = callbackOrRetryCount;
+        retryCount = retryCountOrMaxRetries;
+    }
+    let pgClient = await pool.connect();
+    try {
+        return await withPgClientTransaction(pgClient, isolationLevel, callback);
+    }
+    catch (error) {
+        if (error instanceof RollbackFailedError) {
+            pgClient.release(true);
+            pgClient = null;
+            throw error.originalError;
+        }
+        if (retryCount < maxRetries &&
+            error instanceof pg.DatabaseError &&
+            (error.code === PG_ERROR_CODE.deadlock ||
+                error.code === PG_ERROR_CODE.serializationFailure)) {
+            const backoffMs = Math.min(100 * Math.pow(2, retryCount), 2000);
+            logger.warn(`Retrying transaction in ${Math.floor(backoffMs)}ms (attempt ${retryCount + 2}/${maxRetries + 1}) due to pg error code ${error.code}: ${error.message}`);
             pgClient.release();
+            pgClient = null;
+            await setTimeout(backoffMs);
+            return withPgPoolTransaction(pool, isolationLevel, callback, retryCount + 1, maxRetries);
         }
+        throw error;
+    }
+    finally {
+        pgClient?.release();
     }
 }

package/dist/src/index.js

@@ -1,5 +1,6 @@
 import { NODE_ENV, PORT, SUPERUSER_DATABASE_URL, DATABASE_URL, } from "./config.js";
 import { logger } from "./logger.js";
+import { getPgClient } from "./db/index.js";
 import { createHubServer } from "./server/index.js";
 export { HubGameConfigPlugin, } from "./plugins/hub-game-config-plugin.js";
 export { validateRisk, } from "./risk-policy.js";
@@ -21,9 +22,17 @@ function validateOptions(options) {
 }
 export async function startAndListen(options) {
     validateOptions(options);
-    await runMigrations({
-        userDatabaseMigrationsPath: options.userDatabaseMigrationsPath,
-    });
+    const pgClient = getPgClient(options.superuserDatabaseUrl ?? SUPERUSER_DATABASE_URL);
+    await pgClient.connect();
+    try {
+        await runMigrations({
+            pgClient,
+            userDatabaseMigrationsPath: options.userDatabaseMigrationsPath,
+        });
+    }
+    finally {
+        await pgClient.end();
+    }
     const hubServer = createHubServer({
         superuserDatabaseUrl: options.superuserDatabaseUrl ?? SUPERUSER_DATABASE_URL,
         postgraphileDatabaseUrl: options.postgraphileDatabaseUrl ?? DATABASE_URL,

package/dist/src/migrations.d.ts

@@ -1,4 +1,5 @@
+import { type Client } from "pg";
 export declare function runMigrations(options: {
+    pgClient: Client;
     userDatabaseMigrationsPath?: string;
-    superuserDatabaseUrl?: string;
 }): Promise<void>;

package/dist/src/migrations.js

@@ -1,11 +1,10 @@
 import PgUpgradeSchema, { DatabaseAheadError, } from "@moneypot/pg-upgrade-schema";
-import * as db from "./db/index.js";
-import * as config from "./config.js";
 import { join } from "path";
 import { logger } from "./logger.js";
+import { existsSync, statSync } from "fs";
 export async function runMigrations(options) {
+    const { pgClient } = options;
     if (options.userDatabaseMigrationsPath) {
-        const { existsSync, statSync } = await import("fs");
         if (!existsSync(options.userDatabaseMigrationsPath)) {
             throw new Error(`userDatabaseMigrationsPath does not exist: ${options.userDatabaseMigrationsPath}`);
         }
@@ -14,38 +13,28 @@ export async function runMigrations(options) {
             throw new Error(`userDatabaseMigrationsPath is not a directory: ${options.userDatabaseMigrationsPath}`);
         }
     }
-    const superuserDatabaseUrl = options.superuserDatabaseUrl ??
-        process.env.SUPERUSER_DATABASE_URL ??
-        config.SUPERUSER_DATABASE_URL;
-    const pgClient = db.getPgClient(superuserDatabaseUrl);
-    await pgClient.connect();
     try {
-        try {
-            await PgUpgradeSchema.default({
-                pgClient,
-                dirname: join(import.meta.dirname, "pg-versions"),
-                schemaName: "hub_core_versions",
-                silent: process.env.NODE_ENV === "test",
-            });
-        }
-        catch (e) {
-            logger.error(e, "Error upgrading core schema");
-            if (e instanceof DatabaseAheadError) {
-                logger.error(`${"⚠️".repeat(10)}\n@moneypot/hub database was reset to prepare for a production release and you must reset your database to continue. Please see <https://www.npmjs.com/package/@moneypot/hub#change-log> for more info.`);
-                process.exit(1);
-            }
-            throw e;
-        }
-        if (options.userDatabaseMigrationsPath) {
-            await PgUpgradeSchema.default({
-                pgClient,
-                dirname: options.userDatabaseMigrationsPath,
-                schemaName: "hub_user_versions",
-                silent: process.env.NODE_ENV === "test",
-            });
+        await PgUpgradeSchema.default({
+            pgClient,
+            dirname: join(import.meta.dirname, "pg-versions"),
+            schemaName: "hub_core_versions",
+            silent: process.env.NODE_ENV === "test",
+        });
+    }
+    catch (e) {
+        logger.error(e, "Error upgrading core schema");
+        if (e instanceof DatabaseAheadError) {
+            logger.error(`${"⚠️".repeat(10)}\n@moneypot/hub database was reset to prepare for a production release and you must reset your database to continue. Please see <https://www.npmjs.com/package/@moneypot/hub#change-log> for more info.`);
+            process.exit(1);
         }
+        throw e;
     }
-    finally {
-        await pgClient.end();
+    if (options.userDatabaseMigrationsPath) {
+        await PgUpgradeSchema.default({
+            pgClient,
+            dirname: options.userDatabaseMigrationsPath,
+            schemaName: "hub_user_versions",
+            silent: process.env.NODE_ENV === "test",
+        });
     }
 }

package/dist/src/services/jwt-service.d.ts

@@ -1,8 +1,8 @@
-import { PoolClient } from "pg";
+import { ClientBase } from "pg";
 import { GraphQLClient } from "graphql-request";
 import { Result } from "../util.js";
 import { QueryExecutor } from "../db/index.js";
-export declare function verifyJwtFromDbCacheAndEnsureNotAlreadyUsed(pgClient: PoolClient, { casinoId, jwt, }: {
+export declare function verifyJwtFromDbCacheAndEnsureNotAlreadyUsed(pgClient: ClientBase, { casinoId, jwt, }: {
     casinoId: string;
     jwt: string;
 }): Promise<Result<{

package/dist/src/test/index.js

@@ -1,4 +1,4 @@
-import { Pool } from "pg";
+import { Client, Pool } from "pg";
 import { randomBytes, randomUUID } from "node:crypto";
 import { execSync } from "node:child_process";
 import { DbHashKind, } from "../db/types.js";
@@ -35,10 +35,17 @@ export async function startTestServer({ plugins = [...defaultPlugins], userDatab
     process.env.LOG_LEVEL = process.env.LOG_LEVEL ?? "error";
     process.env.HASHCHAINSERVER_URL = "mock-server";
     process.env.HASHCHAINSERVER_APPLICATION_SECRET = "test-secret";
-    await runMigrations({
-        userDatabaseMigrationsPath,
-        superuserDatabaseUrl: connectionString,
-    });
+    const pgClient = new Client({ connectionString });
+    await pgClient.connect();
+    try {
+        await runMigrations({
+            pgClient,
+            userDatabaseMigrationsPath,
+        });
+    }
+    finally {
+        await pgClient.end();
+    }
     const hubServer = createHubServer({
         port: 0,
         plugins,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.19.10",
+  "version": "1.19.11",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [