@moneypot/hub 1.9.0 → 1.10.0-dev.1

package/dist/cli/add-casino.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { z } from "zod";
 import { dbInsertCasino } from "../src/db/internal.js";
-import { superuserPool, upsertCurrencies } from "../src/db/index.js";
+import { upsertCurrencies } from "../src/db/index.js";
 import { createGraphqlClient } from "../src/graphql-client.js";
 import { GET_CURRENCIES } from "../src/graphql-queries.js";
 import { gql } from "../src/__generated__/gql.js";
+import { createServerContext, closeServerContext } from "../src/context.js";
 const GET_CURRENT_CONTROLLER = gql(`
   query AddCasino_GetCurrentController {
     currentController {
@@ -66,24 +67,30 @@ function parseArgs(args) {
     return parsedArgs;
 }
 async function addCasino(input) {
-    const graphqlClient = createGraphqlClient({
-        graphqlUrl: input.graphql_url,
-        apiKey: input.api_key,
-    });
-    console.log(`Verifying controller creds with ${input.graphql_url}...`);
-    const result1 = await graphqlClient.request(GET_CURRENT_CONTROLLER);
-    if (!result1.currentController) {
-        throw new Error("Bad controller ID or API key");
+    const context = createServerContext();
+    try {
+        const graphqlClient = createGraphqlClient({
+            graphqlUrl: input.graphql_url,
+            apiKey: input.api_key,
+        });
+        console.log(`Verifying controller creds with ${input.graphql_url}...`);
+        const result1 = await graphqlClient.request(GET_CURRENT_CONTROLLER);
+        if (!result1.currentController) {
+            throw new Error("Bad controller ID or API key");
+        }
+        const result2 = await graphqlClient.request(GET_CURRENCIES);
+        const currencies = result2.allCurrencies?.nodes.flatMap((x) => (x ? [x] : [])) || [];
+        console.log(`Found ${currencies.length} currencies:`, currencies.map((x) => x.id).join(", "));
+        const fields = { ...input, controller_id: result1.currentController.id };
+        const casino = await dbInsertCasino(context.superuserPool, fields);
+        if (currencies.length > 0) {
+            await upsertCurrencies(context.superuserPool, { casinoId: casino.id, currencies });
+        }
+        return casino;
     }
-    const result2 = await graphqlClient.request(GET_CURRENCIES);
-    const currencies = result2.allCurrencies?.nodes.flatMap((x) => (x ? [x] : [])) || [];
-    console.log(`Found ${currencies.length} currencies:`, currencies.map((x) => x.id).join(", "));
-    const fields = { ...input, controller_id: result1.currentController.id };
-    const casino = await dbInsertCasino(superuserPool, fields);
-    if (currencies.length > 0) {
-        await upsertCurrencies(superuserPool, { casinoId: casino.id, currencies });
+    finally {
+        await closeServerContext(context);
     }
-    return casino;
 }
 function printUsageExample() {
     console.error("\nUsage example:");

package/dist/src/context.d.ts

@@ -0,0 +1,12 @@
+import * as pg from "pg";
+import { DatabaseNotifier } from "./db/index.js";
+export interface ServerContext {
+    postgraphilePool: pg.Pool;
+    superuserPool: pg.Pool;
+    notifier: DatabaseNotifier;
+}
+export declare function createServerContext(overrides?: {
+    superuserDatabaseUrl?: string;
+    postgraphileDatabaseUrl?: string;
+}): ServerContext;
+export declare function closeServerContext(context: ServerContext): Promise<void>;

package/dist/src/context.js

@@ -0,0 +1,31 @@
+import * as pg from "pg";
+import * as config from "./config.js";
+import { logger } from "./logger.js";
+import { DatabaseNotifier } from "./db/index.js";
+export function createServerContext(overrides) {
+    const postgraphileDatabaseUrl = overrides?.postgraphileDatabaseUrl ?? config.DATABASE_URL;
+    const superuserDatabaseUrl = overrides?.superuserDatabaseUrl ?? config.SUPERUSER_DATABASE_URL;
+    const context = {
+        postgraphilePool: new pg.Pool({
+            connectionString: postgraphileDatabaseUrl,
+        }),
+        superuserPool: new pg.Pool({
+            connectionString: superuserDatabaseUrl,
+        }),
+        notifier: new DatabaseNotifier(postgraphileDatabaseUrl),
+    };
+    return context;
+}
+export async function closeServerContext(context) {
+    try {
+        await Promise.all([
+            context.notifier.close(),
+            context.postgraphilePool.end(),
+            context.superuserPool.end(),
+        ]);
+    }
+    catch (err) {
+        logger.warn(err, "Error closing server context resources");
+        throw err;
+    }
+}

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

@@ -7,8 +7,6 @@ export * from "./types.js";
 export * from "./public.js";
 export * from "./util.js";
 export declare function getPgClient(connectionString: string): InstanceType<typeof pg.Client>;
-export declare const postgraphilePool: pg.Pool;
-export declare const superuserPool: pg.Pool;
 export interface QueryExecutor {
     query<T extends pg.QueryResultRow = any>(queryText: string, values?: any[]): Promise<pg.QueryResult<T>>;
 }
@@ -23,13 +21,12 @@ export declare function userFromActiveSessionKey(pgClient: QueryExecutor, sessio
     user: DbUser;
     sessionId: DbSession["id"];
 } | null>;
-declare class DatabaseNotifier extends stream.EventEmitter {
+export declare class DatabaseNotifier extends stream.EventEmitter {
     private pgClient;
     constructor(connectionString: string);
     close(): Promise<void>;
     listen(): Promise<void>;
 }
-export declare const notifier: DatabaseNotifier;
 export declare function getTransferCursor(pgClient: QueryExecutor, { casinoId, }: {
     casinoId: string;
 }): Promise<string | undefined>;
@@ -47,7 +44,7 @@ export declare function upsertExperience(pgClient: QueryExecutor, { casinoId, mp
     mpExperienceId: string;
     name: string;
 }): Promise<DbExperience>;
-export declare function insertDeposit(o: {
+export declare function insertDeposit(pool: pg.Pool, o: {
     casinoId: string;
     mpTransferId: string;
     userId: string;
@@ -78,7 +75,7 @@ export declare function getPendingWithdrawals(pgClient: QueryExecutor, { casinoI
     mp_experience_id: string;
     mp_user_id: string;
 })[]>;
-export declare function settleWithdrawal({ withdrawalId, newStatus, }: {
+export declare function settleWithdrawal(pool: pg.Pool, { withdrawalId, newStatus, }: {
     withdrawalId: string;
     newStatus: Extract<DbTransferStatusKind, "COMPLETED" | "CANCELED">;
 }): Promise<void>;

package/dist/src/db/index.js

@@ -1,5 +1,4 @@
 import * as pg from "pg";
-import * as config from "../config.js";
 import stream from "node:stream";
 import { exactlyOneRow, maybeOneRow } from "./util.js";
 import { logger } from "../logger.js";
@@ -13,12 +12,6 @@ export function getPgClient(connectionString) {
     const client = new pg.Client({ connectionString });
     return client;
 }
-export const postgraphilePool = new pg.Pool({
-    connectionString: config.DATABASE_URL,
-});
-export const superuserPool = new pg.Pool({
-    connectionString: config.SUPERUSER_DATABASE_URL,
-});
 export class UserFriendlyError extends Error {
     constructor(userFriendlyMessage) {
         super(userFriendlyMessage);
@@ -93,7 +86,7 @@ export async function userFromActiveSessionKey(pgClient, sessionKey) {
         sessionId: session_id,
     };
 }
-class DatabaseNotifier extends stream.EventEmitter {
+export class DatabaseNotifier extends stream.EventEmitter {
     pgClient;
     constructor(connectionString) {
         super();
@@ -124,7 +117,6 @@ class DatabaseNotifier extends stream.EventEmitter {
         });
     }
 }
-export const notifier = new DatabaseNotifier(config.DATABASE_URL);
 export async function getTransferCursor(pgClient, { casinoId, }) {
     const row = await pgClient
         .query("select cursor from hub_hidden.transfer_cursor where casino_id = $1", [casinoId])
@@ -175,11 +167,11 @@ export async function upsertExperience(pgClient, { casinoId, mpExperienceId, nam
         `, [casinoId, mpExperienceId, name])
         .then(exactlyOneRow);
 }
-export async function insertDeposit(o) {
+export async function insertDeposit(pool, o) {
     if (o.amount <= 0) {
         throw new UserFriendlyError("amount must be positive");
     }
-    return withPgPoolTransaction(superuserPool, async (client) => {
+    return withPgPoolTransaction(pool, async (client) => {
         const result = await client.query(`
         INSERT INTO hub.deposit(casino_id, mp_transfer_id, user_id, experience_id, amount, currency_key)
         VALUES ($1, $2, $3, $4, $5, $6)
@@ -268,8 +260,8 @@ export async function getPendingWithdrawals(pgClient, { casinoId, limit, }) {
     `, [casinoId, limit]);
     return result.rows;
 }
-export async function settleWithdrawal({ withdrawalId, newStatus, }) {
-    return withPgPoolTransaction(superuserPool, async (pgClient) => {
+export async function settleWithdrawal(pool, { withdrawalId, newStatus, }) {
+    return withPgPoolTransaction(pool, async (pgClient) => {
         const dbWithdrawal = await pgClient
             .query(`
         select * 

package/dist/src/hash-chain/plugins/hub-create-hash-chain.js

@@ -2,7 +2,7 @@ import { context, object, sideEffect } from "@moneypot/hub/grafast";
 import { gql, makeExtendSchemaPlugin } from "@moneypot/hub/graphile";
 import { GraphQLError } from "graphql";
 import { PgAdvisoryLock } from "../../pg-advisory-lock.js";
-import { exactlyOneRow, superuserPool, withPgPoolTransaction, } from "@moneypot/hub/db";
+import { exactlyOneRow, withPgPoolTransaction } from "@moneypot/hub/db";
 import * as HashCommon from "../get-hash.js";
 import { DbHashKind } from "../../db/types.js";
 import * as config from "../../config.js";
@@ -23,7 +23,8 @@ export const HubCreateHashChainPlugin = makeExtendSchemaPlugin((build) => {
                 plans: {
                     hubCreateHashChain: () => {
                         const $identity = context().get("identity");
-                        const $hashChainId = sideEffect([$identity], ([identity]) => {
+                        const $superuserPool = context().get("superuserPool");
+                        const $hashChainId = sideEffect([$identity, $superuserPool], ([identity, superuserPool]) => {
                             if (identity?.kind !== "user") {
                                 throw new GraphQLError("Unauthorized");
                             }

package/dist/src/index.d.ts

@@ -1,10 +1,12 @@
 import { Express } from "express";
 import { type PluginIdentity } from "./server/graphile.config.js";
+import { ServerContext } from "./context.js";
 declare global {
     namespace Grafast {
         interface Context {
             identity?: PluginIdentity;
             abortSignal: AbortSignal;
+            superuserPool: ServerContext["superuserPool"];
         }
     }
 }

package/dist/src/index.js

@@ -5,6 +5,7 @@ import { createHubServer } from "./server/index.js";
 import { initializeTransferProcessors } from "./process-transfers/index.js";
 import { join } from "path";
 import { logger } from "./logger.js";
+import { createServerContext, closeServerContext, } from "./context.js";
 export { MakeOutcomeBetPlugin, } from "./plugins/hub-make-outcome-bet.js";
 export { validateRisk, } from "./risk-policy.js";
 export { defaultPlugins, } from "./server/graphile.config.js";
@@ -49,6 +50,7 @@ async function initialize(options) {
     if (process.env.NODE_ENV !== "test") {
         initializeTransferProcessors({
             signal: options.signal,
+            pool: options.context.superuserPool,
         });
     }
 }
@@ -66,9 +68,11 @@ export async function startAndListen(options) {
     }
     const abortController = new AbortController();
     let isShuttingDown = false;
+    const context = createServerContext();
     await initialize({
         userDatabaseMigrationsPath: options.userDatabaseMigrationsPath,
         signal: abortController.signal,
+        context,
     });
     const hubServer = createHubServer({
         configureApp: options.configureApp,
@@ -76,6 +80,7 @@ export async function startAndListen(options) {
         exportSchemaSDLPath: options.exportSchemaSDLPath,
         extraPgSchemas: options.extraPgSchemas,
         abortSignal: abortController.signal,
+        context,
     });
     const gracefulShutdown = async ({ exit = true } = {}) => {
         if (isShuttingDown) {
@@ -89,13 +94,8 @@ export async function startAndListen(options) {
         logger.info("Closing resources...");
         hubServer.shutdown();
         try {
-            const closeTasks = [db.notifier.close()];
-            if (process.env.NODE_ENV !== "test") {
-                closeTasks.push(db.postgraphilePool.end());
-                closeTasks.push(db.superuserPool.end());
-            }
             await Promise.race([
-                Promise.all(closeTasks),
+                closeServerContext(context),
                 new Promise((_, reject) => setTimeout(() => reject(new Error("Database cleanup timeout")), 3000)),
             ]);
             logger.info("Cleanup complete.");
@@ -107,8 +107,10 @@ export async function startAndListen(options) {
             process.exit(0);
         }
     };
-    process.on("SIGINT", gracefulShutdown);
-    process.on("SIGTERM", gracefulShutdown);
+    if (process.env.NODE_ENV !== "test") {
+        process.on("SIGINT", gracefulShutdown);
+        process.on("SIGTERM", gracefulShutdown);
+    }
     return hubServer.listen().then(() => {
         return {
             port: config.PORT,

package/dist/src/plugins/hub-add-casino.js

@@ -4,7 +4,7 @@ import { exactlyOneRow } from "../db/util.js";
 import { gql as generatedGql } from "../__generated__/gql.js";
 import { GraphQLClient } from "graphql-request";
 import { GraphQLError } from "graphql";
-import { superuserPool, upsertCurrencies, withPgPoolTransaction, } from "../db/index.js";
+import { upsertCurrencies, withPgPoolTransaction, } from "../db/index.js";
 import { logger } from "../logger.js";
 import { assert, is } from "tsafe";
 import * as jwtService from "../services/jwt-service.js";
@@ -48,8 +48,9 @@ export const HubAddCasinoPlugin = makeExtendSchemaPlugin((build) => {
                 plans: {
                     hubAddCasino(_, { $input }) {
                         const $identity = context().get("identity");
+                        const $superuserPool = context().get("superuserPool");
                         const $abortSignal = context().get("abortSignal");
-                        const $casinoId = sideEffect([$input, $identity, $abortSignal], ([input, identity, abortSignal]) => {
+                        const $casinoId = sideEffect([$input, $identity, $superuserPool, $abortSignal], ([input, identity, superuserPool, abortSignal]) => {
                             return withPgPoolTransaction(superuserPool, async (pgClient) => {
                                 if (identity?.kind !== "operator") {
                                     throw new GraphQLError("Unauthorized");
@@ -141,6 +142,7 @@ export const HubAddCasinoPlugin = makeExtendSchemaPlugin((build) => {
                                 startCasinoTransferProcessor({
                                     casinoId: casino.id,
                                     signal: abortSignal,
+                                    pool: superuserPool,
                                 });
                                 return casino.id;
                             });

package/dist/src/plugins/hub-authenticate.js

@@ -5,7 +5,7 @@ import { GET_USER_FROM_USER_TOKEN } from "../graphql-queries.js";
 import { exactlyOneRow, maybeOneRow } from "../db/util.js";
 import { createGraphqlClient } from "../graphql-client.js";
 import { constant, context, error, object, sideEffect, } from "postgraphile/grafast";
-import { superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { withPgPoolTransaction, } from "../db/index.js";
 import { logger } from "../logger.js";
 import * as jwtService from "../services/jwt-service.js";
 import { extractGraphQLErrorInfo, isGraphQLError } from "../GraphQLError.js";
@@ -51,7 +51,8 @@ export const HubAuthenticatePlugin = makeExtendSchemaPlugin(() => {
                     hubAuthenticate(_, { $input }) {
                         try {
                             const $context = context();
-                            const $success = sideEffect([$input, $context], ([rawInput, context]) => {
+                            const $superuserPool = $context.get("superuserPool");
+                            const $success = sideEffect([$input, $superuserPool, $context], ([rawInput, superuserPool, context]) => {
                                 return withPgPoolTransaction(superuserPool, async (pgClient) => {
                                     let input;
                                     try {

package/dist/src/plugins/hub-claim-faucet.js

@@ -1,6 +1,6 @@
 import { object } from "grafast";
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
-import { superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { withPgPoolTransaction, } from "../db/index.js";
 import { constant, context, sideEffect } from "postgraphile/grafast";
 import { assert } from "tsafe";
 const CLAIM_AMOUNT = 1000;
@@ -20,8 +20,10 @@ export const HubClaimFaucetPlugin = makeExtendSchemaPlugin(() => {
             Mutation: {
                 plans: {
                     hubClaimFaucet() {
-                        const $identity = context().get("identity");
-                        const $result = sideEffect([$identity], ([identity]) => {
+                        const $context = context();
+                        const $identity = $context.get("identity");
+                        const $superuserPool = $context.get("superuserPool");
+                        const $result = sideEffect([$identity, $superuserPool], ([identity, superuserPool]) => {
                             if (identity?.kind !== "user") {
                                 throw new Error("Must be logged in as user");
                             }

package/dist/src/plugins/hub-make-outcome-bet.js

@@ -2,7 +2,7 @@ import { access, context, object, ObjectStep, sideEffect, } from "postgraphile/g
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
 import * as z from "zod";
 import { GraphQLError } from "graphql";
-import { DbHashKind, dbLockPlayerBalanceAndHouseBankroll, exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { DbHashKind, dbLockPlayerBalanceAndHouseBankroll, exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
 import { dbInsertHubHash, dbLockHubHashChain, } from "../hash-chain/db-hash-chain.js";
 import { getIntermediateHash, getPreimageHash, } from "../hash-chain/get-hash.js";
@@ -106,7 +106,8 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                     plans: {
                         hubMakeOutcomeBet: (_, { $input }) => {
                             const $identity = context().get("identity");
-                            const $result = sideEffect([$identity, $input], async ([identity, rawInput]) => {
+                            const $superuserPool = context().get("superuserPool");
+                            const $result = sideEffect([$identity, $superuserPool, $input], async ([identity, superuserPool, rawInput]) => {
                                 if (identity?.kind !== "user") {
                                     throw new GraphQLError("Unauthorized");
                                 }
@@ -217,6 +218,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         if (dbHashChain.current_iteration === 1) {
                                             finishHashChainInBackground({
                                                 hashChainId: input.hashChainId,
+                                                pool: superuserPool,
                                             }).catch((e) => {
                                                 logger.error({ hashChainId: input.hashChainId, error: e }, "Error finishing hash chain in background");
                                             });
@@ -403,7 +405,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
         };
     }, "HubMakeOutcomeBetPlugin");
 }
-async function finishHashChainInBackground({ hashChainId, }) {
+async function finishHashChainInBackground({ hashChainId, pool, }) {
     logger.debug({ hashChainId }, "Finishing hash chain in background");
     const preimageHashResult = await getPreimageHash({
         hashChainId,
@@ -416,7 +418,7 @@ async function finishHashChainInBackground({ hashChainId, }) {
             digest: preimageHashResult.hash,
             iteration: 0,
         }, "Inserting preimage hash");
-        await withPgPoolTransaction(superuserPool, async (pgClient) => {
+        await withPgPoolTransaction(pool, async (pgClient) => {
             await dbInsertHubHash(pgClient, {
                 hashChainId,
                 kind: DbHashKind.PREIMAGE,

package/dist/src/plugins/hub-withdraw.js

@@ -1,6 +1,6 @@
 import { constant, context, object, sideEffect } from "postgraphile/grafast";
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
-import { superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { withPgPoolTransaction } from "../db/index.js";
 import { exactlyOneRow, maybeOneRow } from "../db/util.js";
 import { GraphQLError } from "graphql";
 export const HubWithdrawPlugin = makeExtendSchemaPlugin((build) => {
@@ -26,7 +26,8 @@ export const HubWithdrawPlugin = makeExtendSchemaPlugin((build) => {
                 plans: {
                     hubWithdraw(_, { $input }) {
                         const $identity = context().get("identity");
-                        const $withdrawalRequestId = sideEffect([$input, $identity], ([input, identity]) => {
+                        const $superuserPool = context().get("superuserPool");
+                        const $withdrawalRequestId = sideEffect([$input, $identity, $superuserPool], ([input, identity, superuserPool]) => {
                             if (identity?.kind !== "user") {
                                 throw new GraphQLError("You must be logged in");
                             }

package/dist/src/process-transfers/index.d.ts

@@ -1,9 +1,12 @@
 import { DbCasino, DbCasinoSecret } from "../db/index.js";
+import * as pg from "pg";
 export type CasinoWithSecret = DbCasino & DbCasinoSecret;
-export declare function startCasinoTransferProcessor({ casinoId, signal, }: {
+export declare function startCasinoTransferProcessor({ casinoId, signal, pool, }: {
     casinoId: string;
     signal: AbortSignal;
+    pool: pg.Pool;
 }): Promise<void>;
-export declare function initializeTransferProcessors({ signal, }: {
+export declare function initializeTransferProcessors({ signal, pool, }: {
     signal: AbortSignal;
+    pool: pg.Pool;
 }): void;

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

@@ -1,6 +1,5 @@
 import { startPollingProcessor } from "./polling-processor.js";
 import { startWebsocketProcessor } from "./websocket-processor.js";
-import { superuserPool } from "../db/index.js";
 import { dbGetCasinoById, dbGetCasinoSecretById } from "../db/internal.js";
 import assert from "assert";
 import { logger } from "../logger.js";
@@ -9,28 +8,29 @@ import * as db from "../db/index.js";
 import * as pg from "pg";
 import { z } from "zod";
 const activeCasinos = new Set();
-export async function startCasinoTransferProcessor({ casinoId, signal, }) {
+export async function startCasinoTransferProcessor({ casinoId, signal, pool, }) {
     if (activeCasinos.has(casinoId)) {
         throw new Error(`processor already running for casino ${casinoId}`);
     }
-    const casino = await dbGetCasinoById(superuserPool, casinoId);
-    const secret = await dbGetCasinoSecretById(superuserPool, casinoId);
+    const casino = await dbGetCasinoById(pool, casinoId);
+    const secret = await dbGetCasinoSecretById(pool, casinoId);
     assert(casino, `Casino not found for casino id ${casinoId}`);
     assert(secret, `Secret not found for casino id ${casinoId}`);
     activeCasinos.add(casinoId);
-    startPollingProcessor({ casinoId, signal });
+    startPollingProcessor({ casinoId, signal, pool });
     startWebsocketProcessor({
         casinoId,
         graphqlUrl: casino.graphql_url,
         signal,
         controllerId: secret.controller_id,
         apiKey: secret.api_key,
+        pool,
     });
 }
-export function initializeTransferProcessors({ signal, }) {
+export function initializeTransferProcessors({ signal, pool, }) {
     (async () => {
         try {
-            const casinos = await db.listCasinos(superuserPool);
+            const casinos = await db.listCasinos(pool);
             for (const casino of casinos) {
                 if (!URL.canParse(casino.graphql_url)) {
                     logger.warn(`Skipping casino ${casino.id} due to invalid graphql_url: "${casino.graphql_url}"`);
@@ -41,16 +41,16 @@ export function initializeTransferProcessors({ signal, }) {
                     logger.warn(`${casino.id} has localhost endpoint "${casino.graphql_url}" while NODE_ENV=production.`);
                 }
                 logger.info(`Starting casino processor for "${casino.name}" at "${casino.graphql_url}"`);
-                startCasinoTransferProcessor({ casinoId: casino.id, signal });
+                startCasinoTransferProcessor({ casinoId: casino.id, signal, pool });
             }
-            await listenForNewCasinos({ signal });
+            await listenForNewCasinos({ signal, pool });
         }
         catch (e) {
             logger.error(e, `Error initializing transfer processors`);
         }
     })();
 }
-async function listenForNewCasinos({ signal }) {
+async function listenForNewCasinos({ signal, pool, }) {
     const pgClient = new pg.Client(config.SUPERUSER_DATABASE_URL);
     await pgClient.connect();
     const NewCasinoPayload = z.object({
@@ -76,7 +76,11 @@ async function listenForNewCasinos({ signal }) {
                     logger.error(result.error, "Error parsing new casino notification");
                     return;
                 }
-                startCasinoTransferProcessor({ casinoId: result.data.id, signal });
+                startCasinoTransferProcessor({
+                    casinoId: result.data.id,
+                    signal,
+                    pool,
+                });
                 break;
             }
         }

package/dist/src/process-transfers/polling-processor.d.ts

@@ -1,10 +1,12 @@
 import * as db from "../db/index.js";
+import * as pg from "pg";
 export declare const PAGINATE_TRANSFERS: import("@graphql-typed-document-node/core").TypedDocumentNode<import("../__generated__/graphql.js").PaginateTransfersQuery, import("../__generated__/graphql.js").Exact<{
     controllerId: import("../__generated__/graphql.js").Scalars["UUID"]["input"];
     after?: import("../__generated__/graphql.js").InputMaybe<import("../__generated__/graphql.js").Scalars["Cursor"]["input"]>;
     limit?: import("../__generated__/graphql.js").InputMaybe<import("../__generated__/graphql.js").Scalars["Int"]["input"]>;
 }>>;
-export declare function startPollingProcessor({ casinoId, signal, }: {
+export declare function startPollingProcessor({ casinoId, signal, pool, }: {
     casinoId: db.DbCasino["id"];
     signal: AbortSignal;
+    pool: pg.Pool;
 }): void;

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

@@ -8,7 +8,6 @@ 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";
-import { superuserPool } from "../db/index.js";
 import { TransferStatusKind } from "../__generated__/graphql.js";
 import { MP_COMPLETE_TRANSFER, processTransfer } from "./process-transfer.js";
 import { gql } from "../__generated__/gql.js";
@@ -44,7 +43,7 @@ export const PAGINATE_TRANSFERS = gql(`
 `);
 const MIN_BACKOFF_TIME = 5000;
 const MAX_BACKOFF_TIME = 30 * 1000;
-export function startPollingProcessor({ casinoId, signal, }) {
+export function startPollingProcessor({ casinoId, signal, pool, }) {
     if (signal.aborted) {
         logger.info(`[startTransferProcessor] AbortSignal aborted. Not starting processor for casino ${casinoId}`);
         return;
@@ -55,7 +54,7 @@ export function startPollingProcessor({ casinoId, signal, }) {
         lastAttempt: 0,
     };
     (async () => {
-        let cursor = await db.getTransferCursor(superuserPool, {
+        let cursor = await db.getTransferCursor(pool, {
             casinoId,
         });
         if (cursor && !isUuid(cursor)) {
@@ -80,13 +79,13 @@ export function startPollingProcessor({ casinoId, signal, }) {
                     await new Promise((resolve) => setTimeout(resolve, timeToWait));
                 }
                 processorState.lastAttempt = Date.now();
-                const casino = await dbGetCasinoById(superuserPool, casinoId);
+                const casino = await dbGetCasinoById(pool, casinoId);
                 if (!casino) {
                     logger.warn(`casino ${casinoId} not found. Stopping processor...`);
                     shouldStop = true;
                     break;
                 }
-                const casinoSecret = await dbGetCasinoSecretById(superuserPool, casino.id);
+                const casinoSecret = await dbGetCasinoSecretById(pool, casino.id);
                 if (!casinoSecret) {
                     logger.warn(`Casino secret hasn't been set for casino ${casinoId}. Skipping...`);
                     continue;
@@ -99,7 +98,7 @@ export function startPollingProcessor({ casinoId, signal, }) {
                     logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (1)`);
                     break;
                 }
-                await jwtService.refreshCasinoJwksTask(superuserPool, {
+                await jwtService.refreshCasinoJwksTask(pool, {
                     casinoId: casino.id,
                     graphqlClient,
                 });
@@ -114,7 +113,7 @@ export function startPollingProcessor({ casinoId, signal, }) {
                         return (res.allCurrencies?.nodes || []).flatMap((x) => x ? [x] : []);
                     });
                     if (currencies.length > 0) {
-                        await db.upsertCurrencies(superuserPool, {
+                        await db.upsertCurrencies(pool, {
                             casinoId: casino.id,
                             currencies,
                         });
@@ -130,6 +129,7 @@ export function startPollingProcessor({ casinoId, signal, }) {
                     graphqlClient,
                     casinoInfo: { ...casino, ...casinoSecret },
                     signal,
+                    pool,
                 });
                 if (signal.aborted) {
                     logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (4)`);
@@ -139,6 +139,7 @@ export function startPollingProcessor({ casinoId, signal, }) {
                     abortSignal: signal,
                     casinoId: casino.id,
                     graphqlClient,
+                    pool,
                 });
                 if (signal.aborted) {
                     logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (5)`);
@@ -149,6 +150,7 @@ export function startPollingProcessor({ casinoId, signal, }) {
                     controllerId: casinoSecret.controller_id,
                     casinoId: casino.id,
                     graphqlClient,
+                    pool,
                 });
                 processorState.backoffTime = MIN_BACKOFF_TIME;
             }
@@ -161,11 +163,11 @@ export function startPollingProcessor({ casinoId, signal, }) {
         logger.info(`processor stopped for casino ${casinoId}`);
     })();
 }
-async function processWithdrawals({ abortSignal, casinoId, graphqlClient, }) {
+async function processWithdrawals({ abortSignal, casinoId, graphqlClient, pool, }) {
     if (abortSignal.aborted) {
         return;
     }
-    const withdrawals = await db.getPendingWithdrawals(superuserPool, {
+    const withdrawals = await db.getPendingWithdrawals(pool, {
         casinoId,
         limit: 10,
     });
@@ -185,7 +187,7 @@ async function processWithdrawals({ abortSignal, casinoId, graphqlClient, }) {
             case undefined:
                 break;
             case "CompleteTransferSuccess": {
-                await db.settleWithdrawal({
+                await db.settleWithdrawal(pool, {
                     withdrawalId: withdrawal.id,
                     newStatus: "COMPLETED",
                 });
@@ -198,7 +200,7 @@ async function processWithdrawals({ abortSignal, casinoId, graphqlClient, }) {
                 switch (currentState) {
                     case TransferStatusKind.Canceled:
                     case TransferStatusKind.Completed:
-                        await db.settleWithdrawal({
+                        await db.settleWithdrawal(pool, {
                             withdrawalId: withdrawal.id,
                             newStatus: currentState,
                         });
@@ -224,13 +226,14 @@ async function processWithdrawals({ abortSignal, casinoId, graphqlClient, }) {
         }
     }
 }
-async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoInfo, signal, }) {
+async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoInfo, signal, pool, }) {
     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.`);
@@ -266,8 +269,9 @@ async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoIn
                 controllerId: casinoInfo.controller_id,
                 transfer,
                 graphqlClient,
+                pool,
             });
-            await db.setTransferCursor(superuserPool, {
+            await db.setTransferCursor(pool, {
                 cursor,
                 casinoId: casinoInfo.id,
             });

package/dist/src/process-transfers/process-transfer.d.ts

@@ -1,13 +1,15 @@
 import { TransferFieldsFragment } from "../__generated__/graphql.js";
 import { GraphQLClient } from "graphql-request";
+import * as pg from "pg";
 export declare const MP_COMPLETE_TRANSFER: import("@graphql-typed-document-node/core").TypedDocumentNode<import("../__generated__/graphql.js").CompleteTransferMutation, import("../__generated__/graphql.js").Exact<{
     mpTransferId: import("../__generated__/graphql.js").Scalars["UUID"]["input"];
 }>>;
-export declare function processTransfer({ casinoId, controllerId, transfer, graphqlClient, }: {
+export declare function processTransfer({ casinoId, controllerId, transfer, graphqlClient, pool, }: {
     casinoId: string;
     controllerId: string;
     transfer: Extract<TransferFieldsFragment, {
         __typename: "ExperienceTransfer";
     }>;
     graphqlClient: GraphQLClient;
+    pool: pg.Pool;
 }): Promise<void>;

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

@@ -1,6 +1,5 @@
 import * as db from "../db/index.js";
 import { TransferStatusKind, } from "../__generated__/graphql.js";
-import { superuserPool } from "../db/index.js";
 import { gql } from "../__generated__/gql.js";
 import { logger } from "../logger.js";
 import { assert } from "tsafe";
@@ -50,7 +49,7 @@ const MP_CLAIM_TRANSFER = gql(`
     }
   }
 `);
-export async function processTransfer({ casinoId, controllerId, transfer, graphqlClient, }) {
+export async function processTransfer({ casinoId, controllerId, transfer, graphqlClient, pool, }) {
     assert(transfer, "Expected transfer");
     assert(transfer.__typename === "ExperienceTransfer", `Expected ExperienceTransfer but got ${transfer.__typename}`);
     logger.debug(`processing transfer ${transfer.id} for casino ${casinoId}...`);
@@ -62,17 +61,17 @@ export async function processTransfer({ casinoId, controllerId, transfer, graphq
         : transfer.holderByToHolderId;
     assert(user?.__typename === "User", "Expected user transfer participant");
     const currency = transfer.currencyByCurrency;
-    const dbSender = await db.upsertUser(superuserPool, {
+    const dbSender = await db.upsertUser(pool, {
         casinoId,
         mpUserId: user.id,
         uname: user.uname,
     });
-    const dbExperience = await db.upsertExperience(superuserPool, {
+    const dbExperience = await db.upsertExperience(pool, {
         casinoId,
         mpExperienceId: transfer.experienceByExperienceId.id,
         name: transfer.experienceByExperienceId.name,
     });
-    await db.upsertCurrencies(superuserPool, {
+    await db.upsertCurrencies(pool, {
         casinoId,
         currencies: [currency],
     });
@@ -85,7 +84,7 @@ export async function processTransfer({ casinoId, controllerId, transfer, graphq
             case TransferStatusKind.Expired:
                 return;
             case TransferStatusKind.Completed: {
-                await db.insertDeposit({
+                await db.insertDeposit(pool, {
                     casinoId,
                     mpTransferId: transfer.id,
                     userId: dbSender.id,
@@ -110,7 +109,7 @@ export async function processTransfer({ casinoId, controllerId, transfer, graphq
                 if (data.claimTransfer?.result.__typename !== "ClaimTransferSuccess") {
                     throw new Error(`Failed to claim transfer: ${JSON.stringify(data.claimTransfer)}`);
                 }
-                await db.insertDeposit({
+                await db.insertDeposit(pool, {
                     casinoId,
                     mpTransferId: transfer.id,
                     userId: dbSender.id,
@@ -130,7 +129,7 @@ export async function processTransfer({ casinoId, controllerId, transfer, graphq
         logger.debug(`I sent ${user.uname} ${transfer.amount} base units of ${currency.id}`);
         switch (transfer.status) {
             case TransferStatusKind.Canceled:
-                await db.settleWithdrawal({
+                await db.settleWithdrawal(pool, {
                     withdrawalId: transfer.id,
                     newStatus: "CANCELED",
                 });

package/dist/src/process-transfers/websocket-processor.d.ts

@@ -1,7 +1,9 @@
-export declare function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controllerId, apiKey, }: {
+import * as pg from "pg";
+export declare function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controllerId, apiKey, pool, }: {
     casinoId: string;
     graphqlUrl: string;
     signal: AbortSignal;
     controllerId: string;
     apiKey: string;
+    pool: pg.Pool;
 }): void;

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

@@ -7,7 +7,6 @@ import { TRANSFER_FIELDS } from "./graphql.js";
 import { logger } from "../logger.js";
 import { processTransfer } from "./process-transfer.js";
 import assert from "assert";
-import { superuserPool } from "../db/index.js";
 import { mpGetTakeRequest, processSingleTakeRequest, } from "../take-request/process-take-request.js";
 function httpToWs(url) {
     if (url.protocol === "http:") {
@@ -50,7 +49,7 @@ async function mpGetExperienceTransfer(graphqlClient, id) {
     const mpTransfer = useFragment(TRANSFER_FIELDS, x);
     return mpTransfer;
 }
-export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controllerId, apiKey, }) {
+export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controllerId, apiKey, pool, }) {
     logger.info(`Starting websocket processor for ${graphqlUrl} using apiKey ${apiKey}`);
     const client = createWebsocketClient({
         url: httpToWs(new URL(graphqlUrl)).toString(),
@@ -90,6 +89,7 @@ export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controll
             controllerId,
             transfer: mpTransfer,
             graphqlClient,
+            pool,
         });
     });
     const dispose2 = createSubscription(client, MP_NEW_TAKE_REQUEST, async (result) => {
@@ -108,7 +108,7 @@ export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controll
             mpTakeRequest,
             casinoId,
             graphqlClient,
-            pool: superuserPool,
+            pool,
         });
     });
     signal.addEventListener("abort", () => {

package/dist/src/process-withdrawal-request.d.ts

@@ -1,5 +1,7 @@
+import * as pg from "pg";
 import { GraphQLClient } from "graphql-request";
-export declare function processWithdrawalRequests({ casinoId, graphqlClient, }: {
+export declare function processWithdrawalRequests({ casinoId, graphqlClient, pool, }: {
     casinoId: string;
     graphqlClient: GraphQLClient;
+    pool: pg.Pool;
 }): Promise<void>;

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

@@ -1,11 +1,11 @@
 import { assert } from "tsafe";
 import { TransferStatusKind } from "./__generated__/graphql.js";
-import { withPgPoolTransaction, superuserPool } from "./db/index.js";
+import { withPgPoolTransaction } from "./db/index.js";
 import { maybeOneRow, exactlyOneRow } from "./db/util.js";
 import { START_PENDING_EXPERIENCE_TRANSFER } from "./graphql-queries.js";
 import { logger } from "./logger.js";
-async function processWithdrawalRequest({ requestId, graphqlClient, }) {
-    return withPgPoolTransaction(superuserPool, async (pgClient) => {
+async function processWithdrawalRequest({ requestId, graphqlClient, pool, }) {
+    return withPgPoolTransaction(pool, async (pgClient) => {
         const dbWithdrawalRequest = await pgClient
             .query({
             text: `
@@ -120,8 +120,8 @@ async function processWithdrawalRequest({ requestId, graphqlClient, }) {
         });
     });
 }
-export async function processWithdrawalRequests({ casinoId, graphqlClient, }) {
-    const pendingRequests = await superuserPool.query({
+export async function processWithdrawalRequests({ casinoId, graphqlClient, pool, }) {
+    const pendingRequests = await pool.query({
         text: `
       SELECT wr.* 
       FROM hub.withdrawal_request wr
@@ -136,6 +136,7 @@ export async function processWithdrawalRequests({ casinoId, graphqlClient, }) {
             await processWithdrawalRequest({
                 requestId: request.id,
                 graphqlClient,
+                pool,
             });
         }
         catch (error) {

package/dist/src/server/graphile.config.d.ts

@@ -1,5 +1,6 @@
 import "graphile-config";
 import "postgraphile";
+import { ServerContext } from "../context.js";
 export type UserSessionContext = {
     user_id: string;
     mp_user_id: string;
@@ -15,9 +16,10 @@ export type PluginIdentity = {
 };
 export declare const requiredPlugins: readonly GraphileConfig.Plugin[];
 export declare const defaultPlugins: readonly GraphileConfig.Plugin[];
-export declare function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, }: {
+export declare function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, }: {
     plugins: readonly GraphileConfig.Plugin[];
     exportSchemaSDLPath?: string;
     extraPgSchemas: string[];
     abortSignal: AbortSignal;
+    context: ServerContext;
 }): GraphileConfig.Preset;

package/dist/src/server/graphile.config.js

@@ -48,7 +48,7 @@ export const defaultPlugins = [
     HubClaimFaucetPlugin,
     customPgOmitArchivedPlugin("deleted"),
 ];
-export function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, }) {
+export function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, }) {
     if (exportSchemaSDLPath) {
         if (!exportSchemaSDLPath.startsWith("/")) {
             throw new Error("exportSchemaSDLPath must be an absolute path");
@@ -96,7 +96,7 @@ export function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abo
         grafast: {
             context(ctx, _args) {
                 if (ctx.ws) {
-                    return handleWebsocketContext(ctx.ws);
+                    return handleWebsocketContext(context, ctx.ws);
                 }
                 const expressReq = ctx.expressv4.req;
                 const reqIdentity = expressReq.identity;
@@ -132,6 +132,7 @@ export function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abo
                     pgSettings,
                     identity: pluginIdentity,
                     abortSignal,
+                    superuserPool: context.superuserPool,
                 };
             },
         },
@@ -147,12 +148,12 @@ function getSessionIdFromWebsocketCtx(ws) {
     const uuid = value.slice("session:".length);
     return isUuid(uuid) ? uuid : "";
 }
-async function handleWebsocketContext(ws) {
+async function handleWebsocketContext(context, ws) {
     const sessionId = getSessionIdFromWebsocketCtx(ws);
     if (!sessionId) {
         throw new Error("Unauthorized");
     }
-    const result = await db.userFromActiveSessionKey(db.superuserPool, sessionId);
+    const result = await db.userFromActiveSessionKey(context.superuserPool, sessionId);
     if (!result) {
         throw new Error("Unauthorized");
     }

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

@@ -1,8 +1,10 @@
 import { ServerOptions } from "../index.js";
+import { ServerContext } from "../context.js";
 export type HubServer = {
     listen: () => Promise<void>;
     shutdown: () => Promise<void>;
 };
-export declare function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, }: Pick<ServerOptions, "plugins" | "exportSchemaSDLPath" | "extraPgSchemas" | "configureApp"> & {
+export declare function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, }: Pick<ServerOptions, "plugins" | "exportSchemaSDLPath" | "extraPgSchemas" | "configureApp"> & {
     abortSignal: AbortSignal;
+    context: ServerContext;
 }): HubServer;

package/dist/src/server/index.js

@@ -31,11 +31,11 @@ const dashboardDir = path.join(distDir, "dashboard");
 if (!fs.existsSync(dashboardDir)) {
     throw new Error(`Could not find dashboard directory. Expected it to be at "${dashboardDir}"`);
 }
-function createExpressServer() {
+function createExpressServer(context) {
     const app = express();
     app.disable("x-powered-by");
     app.use(cors());
-    app.use(authentication());
+    app.use(authentication(context));
     app.use("/dashboard", express.static(dashboardDir));
     app.use("/dashboard/*splat", (_, res) => {
         res.sendFile(path.join(dashboardDir, "index.html"));
@@ -45,13 +45,14 @@ function createExpressServer() {
     });
     return app;
 }
-export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, }) {
-    const expressServer = createExpressServer();
+export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, }) {
+    const expressServer = createExpressServer(context);
     const preset = createPreset({
         plugins: plugins ?? defaultPlugins,
         exportSchemaSDLPath,
         extraPgSchemas: extraPgSchemas ?? [],
         abortSignal,
+        context,
     });
     const pgl = postgraphile.default(preset);
     const serv = pgl.createServ(grafserv);

package/dist/src/server/middleware/authentication.d.ts

@@ -1,4 +1,5 @@
 import { Response, NextFunction } from "express";
 import { HubRequest } from "../../express.js";
-declare const authentication: () => (req: HubRequest, _: Response, next: NextFunction) => Promise<void>;
+import { ServerContext } from "../../context.js";
+declare const authentication: (context: ServerContext) => (req: HubRequest, _: Response, next: NextFunction) => Promise<void>;
 export default authentication;

package/dist/src/server/middleware/authentication.js

@@ -1,7 +1,7 @@
 import { isUuid } from "../../util.js";
 import * as db from "../../db/index.js";
-async function checkAndUpdateApiKey(key) {
-    const row = await db.superuserPool
+async function checkAndUpdateApiKey(key, pool) {
+    const row = await pool
         .query(`
     UPDATE hub.api_key 
     SET last_used_at = now()
@@ -11,7 +11,7 @@ async function checkAndUpdateApiKey(key) {
         .then(db.maybeOneRow);
     return !!row;
 }
-const authentication = () => {
+const authentication = (context) => {
     return async (req, _, next) => {
         const header = req.get("authorization");
         if (!header) {
@@ -28,7 +28,7 @@ const authentication = () => {
         }
         if (tokenType === "session") {
             const sessionKey = token;
-            const result = await db.userFromActiveSessionKey(db.superuserPool, sessionKey);
+            const result = await db.userFromActiveSessionKey(context.superuserPool, sessionKey);
             if (result) {
                 req.identity = {
                     kind: "user",
@@ -40,7 +40,7 @@ const authentication = () => {
         }
         else if (tokenType === "apikey") {
             const apiKey = token;
-            const isValid = await checkAndUpdateApiKey(apiKey);
+            const isValid = await checkAndUpdateApiKey(apiKey, context.superuserPool);
             if (isValid) {
                 req.identity = {
                     kind: "operator",

package/dist/src/take-request/process-take-request.d.ts

@@ -3,11 +3,12 @@ import { MpTakeRequestFieldsFragment } from "../__generated__/graphql.js";
 import * as pg from "pg";
 export declare const MP_TAKE_REQUEST_FIELDS: import("@graphql-typed-document-node/core").TypedDocumentNode<MpTakeRequestFieldsFragment, unknown>;
 export declare function mpGetTakeRequest(graphqlClient: GraphQLClient, id: string): Promise<MpTakeRequestFieldsFragment | null>;
-export declare function processTakeRequests({ abortSignal, controllerId, casinoId, graphqlClient, }: {
+export declare function processTakeRequests({ abortSignal, controllerId, casinoId, graphqlClient, pool, }: {
     abortSignal: AbortSignal;
     controllerId: string;
     casinoId: string;
     graphqlClient: GraphQLClient;
+    pool: pg.Pool;
 }): Promise<void>;
 export declare function processSingleTakeRequest({ mpTakeRequestId, mpTakeRequest, casinoId, graphqlClient, pool, }: {
     mpTakeRequestId: string;

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

@@ -1,6 +1,6 @@
 import { gql } from "../__generated__/gql.js";
 import { TakeRequestStatus as MpTakeRequestStatus, TransferStatusKind as MpTransferStatus, } from "../__generated__/graphql.js";
-import { exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
 import { PgAdvisoryLock } from "../pg-advisory-lock.js";
 import { useFragment } from "../__generated__/fragment-masking.js";
@@ -168,7 +168,7 @@ var LocalTakeRequestStatus;
     LocalTakeRequestStatus["FAILED"] = "FAILED";
     LocalTakeRequestStatus["REJECTED"] = "REJECTED";
 })(LocalTakeRequestStatus || (LocalTakeRequestStatus = {}));
-export async function processTakeRequests({ abortSignal, controllerId, casinoId, graphqlClient, }) {
+export async function processTakeRequests({ abortSignal, controllerId, casinoId, graphqlClient, pool, }) {
     if (abortSignal.aborted) {
         return;
     }
@@ -182,15 +182,16 @@ export async function processTakeRequests({ abortSignal, controllerId, casinoId,
             mpTakeRequest: takeRequest,
             casinoId,
             graphqlClient,
-            pool: superuserPool,
+            pool,
         });
     }
     await processPendingTransferCompletions({
         casinoId,
         graphqlClient,
         abortSignal,
+        pool,
     });
-    await processStuckRequests({ casinoId, graphqlClient, abortSignal });
+    await processStuckRequests({ casinoId, graphqlClient, abortSignal, pool });
 }
 async function fetchPendingTakeRequests(graphqlClient, controllerId) {
     const result = await graphqlClient.request(MP_PAGINATE_PENDING_TAKE_REQUESTS, {
@@ -434,11 +435,11 @@ async function attemptTransfer({ pgClient, takeRequestId, mpTakeRequestId, mpExp
         return null;
     }
 }
-async function processPendingTransferCompletions({ casinoId, graphqlClient, abortSignal, }) {
+async function processPendingTransferCompletions({ casinoId, graphqlClient, abortSignal, pool, }) {
     if (abortSignal.aborted) {
         return;
     }
-    const pendingCompletions = await superuserPool
+    const pendingCompletions = await pool
         .query({
         text: `
       SELECT id, mp_take_request_id, mp_transfer_id, transfer_completion_attempted_at
@@ -476,7 +477,7 @@ async function processPendingTransferCompletions({ casinoId, graphqlClient, abor
             mpTransferId: request.mp_transfer_id,
             graphqlClient,
             casinoId,
-            pool: superuserPool,
+            pool,
         });
     }
 }
@@ -681,11 +682,11 @@ export async function completeTransfer({ mpTakeRequestId, takeRequestId, mpTrans
         }
     });
 }
-async function processStuckRequests({ casinoId, graphqlClient, abortSignal, }) {
+async function processStuckRequests({ casinoId, graphqlClient, abortSignal, pool, }) {
     if (abortSignal.aborted) {
         return;
     }
-    const stuckRequests = await superuserPool
+    const stuckRequests = await pool
         .query({
         text: `
       SELECT id, mp_take_request_id
@@ -710,7 +711,7 @@ async function processStuckRequests({ casinoId, graphqlClient, abortSignal, }) {
             mpTakeRequestId: request.mp_take_request_id,
             casinoId,
             graphqlClient,
-            pool: superuserPool,
+            pool,
         });
     }
 }

package/package.json

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