@moneypot/hub 1.16.0-dev.7 → 1.17.0-dev.1

package/README.md

@@ -75,7 +75,7 @@ insert into hub.api_key default values returning key;
 
 ## Changelog
 
-You should always keep your hub server up to date as soon as possible.
+You should always keep your hub server up to date as soon as possible. Never install an old, intermediate version: it may leave you without an automatic upgrade path.
 
 ### 1.16.x
 

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

@@ -2,21 +2,19 @@ import * as pg from "pg";
 import stream from "node:stream";
 import { DbCasino, DbExperience, DbSession, DbTransferStatusKind, DbUser, DbWithdrawal } from "./types.js";
 import { TransferStatusKind } from "../__generated__/graphql.js";
+import { PgClientInTransaction } from "./transaction.js";
 export * from "../hash-chain/db-hash-chain.js";
 export * from "./types.js";
 export * from "./public.js";
 export * from "./util.js";
 export declare function getPgClient(connectionString: string): InstanceType<typeof pg.Client>;
+export * from "./transaction.js";
 export interface QueryExecutor {
     query<T extends pg.QueryResultRow = any>(queryText: string, values?: any[]): Promise<pg.QueryResult<T>>;
 }
 export declare class UserFriendlyError extends Error {
     constructor(userFriendlyMessage: string);
 }
-export type PgClientInTransaction = pg.PoolClient & {
-    _inTransaction: true;
-};
-export declare function withPgPoolTransaction<T>(pool: pg.Pool, callback: (_pgClient: PgClientInTransaction) => Promise<T>, retryCount?: number, maxRetries?: number): Promise<T>;
 export declare function userFromActiveSessionKey(pgClient: QueryExecutor, sessionKey: string): Promise<{
     user: DbUser;
     sessionId: DbSession["id"];

package/dist/src/db/index.js

@@ -2,9 +2,9 @@ import * as pg from "pg";
 import stream from "node:stream";
 import { exactlyOneRow, maybeOneRow } from "./util.js";
 import { logger } from "../logger.js";
-import { setTimeout } from "node:timers/promises";
 import { assert } from "tsafe";
 import { insertAuditLog } from "../audit-log.js";
+import { withPgPoolTransaction } from "./transaction.js";
 export * from "../hash-chain/db-hash-chain.js";
 export * from "./types.js";
 export * from "./public.js";
@@ -13,61 +13,13 @@ export function getPgClient(connectionString) {
     const client = new pg.Client({ connectionString });
     return client;
 }
+export * from "./transaction.js";
 export class UserFriendlyError extends Error {
     constructor(userFriendlyMessage) {
         super(userFriendlyMessage);
         this.name = "UserFriendlyError";
     }
 }
-const PG_ERROR_CODE = {
-    deadlock: "40P01",
-    serializationFailure: "40001",
-};
-export async function withPgPoolTransaction(pool, callback, retryCount = 0, maxRetries = 3) {
-    let pgClient = null;
-    try {
-        pgClient = await pool.connect();
-        await pgClient.query("begin isolation level serializable");
-        Object.defineProperty(pgClient, "_inTransaction", {
-            value: true,
-            writable: false,
-            enumerable: false,
-            configurable: false,
-        });
-        const result = await callback(pgClient);
-        await pgClient.query("commit");
-        return result;
-    }
-    catch (error) {
-        if (pgClient) {
-            try {
-                await pgClient.query("rollback");
-            }
-            catch (rollbackError) {
-                logger.error(error, "Original error");
-                logger.error(rollbackError, "Rollback failed");
-                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);
-                return withPgPoolTransaction(pool, callback, retryCount + 1, maxRetries);
-            }
-        }
-        throw error;
-    }
-    finally {
-        if (pgClient) {
-            pgClient.release();
-        }
-    }
-}
 export async function userFromActiveSessionKey(pgClient, sessionKey) {
     const result = await pgClient
         .query(`
@@ -235,7 +187,6 @@ export async function insertDeposit(pool, o) {
     });
 }
 export async function processWithdrawal(pgClient, { casinoId, mpTransferId, userId, experienceId, amount, currency, status, }) {
-    assert(pgClient._inTransaction, "pgClient must be in transaction");
     await pgClient.query(`
       INSERT INTO hub.withdrawal (
         casino_id, 

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

@@ -0,0 +1,17 @@
+import * as pg from "pg";
+declare const PgClientInTransactionBrand: unique symbol;
+export type PgClientInTransaction = pg.PoolClient & {
+    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 getIsolationLevel(pgClient: PgClientInTransaction): IsolationLevel | null;
+export declare const IsolationLevel: {
+    readonly READ_COMMITTED: "READ COMMITTED";
+    readonly REPEATABLE_READ: "REPEATABLE READ";
+    readonly SERIALIZABLE: "SERIALIZABLE";
+};
+export type IsolationLevel = (typeof IsolationLevel)[keyof typeof IsolationLevel];
+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

@@ -0,0 +1,93 @@
+import * as pg from "pg";
+import { logger } from "../logger.js";
+import { setTimeout } from "node:timers/promises";
+const PgClientInTransactionBrand = Symbol("PgClientInTransaction");
+const PG_ERROR_CODE = {
+    deadlock: "40P01",
+    serializationFailure: "40001",
+};
+const SIDECAR = new WeakMap();
+export function isInTransaction(pgClient) {
+    return SIDECAR.has(pgClient);
+}
+export function assertInTransaction(pgClient) {
+    if (!isInTransaction(pgClient)) {
+        throw new Error("Must be called inside a transaction");
+    }
+}
+export function getIsolationLevel(pgClient) {
+    return SIDECAR.get(pgClient) ?? null;
+}
+export const IsolationLevel = {
+    READ_COMMITTED: "READ COMMITTED",
+    REPEATABLE_READ: "REPEATABLE READ",
+    SERIALIZABLE: "SERIALIZABLE",
+};
+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;
+        callback = callbackOrRetryCount;
+        retryCount = retryCountOrMaxRetries;
+    }
+    let pgClient = null;
+    try {
+        pgClient = await pool.connect();
+        if (isolationLevel === IsolationLevel.READ_COMMITTED) {
+            await pgClient.query("BEGIN");
+        }
+        else {
+            await pgClient.query(`BEGIN ISOLATION LEVEL ${isolationLevel}`);
+        }
+        SIDECAR.set(pgClient, isolationLevel);
+        assertInTransaction(pgClient);
+        const result = await callback(pgClient);
+        await pgClient.query("COMMIT");
+        return result;
+    }
+    catch (error) {
+        if (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 error;
+    }
+    finally {
+        if (pgClient) {
+            SIDECAR.delete(pgClient);
+            pgClient.release();
+        }
+    }
+}

package/dist/src/hash-chain/db-hash-chain.js

@@ -3,7 +3,6 @@ import { exactlyOneRow, maybeOneRow, } from "../db/index.js";
 import { assert } from "tsafe";
 import { logger } from "../logger.js";
 export async function dbLockHubHashChain(pgClient, { userId, experienceId, casinoId, hashChainId, }) {
-    assert(pgClient._inTransaction, "dbLockHubHashChain must be called in a transaction");
     const hashChain = await pgClient
         .query(`
        SELECT * 
@@ -32,7 +31,6 @@ export async function dbInsertHubHash(pgClient, { hashChainId, kind, digest, ite
         metadata,
         digest: Buffer.from(digest).toString("base64"),
     }, "[dbInsertHubHash] Inserting hash");
-    assert(pgClient._inTransaction, "dbInsertHash must be called in a transaction");
     if (kind === DbHashKind.INTERMEDIATE) {
         assert(typeof clientSeed === "string", "clientSeed must be provided for INTERMEDIATE hashes");
     }

package/dist/src/hash-chain/reveal-hash-chain.js

@@ -2,9 +2,7 @@ import { logger } from "../logger.js";
 import { getPreimageHash } from "./get-hash.js";
 import { DbHashKind } from "../db/types.js";
 import { dbInsertHubHash } from "../db/index.js";
-import { assert } from "tsafe";
 export async function dbRevealHashChain(pgClient, { hashChainId, }) {
-    assert(pgClient._inTransaction, "dbRevealHashChain must be called in a transaction");
     logger.debug({ hashChainId }, "Revealing hash chain");
     const preimageHashResult = await getPreimageHash({
         hashChainId,

package/dist/src/pg-advisory-lock.js

@@ -1,4 +1,3 @@
-import { assert } from "tsafe";
 var LockNamespace;
 (function (LockNamespace) {
     LockNamespace[LockNamespace["MP_TAKE_REQUEST"] = 1] = "MP_TAKE_REQUEST";
@@ -26,15 +25,12 @@ async function acquireAdvisoryLock(pgClient, namespace, hash) {
 }
 export const PgAdvisoryLock = {
     forMpTakeRequestProcessing: async (pgClient, params) => {
-        assert(pgClient._inTransaction, "pgClient must be in a transaction");
         await acquireAdvisoryLock(pgClient, LockNamespace.MP_TAKE_REQUEST, createHashKey(params.mpTakeRequestId, params.casinoId));
     },
     forNewHashChain: async (pgClient, params) => {
-        assert(pgClient._inTransaction, "pgClient must be in a transaction");
         await acquireAdvisoryLock(pgClient, LockNamespace.NEW_HASH_CHAIN, createHashKey(params.userId, params.experienceId, params.casinoId));
     },
     forChatPlayerAction: async (pgClient, params) => {
-        assert(pgClient._inTransaction, "pgClient must be in a transaction");
         await acquireAdvisoryLock(pgClient, LockNamespace.CHAT_PLAYER_ACTION, createHashKey(params.userId, params.experienceId, params.casinoId));
     },
     forChatModManagement: async (pgClient, params) => {

package/dist/src/pg-versions/013-chat.sql

@@ -1,16 +1,15 @@
-
 -- A simple single-room chat system
 
 -- Quick revert:
-drop table if exists hub.chat_message;
-drop view if exists hub.active_chat_mute;
-drop table if exists hub.chat_mute;
-drop table if exists hub.chat_rate_bucket;
-drop table if exists hub.chat_mod;
-drop type if exists hub.chat_message_type;
-alter table hub.experience drop column if exists user_id;
-alter table hub.user drop column if exists client_id;
-alter table hub.experience drop column if exists client_id;
+-- drop table if exists hub.chat_message;
+-- drop view if exists hub.active_chat_mute;
+-- drop table if exists hub.chat_mute;
+-- drop table if exists hub.chat_rate_bucket;
+-- drop table if exists hub.chat_mod;
+-- drop type if exists hub.chat_message_type;
+-- alter table hub.experience drop column if exists user_id;
+-- alter table hub.user drop column if exists client_id;
+-- alter table hub.experience drop column if exists client_id;
 
 -- New helper function for RLS so we don't have to do a subquery
 create or replace function hub_hidden.is_experience_owner() returns boolean as $$

package/dist/src/process-transfers/polling-processor.js

@@ -4,7 +4,6 @@ import { assert } from "tsafe";
 import { isUuid } from "../util.js";
 import { createGraphqlClient } from "../graphql-client.js";
 import { GET_CURRENCIES } from "../graphql-queries.js";
-import { processWithdrawalRequests } from "../process-withdrawal-request.js";
 import { processTakeRequests } from "../take-request/process-take-request.js";
 import * as jwtService from "../services/jwt-service.js";
 import { dbGetCasinoById, dbGetCasinoSecretById } from "../db/internal.js";
@@ -230,11 +229,6 @@ async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoIn
     let hasNextPage = true;
     const timeout = (ms) => new Promise((res) => setTimeout(res, ms));
     while (hasNextPage && !signal.aborted) {
-        await processWithdrawalRequests({
-            casinoId: casinoInfo.id,
-            graphqlClient,
-            pool,
-        });
         if (signal.aborted) {
             logger.info(`[processTransfersUntilEmpty] Aborted by graceful shutdown.`);
             break;

package/dist/src/process-transfers/process-transfer.js

@@ -107,6 +107,21 @@ export async function processTransfer({ casinoId, controllerId, transfer, graphq
                 }
                 logger.debug(data, "MP_CLAIM_TRANSFER response");
                 if (data.claimTransfer?.result.__typename !== "ClaimTransferSuccess") {
+                    if (data.claimTransfer?.result.__typename ===
+                        "InvalidTransferStatus" &&
+                        data.claimTransfer?.result.currentStatus ===
+                            TransferStatusKind.Completed) {
+                        logger.info(`Transfer ${transfer.id} already claimed (status: COMPLETED), skipping claim but attempting deposit insert`);
+                        await db.insertDeposit(pool, {
+                            casinoId,
+                            mpTransferId: transfer.id,
+                            userId: dbSender.id,
+                            experienceId: dbExperience.id,
+                            amount: transfer.amount,
+                            currency: currency.id,
+                        });
+                        return;
+                    }
                     throw new Error(`Failed to claim transfer: ${JSON.stringify(data.claimTransfer)}`);
                 }
                 await db.insertDeposit(pool, {

package/dist/src/take-request/process-take-request.js

@@ -243,7 +243,6 @@ export async function processSingleTakeRequest({ mpTakeRequestId, mpTakeRequest,
     });
 }
 async function createAndProcessNewTakeRequest({ pgClient, mpTakeRequest, casinoId, graphqlClient, }) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     assert(mpTakeRequest.status === MpTakeRequestStatus.Pending);
     const { dbUser, dbExperience, dbCurrency, dbBalance } = await loadRequiredEntities(pgClient, {
         type: "mpId",
@@ -327,7 +326,6 @@ async function createAndProcessNewTakeRequest({ pgClient, mpTakeRequest, casinoI
     });
 }
 async function processExistingTakeRequest({ pgClient, takeRequest, casinoId, graphqlClient, }) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     switch (takeRequest.status) {
         case LocalTakeRequestStatus.PENDING:
             logger.info(`[processExistingTakeRequest] Take request ${takeRequest.id} in PENDING state`);
@@ -371,7 +369,6 @@ async function processExistingTakeRequest({ pgClient, takeRequest, casinoId, gra
     return null;
 }
 async function attemptTransfer({ pgClient, takeRequestId, mpTakeRequestId, mpExperienceId, mpUserId, amount, currencyKey, graphqlClient, }) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     try {
         const transferResult = await graphqlClient.request(MP_TRANSFER_TAKE_REQUEST, {
             mpTakeRequestId,
@@ -740,7 +737,6 @@ async function processStuckRequests({ casinoId, graphqlClient, abortSignal, pool
 }
 async function loadRequiredEntities(pgClient, params) {
     const { type, currencyKey, casinoId } = params;
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     const dbCurrency = await pgClient
         .query({
         text: `
@@ -839,7 +835,6 @@ async function loadRequiredEntities(pgClient, params) {
     return { dbCurrency, dbUser, dbExperience, dbBalance };
 }
 async function rejectMpTakeRequest(pgClient, graphqlClient, mpTakeRequestId, takeRequestId) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     try {
         logger.info(`[rejectMpTakeRequest] Rejecting take request ${mpTakeRequestId}`);
         const rejectResult = await graphqlClient.request(MP_REJECT_TAKE_REQUEST, {
@@ -916,7 +911,6 @@ async function rejectMpTakeRequest(pgClient, graphqlClient, mpTakeRequestId, tak
     }
 }
 async function updateTakeRequestStatus(pgClient, takeRequestId, status) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     return pgClient.query({
         text: `
       UPDATE hub.take_request

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.16.0-dev.7",
+  "version": "1.17.0-dev.1",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [