@moneypot/hub 1.17.0-dev.1 → 1.17.0-dev.2

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

@@ -4,12 +4,12 @@ import { assert } from "tsafe";
 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 { withPgPoolTransaction, } from "../db/index.js";
+import { constant, context, object, sideEffect } from "postgraphile/grafast";
+import { IsolationLevel, withPgPoolTransaction, } from "../db/index.js";
 import { logger } from "../logger.js";
 import * as jwtService from "../services/jwt-service.js";
 import { extractGraphQLErrorInfo, isGraphQLError } from "../GraphQLError.js";
-import { z } from "zod";
+import { z } from "zod/v4";
 import { prettifyError } from "zod/v4";
 const BaseUrlSchema = z
     .string()
@@ -64,7 +64,7 @@ export const HubAuthenticatePlugin = extendSchema(() => {
                                     }
                                     throw e;
                                 }
-                                return withPgPoolTransaction(superuserPool, async (pgClient) => {
+                                return withPgPoolTransaction(superuserPool, IsolationLevel.READ_COMMITTED, async (pgClient) => {
                                     const { userToken: jwt, casinoBaseUrl } = input;
                                     const casino = await pgClient
                                         .query({
@@ -114,7 +114,7 @@ export const HubAuthenticatePlugin = extendSchema(() => {
                                                 throw new GraphQLError(errorInfo.message);
                                             }
                                         }
-                                        throw error;
+                                        throw e;
                                     }
                                     const result = res.userFromUserToken;
                                     if (!result || !result.user || !result.experience) {

package/dist/src/plugins/hub-make-outcome-bet.d.ts

@@ -1,4 +1,4 @@
-import * as z from "zod";
+import * as z from "zod/v4";
 import { DbOutcome } from "../db/index.js";
 import { Result } from "../util.js";
 import { RiskPolicy } from "../risk-policy.js";
@@ -7,53 +7,13 @@ declare const InputSchema: z.ZodObject<{
     clientSeed: z.ZodString;
     wager: z.ZodNumber;
     currency: z.ZodString;
-    outcomes: z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodObject<{
+    outcomes: z.ZodArray<z.ZodObject<{
         weight: z.ZodNumber;
         profit: z.ZodNumber;
-    }, "strict", z.ZodTypeAny, {
-        profit: number;
-        weight: number;
-    }, {
-        profit: number;
-        weight: number;
-    }>, "many">, {
-        profit: number;
-        weight: number;
-    }[], {
-        profit: number;
-        weight: number;
-    }[]>, {
-        profit: number;
-        weight: number;
-    }[], {
-        profit: number;
-        weight: number;
-    }[]>;
+    }, z.core.$strict>>;
     hashChainId: z.ZodString;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strict", z.ZodTypeAny, {
-    currency: string;
-    hashChainId: string;
-    kind: string;
-    clientSeed: string;
-    outcomes: {
-        profit: number;
-        weight: number;
-    }[];
-    wager: number;
-    metadata?: Record<string, unknown> | undefined;
-}, {
-    currency: string;
-    hashChainId: string;
-    kind: string;
-    clientSeed: string;
-    outcomes: {
-        profit: number;
-        weight: number;
-    }[];
-    wager: number;
-    metadata?: Record<string, unknown> | undefined;
-}>;
+}, z.core.$strict>;
 type Input = z.infer<typeof InputSchema>;
 type Metadata = NonNullable<Input["metadata"]>;
 type FinalizeMetadataData = {

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

@@ -1,6 +1,6 @@
 import { access, context, object, ObjectStep, sideEffect, } from "postgraphile/grafast";
 import { gql, extendSchema } from "postgraphile/utils";
-import * as z from "zod";
+import * as z from "zod/v4";
 import { GraphQLError } from "graphql";
 import { DbHashKind, dbLockHouseBankroll, dbLockPlayerBalance, exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
@@ -199,6 +199,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         experienceId: session.experience_id,
                                         casinoId: session.casino_id,
                                         hashChainId: input.hashChainId,
+                                        active: "must-be-active",
                                     });
                                     if (!dbHashChain || !dbHashChain.active) {
                                         return {

package/dist/src/plugins/hub-put-alert.js

@@ -1,9 +1,9 @@
 import { context, lambda } from "postgraphile/grafast";
-import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+import { gql, extendSchema } from "postgraphile/utils";
 import { jsonParse } from "postgraphile/@dataplan/json";
 import { listenWithFilter } from "./listen-with-filter.js";
 import { logger } from "../logger.js";
-export const HubPutAlertPlugin = makeExtendSchemaPlugin(() => {
+export const HubPutAlertPlugin = extendSchema((_build) => {
     return {
         typeDefs: gql `
       extend type Subscription {

package/dist/src/plugins/listen-with-filter.d.ts

@@ -6,7 +6,7 @@ export declare class ListenWithFilterStep<TTopics extends {
 }, TTopic extends keyof TTopics, TPayloadStep extends Step, TFilterInput> extends Step<TTopics[TTopic][]> {
     itemPlan: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep;
     filterFn: (item: unknown, filterInput: TFilterInput) => boolean;
-    static $$export: {
+    static $export: {
         moduleName: string;
         exportName: string;
     };
@@ -14,9 +14,10 @@ export declare class ListenWithFilterStep<TTopics extends {
     private pubsubDep;
     private topicDep;
     private filterInputDep;
-    constructor(pubsubOrPlan: Step<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: Step<TTopic> | string, itemPlan: ((itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep) | undefined, filterInputPlan: Step<TFilterInput>, filterFn: (item: unknown, filterInput: TFilterInput) => boolean);
+    private initialEventDep;
+    constructor(pubsubOrPlan: Step<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: Step<TTopic> | string, itemPlan: ((itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep) | undefined, filterInputPlan: Step<TFilterInput>, filterFn: (item: unknown, filterInput: TFilterInput) => boolean, $initialEvent?: Step<TTopics[TTopic]>);
     execute({ indexMap, values, stream, }: ExecutionDetails<readonly [GrafastSubscriber<TTopics>, TTopic]>): GrafastResultStreamList<TTopics[TTopic]>;
 }
 export declare function listenWithFilter<TTopics extends {
     [topic: string]: any;
-}, TTopic extends keyof TTopics, TPayloadStep extends Step, TFilterInput>(pubsubOrPlan: Step<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: Step<TTopic> | string, itemPlan: ((itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep) | undefined, filterInputPlan: Step<TFilterInput>, filterFn: (item: unknown, filterInput: TFilterInput) => boolean): ListenWithFilterStep<TTopics, TTopic, TPayloadStep, TFilterInput>;
+}, TTopic extends keyof TTopics, TPayloadStep extends Step, TFilterInput>(pubsubOrPlan: Step<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: Step<TTopic> | string, itemPlan: ((itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep) | undefined, filterInputPlan: Step<TFilterInput>, filterFn: (item: unknown, filterInput: TFilterInput) => boolean, $initialEvent?: Step<TTopics[TTopic]>): ListenWithFilterStep<TTopics, TTopic, TPayloadStep, TFilterInput>;

package/dist/src/plugins/listen-with-filter.js

@@ -1,9 +1,9 @@
-import { constant, isDev, isExecutableStep, SafeError, } from "postgraphile/grafast";
+import { constant, isDev, isStep, SafeError, } from "postgraphile/grafast";
 import { Step } from "postgraphile/grafast";
 export class ListenWithFilterStep extends Step {
     itemPlan;
     filterFn;
-    static $$export = {
+    static $export = {
         moduleName: "grafast",
         exportName: "ListenWithFilterStep",
     };
@@ -11,17 +11,21 @@ export class ListenWithFilterStep extends Step {
     pubsubDep;
     topicDep;
     filterInputDep;
-    constructor(pubsubOrPlan, topicOrPlan, itemPlan = ($item) => $item, filterInputPlan, filterFn) {
+    initialEventDep = null;
+    constructor(pubsubOrPlan, topicOrPlan, itemPlan = ($item) => $item, filterInputPlan, filterFn, $initialEvent) {
         super();
         this.itemPlan = itemPlan;
         this.filterFn = filterFn;
         const $topic = typeof topicOrPlan === "string" ? constant(topicOrPlan) : topicOrPlan;
-        const $pubsub = isExecutableStep(pubsubOrPlan)
+        const $pubsub = isStep(pubsubOrPlan)
             ? pubsubOrPlan
             : constant(pubsubOrPlan, false);
         this.pubsubDep = this.addDependency($pubsub);
         this.topicDep = this.addDependency($topic);
         this.filterInputDep = this.addDependency(filterInputPlan);
+        if ($initialEvent) {
+            this.initialEventDep = this.addDependency($initialEvent);
+        }
     }
     execute({ indexMap, values, stream, }) {
         if (!stream) {
@@ -30,20 +34,22 @@ export class ListenWithFilterStep extends Step {
         const pubsubValue = values[this.pubsubDep];
         const topicValue = values[this.topicDep];
         const filterInputValue = values[this.filterInputDep];
+        const initialEventValue = this.initialEventDep !== null ? values[this.initialEventDep] : null;
         return indexMap((i) => {
             const pubsub = pubsubValue.at(i);
             if (!pubsub) {
                 throw new SafeError("Subscription not supported", isDev
                     ? {
-                        hint: `${this.dependencies[this.pubsubDep]} did not provide a GrafastSubscriber; perhaps you forgot to add the relevant property to context?`,
+                        hint: `Pubsub did not provide a GrafastSubscriber; perhaps you forgot to add the relevant property to context?`,
                     }
                     : {});
             }
             const topic = topicValue.at(i);
             const filterInput = filterInputValue.at(i);
             const origStream = pubsub.subscribe(topic);
+            const initialEvent = initialEventValue?.at(i);
             const filterFn = this.filterFn;
-            return {
+            const filteredStream = {
                 [Symbol.asyncIterator]: async function* () {
                     const iterator = await origStream;
                     for await (const item of iterator) {
@@ -53,9 +59,60 @@ export class ListenWithFilterStep extends Step {
                     }
                 },
             };
+            if (initialEvent === undefined) {
+                return filteredStream;
+            }
+            else {
+                if (filterFn(initialEvent, filterInput)) {
+                    return withInitialValue(initialEvent, filteredStream);
+                }
+                else {
+                    return filteredStream;
+                }
+            }
         });
     }
 }
-export function listenWithFilter(pubsubOrPlan, topicOrPlan, itemPlan = ($item) => $item, filterInputPlan, filterFn) {
-    return new ListenWithFilterStep(pubsubOrPlan, topicOrPlan, itemPlan, filterInputPlan, filterFn);
+export function listenWithFilter(pubsubOrPlan, topicOrPlan, itemPlan = ($item) => $item, filterInputPlan, filterFn, $initialEvent) {
+    return new ListenWithFilterStep(pubsubOrPlan, topicOrPlan, itemPlan, filterInputPlan, filterFn, $initialEvent);
 }
+const DONE = Object.freeze({ value: undefined, done: true });
+const withInitialValue = (initialVal, source) => ({
+    [Symbol.asyncIterator]() {
+        const sourceIterator = source[Symbol.asyncIterator]();
+        let first = true;
+        let done = null;
+        return {
+            async next() {
+                if (done)
+                    return done;
+                if (first) {
+                    first = false;
+                    return { value: initialVal, done: false };
+                }
+                const res = await sourceIterator.next();
+                if (res.done)
+                    done = res;
+                return res;
+            },
+            async return(value) {
+                done ??= { value: value, done: true };
+                if (typeof sourceIterator.return === "function") {
+                    try {
+                        await sourceIterator.return();
+                    }
+                    catch {
+                    }
+                }
+                return done;
+            },
+            async throw(err) {
+                done ??= DONE;
+                if (typeof sourceIterator.throw === "function") {
+                    return sourceIterator.throw(err);
+                }
+                throw err;
+            },
+        };
+    },
+});

package/dist/src/plugins/validate-fields.js

@@ -1,15 +1,16 @@
 import { sideEffect } from "postgraphile/grafast";
 import { GraphQLError } from "postgraphile/graphql";
-import { makeWrapPlansPlugin } from "postgraphile/utils";
-import * as v from "../validate.js";
-import * as Yup from "yup";
+import { wrapPlans } from "postgraphile/utils";
+import * as v from "../validate-zod.js";
+import z, { prettifyError } from "zod/v4";
 function validate(value, schema) {
     try {
-        schema.validateSync(value, { strict: true, abortEarly: true });
+        schema.parse(value);
     }
     catch (e) {
-        if (e instanceof Yup.ValidationError) {
-            const errorMessage = e.path ? `${e.path}: ${e.errors[0]}` : e.errors[0];
+        if (e instanceof z.ZodError) {
+            const fieldPath = e.issues.map((issue) => issue.path.join(".")).join(".");
+            const errorMessage = `Field "${fieldPath}": ${prettifyError(e)}`;
             throw new GraphQLError(errorMessage);
         }
         else {
@@ -17,45 +18,36 @@ function validate(value, schema) {
         }
     }
 }
-const casinoPatchSchema = Yup.object()
-    .shape({
-    name: Yup.string().trim().min(1),
-    graphqlUrl: v.graphqlUrl(),
+const CasinoPatchSchema = z.strictObject({
+    name: z.string().trim().min(1).optional(),
+    graphqlUrl: v.graphqlUrl().optional(),
+    baseUrl: v.baseUrl().optional(),
+});
+const AddCasinoSchema = z.strictObject({
+    name: z.string().trim().min(1),
     baseUrl: v.baseUrl(),
-})
-    .strict()
-    .noUnknown();
-const addCasinoSchema = Yup.object()
-    .shape({
-    name: Yup.string().trim().min(1).required(),
-    baseUrl: v.baseUrl().required(),
-    graphqlUrl: v.graphqlUrl().required(),
-    apiKey: v.uuid().required(),
-})
-    .strict()
-    .noUnknown();
-const updateBankrollSchema = Yup.object()
-    .shape({
-    amount: Yup.number().integer().min(0).required(),
-})
-    .strict()
-    .noUnknown();
-export const ValidateCasinoFieldsPlugin = makeWrapPlansPlugin({
+    graphqlUrl: v.graphqlUrl(),
+    apiKey: z.uuid(),
+});
+const UpdateBankrollSchema = z.strictObject({
+    amount: z.number().int().min(0),
+});
+export const ValidateCasinoFieldsPlugin = wrapPlans(() => ({
     Mutation: {
         updateHubCasinoById: (plan, $source, fieldArgs) => {
             const $patch = fieldArgs.getRaw(["input", "hubCasinoPatch"]);
-            sideEffect($patch, (patch) => validate(patch, casinoPatchSchema));
+            sideEffect($patch, (patch) => validate(patch, CasinoPatchSchema));
             return plan();
         },
         hubAddCasino: (plan, $source, fieldArgs) => {
             const $input = fieldArgs.getRaw(["input"]);
-            sideEffect($input, (input) => validate(input, addCasinoSchema));
+            sideEffect($input, (input) => validate(input, AddCasinoSchema));
             return plan();
         },
         updateHubBankrollById: (plan, $source, fieldArgs) => {
             const $patch = fieldArgs.getRaw(["input", "hubBankrollPatch"]);
-            sideEffect($patch, (patch) => validate(patch, updateBankrollSchema));
+            sideEffect($patch, (patch) => validate(patch, UpdateBankrollSchema));
             return plan();
         },
     },
-});
+}));

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

@@ -6,7 +6,7 @@ import { logger } from "../logger.js";
 import * as config from "../config.js";
 import * as db from "../db/index.js";
 import * as pg from "pg";
-import { z } from "zod";
+import { z } from "zod/v4";
 const activeCasinos = new Set();
 export async function startCasinoTransferProcessor({ casinoId, signal, pool, }) {
     if (activeCasinos.has(casinoId)) {

package/dist/src/risk-policy.js

@@ -1,6 +1,6 @@
 import { formatCurrency } from "./format-currency.js";
 import { logger } from "./logger.js";
-import { z } from "zod";
+import { z } from "zod/v4";
 const RiskLimitsSchema = z
     .object({
     maxWager: z.number().positive().optional(),

package/dist/src/services/jwt-service.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "zod/v4";
 import * as jose from "jose";
 import { gql } from "../__generated__/gql.js";
 import { maybeOneRow } from "../db/util.js";

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

@@ -589,20 +589,18 @@ export async function completeTransfer({ mpTakeRequestId, takeRequestId, mpTrans
                             logger.warn({ mpTransferId, takeRequestId }, `[completeTransfer] Transfer was already refunded. This should never happen.`);
                             break;
                         }
-                        const dbBalanceAfterUpdate = await pgClient
+                        const dbLockedBalance = await pgClient
                             .query({
                             text: `
-                UPDATE hub.balance
-                SET amount = amount + $1
-                WHERE user_id = $2 
-                  AND experience_id = $3 
-                  AND casino_id = $4 
-                  AND currency_key = $5
-
-                RETURNING id, amount
+                SELECT id, amount
+                FROM hub.balance
+                WHERE user_id = $1
+                  AND experience_id = $2
+                  AND casino_id = $3
+                  AND currency_key = $4
+                FOR UPDATE
               `,
                             values: [
-                                takeRequestData.reserved_amount,
                                 takeRequestData.user_id,
                                 takeRequestData.experience_id,
                                 takeRequestData.casino_id,
@@ -610,10 +608,18 @@ export async function completeTransfer({ mpTakeRequestId, takeRequestId, mpTrans
                             ],
                         })
                             .then(exactlyOneRow);
+                        await pgClient.query({
+                            text: `
+                UPDATE hub.balance
+                SET amount = amount + $1
+                WHERE id = $2
+              `,
+                            values: [takeRequestData.reserved_amount, dbLockedBalance.id],
+                        });
                         await insertAuditLog(pgClient, "player-balance", {
-                            balanceId: dbBalanceAfterUpdate.id,
-                            balanceOld: dbBalanceAfterUpdate.amount - takeRequestData.reserved_amount,
-                            balanceNew: dbBalanceAfterUpdate.amount,
+                            balanceId: dbLockedBalance.id,
+                            balanceOld: dbLockedBalance.amount,
+                            balanceNew: dbLockedBalance.amount + takeRequestData.reserved_amount,
                             balanceDelta: takeRequestData.reserved_amount,
                             action: "hub:take_request:refund",
                             refType: "hub.take_request",

package/dist/src/validate-zod.d.ts

@@ -0,0 +1,3 @@
+import z from "zod/v4";
+export declare const baseUrl: () => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<URL, string>>, z.ZodTransform<string, URL>>;
+export declare const graphqlUrl: () => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<URL, string>>, z.ZodTransform<string, URL>>;

package/dist/src/validate-zod.js

@@ -0,0 +1,19 @@
+import z from "zod/v4";
+export const baseUrl = () => z
+    .string()
+    .trim()
+    .min(1, "Base URL is required")
+    .refine((val) => URL.canParse(val), "Base URL is not a valid URL")
+    .transform((val) => new URL(val))
+    .refine((val) => val.protocol === "http:" || val.protocol === "https:", "Base URL must use http or https protocol")
+    .refine((val) => val.pathname === "/" && val.search === "" && val.hash === "", "Base URL must have no path, query, nor hash")
+    .transform((val) => val.toString().replace(/\/$/, ""));
+export const graphqlUrl = () => z
+    .string()
+    .trim()
+    .min(1, "GraphQL URL is required")
+    .refine((val) => URL.canParse(val), "GraphQL URL is not a valid URL")
+    .transform((val) => new URL(val))
+    .refine((val) => val.protocol === "http:" || val.protocol === "https:", "GraphQL URL must use http or https protocol")
+    .refine((val) => val.pathname === "/graphql", "GraphQL URL must have /graphql path")
+    .transform((val) => val.toString().replace(/\/$/, ""));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.17.0-dev.1",
+  "version": "1.17.0-dev.2",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [
@@ -59,10 +59,9 @@
     "pg": "^8.12.0",
     "pg-connection-string": "^2.6.4",
     "pino": "^9.7.0",
-    "postgraphile": "^5.0.0-beta.48",
+    "postgraphile": "^5.0.0-beta.49",
     "tsafe": "^1.6.6",
-    "yup": "^1.6.1",
-    "zod": "^3.23.5"
+    "zod": "^4.1.12"
   },
   "devDependencies": {
     "@eslint/js": "^9.8.0",