@moneypot/hub 1.16.0-dev.3 → 1.16.0-dev.4

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

@@ -5,17 +5,13 @@ export declare function dbGetCasinoCurrencyByKey(pgClient: QueryExecutor, { curr
     currencyKey: string;
     casinoId: string;
 }): Promise<DbCurrency | undefined>;
-export declare function dbLockPlayerBalanceAndHouseBankroll(pgClient: PgClientInTransaction, { userId, casinoId, experienceId, currencyKey, }: {
+export declare function dbLockPlayerBalance(pgClient: PgClientInTransaction, { userId, casinoId, experienceId, currencyKey, }: {
     userId: string;
     casinoId: string;
     experienceId: string;
     currencyKey: string;
-}): Promise<{
-    found: false;
-    dbPlayerBalance: null;
-    dbHouseBankroll: null;
-} | {
-    found: true;
-    dbPlayerBalance: Pick<DbBalance, "id" | "amount">;
-    dbHouseBankroll: Pick<DbBankroll, "id" | "amount">;
-}>;
+}): Promise<Pick<DbBalance, "id" | "amount"> | null>;
+export declare function dbLockHouseBankroll(pgClient: PgClientInTransaction, { casinoId, currencyKey }: {
+    casinoId: string;
+    currencyKey: string;
+}): Promise<Pick<DbBankroll, "id" | "amount"> | null>;

package/dist/src/db/public.js

@@ -1,5 +1,4 @@
 import { maybeOneRow } from "./util.js";
-import { assert } from "tsafe";
 export async function dbGetActiveSessionById(pgClient, sessionId) {
     return pgClient
         .query(`
@@ -19,40 +18,29 @@ export async function dbGetCasinoCurrencyByKey(pgClient, { currencyKey, casinoId
       `, [currencyKey, casinoId])
         .then(maybeOneRow);
 }
-export async function dbLockPlayerBalanceAndHouseBankroll(pgClient, { userId, casinoId, experienceId, currencyKey, }) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
-    const row = await pgClient
+export async function dbLockPlayerBalance(pgClient, { userId, casinoId, experienceId, currencyKey, }) {
+    return pgClient
         .query(`
-        WITH locked_balance AS (
-          SELECT id, amount
-          FROM hub.balance
-          WHERE user_id        = $1
-            AND casino_id      = $2
-            AND experience_id  = $3
-            AND currency_key   = $4
-
-          FOR UPDATE
-        )
-        SELECT
-          json_build_object('id', pb.id, 'amount', pb.amount) as player_balance,
-          json_build_object('id', br.id, 'amount', br.amount) as house_bankroll
-        FROM locked_balance pb
-        JOIN hub.bankroll br
-          ON br.casino_id   = $2
-        AND br.currency_key = $4
-
-        FOR UPDATE OF br
-      `, [userId, casinoId, experienceId, currencyKey])
-        .then(maybeOneRow);
-    return row
-        ? {
-            found: true,
-            dbPlayerBalance: row.player_balance,
-            dbHouseBankroll: row.house_bankroll,
-        }
-        : {
-            found: false,
-            dbPlayerBalance: null,
-            dbHouseBankroll: null,
-        };
+    SELECT * 
+    FROM hub.balance 
+    WHERE user_id = $1 
+      AND casino_id = $2 
+      AND experience_id = $3 
+      AND currency_key = $4 
+    FOR UPDATE
+    `, [userId, casinoId, experienceId, currencyKey])
+        .then(maybeOneRow)
+        .then((row) => row ?? null);
+}
+export async function dbLockHouseBankroll(pgClient, { casinoId, currencyKey }) {
+    return pgClient
+        .query(`
+      SELECT * 
+      FROM hub.bankroll 
+      WHERE casino_id = $1 
+        AND currency_key = $2 
+      FOR UPDATE
+      `, [casinoId, currencyKey])
+        .then(maybeOneRow)
+        .then((row) => row ?? null);
 }

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

@@ -127,36 +127,35 @@ export const HubAuthenticatePlugin = extendSchema(() => {
                                     const mpExperience = result.experience;
                                     assert(mpExperience);
                                     assert(mpExperience.userByUserId, "Expected mpExperience.userByUserId");
-                                    const userInsertResult = await pgClient
+                                    const authUser = await pgClient
                                         .query({
                                         text: `
-                            WITH user_inserts AS (
-                              INSERT INTO hub.user(casino_id, mp_user_id, uname)
-                              VALUES 
-                                ($1, $2, $3),
-                                ($1, $4, $5)
-                              ON CONFLICT (casino_id, mp_user_id) DO UPDATE
-                                SET uname = EXCLUDED.uname
-                                WHERE hub.user.uname IS DISTINCT FROM EXCLUDED.uname
-                              RETURNING id, mp_user_id
-                            )
-                            SELECT 
-                              MAX(CASE WHEN mp_user_id = $2 THEN id END) as auth_user_id,
-                              MAX(CASE WHEN mp_user_id = $2 THEN uname END) as auth_user_uname,
-                              MAX(CASE WHEN mp_user_id = $4 THEN id END) as owner_user_id,
-                              MAX(CASE WHEN mp_user_id = $4 THEN uname END) as owner_user_uname
-                            FROM user_inserts
+                            INSERT INTO hub.user(casino_id, mp_user_id, uname)
+                            VALUES ($1, $2, $3)
+                            ON CONFLICT (casino_id, mp_user_id) DO UPDATE
+                              SET uname = EXCLUDED.uname
+                            RETURNING id, uname
+                          `,
+                                        values: [casino.id, mpUserId, uname],
+                                    })
+                                        .then(exactlyOneRow);
+                                    const ownerUser = await pgClient
+                                        .query({
+                                        text: `
+                            INSERT INTO hub.user(casino_id, mp_user_id, uname)
+                            VALUES ($1, $2, $3)
+                            ON CONFLICT (casino_id, mp_user_id) DO UPDATE
+                              SET uname = EXCLUDED.uname
+                            RETURNING id
                           `,
                                         values: [
                                             casino.id,
-                                            mpUserId,
-                                            uname,
                                             mpExperience.userByUserId.id,
                                             mpExperience.userByUserId.uname,
                                         ],
                                     })
                                         .then(exactlyOneRow);
-                                    const userId = userInsertResult.auth_user_id;
+                                    const userId = authUser.id;
                                     const dbExperience = await pgClient
                                         .query({
                                         text: `
@@ -170,7 +169,7 @@ export const HubAuthenticatePlugin = extendSchema(() => {
                                             casino.id,
                                             mpExperience.id,
                                             mpExperience.name,
-                                            userInsertResult.owner_user_id,
+                                            ownerUser.id,
                                         ],
                                     })
                                         .then(exactlyOneRow);
@@ -191,7 +190,7 @@ export const HubAuthenticatePlugin = extendSchema(() => {
                                         .then(exactlyOneRow);
                                     const ret = {
                                         userId,
-                                        uname: userInsertResult.auth_user_uname,
+                                        uname: authUser.uname,
                                         experienceId: dbExperience.id,
                                         sessionKey: dbSession.key,
                                     };

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

@@ -1,8 +1,8 @@
 import { access, context, object, ObjectStep, sideEffect, } from "postgraphile/grafast";
-import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+import { gql, extendSchema } from "postgraphile/utils";
 import * as z from "zod";
 import { GraphQLError } from "graphql";
-import { DbHashKind, dbLockPlayerBalanceAndHouseBankroll, exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
+import { DbHashKind, dbLockHouseBankroll, dbLockPlayerBalance, exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
 import { dbInsertHubHash, dbLockHubHashChain, } from "../hash-chain/db-hash-chain.js";
 import { getIntermediateHash } from "../hash-chain/get-hash.js";
@@ -71,7 +71,7 @@ const BetConfigsSchema = z.record(BetKindSchema, z.object({
 export function MakeOutcomeBetPlugin({ betConfigs }) {
     BetConfigsSchema.parse(betConfigs);
     const betKinds = Object.keys(betConfigs);
-    return makeExtendSchemaPlugin((build) => {
+    return extendSchema((build) => {
         const outcomeBetTable = build.input.pgRegistry.pgResources.hub_outcome_bet;
         const typeDefs = gql `
         enum BetKind {
@@ -171,14 +171,14 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     throw new GraphQLError("Currency not found");
                                 }
                                 return withPgPoolTransaction(superuserPool, async (pgClient) => {
-                                    const { dbPlayerBalance, dbHouseBankroll, found } = await dbLockPlayerBalanceAndHouseBankroll(pgClient, {
+                                    const dbPlayerBalance = await dbLockPlayerBalance(pgClient, {
                                         userId: session.user_id,
                                         casinoId: session.casino_id,
                                         experienceId: session.experience_id,
                                         currencyKey: dbCurrency.key,
                                     });
-                                    if (!found) {
-                                        throw new GraphQLError("No balance entry found for player or house");
+                                    if (!dbPlayerBalance) {
+                                        throw new GraphQLError("No balance entry found for player");
                                     }
                                     const minProfit = Math.min(...input.outcomes.map((o) => o.profit));
                                     const maxPlayerLoss = Math.abs(input.wager * minProfit);
@@ -194,21 +194,6 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         }
                                         throw new GraphQLError("You cannot afford the worst outcome");
                                     }
-                                    const maxProfitMultiplier = Math.max(...input.outcomes.map((o) => o.profit));
-                                    const maxPotentialPayout = input.wager * maxProfitMultiplier;
-                                    const riskResult = validateRisk({
-                                        currency: input.currency,
-                                        wager: input.wager,
-                                        bankroll: dbHouseBankroll.amount,
-                                        maxPotentialPayout,
-                                        riskPolicy: betConfig.riskPolicy,
-                                        displayUnitName: dbCurrency.display_unit_name,
-                                        displayUnitScale: dbCurrency.display_unit_scale,
-                                        outcomes: input.outcomes,
-                                    });
-                                    if (!riskResult.ok) {
-                                        throw new GraphQLError(riskResult.error);
-                                    }
                                     const dbHashChain = await dbLockHubHashChain(pgClient, {
                                         userId: session.user_id,
                                         experienceId: session.experience_id,
@@ -289,26 +274,47 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     const outcome = input.outcomes[outcomeIdx];
                                     const netPlayerAmount = input.wager * outcome.profit;
                                     const houseBankrollDelta = -netPlayerAmount;
-                                    await pgClient.query({
-                                        text: `
-                    UPDATE hub.balance
-                    SET amount = amount + $1
-                    WHERE id = $2
-                  `,
-                                        values: [netPlayerAmount, dbPlayerBalance.id],
+                                    const dbHouseBankroll = await dbLockHouseBankroll(pgClient, {
+                                        casinoId: session.casino_id,
+                                        currencyKey: dbCurrency.key,
                                     });
+                                    if (!dbHouseBankroll) {
+                                        throw new GraphQLError("No house bankroll found");
+                                    }
+                                    const maxProfitMultiplier = Math.max(...input.outcomes.map((o) => o.profit));
+                                    const maxPotentialPayout = input.wager * maxProfitMultiplier;
+                                    const riskResult = validateRisk({
+                                        currency: input.currency,
+                                        wager: input.wager,
+                                        bankroll: dbHouseBankroll.amount,
+                                        maxPotentialPayout,
+                                        riskPolicy: betConfig.riskPolicy,
+                                        displayUnitName: dbCurrency.display_unit_name,
+                                        displayUnitScale: dbCurrency.display_unit_scale,
+                                        outcomes: input.outcomes,
+                                    });
+                                    if (!riskResult.ok) {
+                                        throw new GraphQLError(riskResult.error);
+                                    }
                                     await pgClient.query({
                                         text: `
+                    WITH balance_update AS (
+                      UPDATE hub.balance
+                      SET amount = amount + $1
+                      WHERE id = $2
+                    )
                     UPDATE hub.bankroll
-                    SET amount = amount + $2,
-                        bets = bets + 1,
-                        wagered = wagered + $3
-                    WHERE id = $1
+                    SET amount = amount + $3,
+                        wagered = wagered + $4,
+                        bets = bets + 1
+                    WHERE id = $5
                   `,
                                         values: [
-                                            dbHouseBankroll.id,
+                                            netPlayerAmount,
+                                            dbPlayerBalance.id,
                                             houseBankrollDelta,
                                             input.wager,
+                                            dbHouseBankroll.id,
                                         ],
                                     });
                                     const immutableData = structuredClone({

package/package.json

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