@moneypot/hub 1.2.6 → 1.3.0-dev.1

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

@@ -1,15 +1,15 @@
-import pg, { QueryResult, QueryResultRow } from "pg";
+import * as pg from "pg";
 import stream from "node:stream";
 import { DbCasino, DbExperience, DbSession, DbTransferStatusKind, DbUser, DbWithdrawal } from "./types.js";
 import { TransferStatusKind } from "../__generated__/graphql.js";
 export * from "./types.js";
 export * from "./public.js";
 export * from "./util.js";
-export declare function getPgClient(connectionString: string): pg.Client;
+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 QueryResultRow = any>(queryText: string, values?: any[]): Promise<QueryResult<T>>;
+    query<T extends pg.QueryResultRow = any>(queryText: string, values?: any[]): Promise<pg.QueryResult<T>>;
 }
 export declare class UserFriendlyError extends Error {
     constructor(userFriendlyMessage: string);
@@ -17,36 +17,36 @@ export declare class UserFriendlyError extends Error {
 export type PgClientInTransaction = pg.PoolClient & {
     _inTransaction: true;
 };
-export declare function withPgPoolTransaction<T>(pool: pg.Pool, callback: (_client: PgClientInTransaction) => Promise<T>, retryCount?: number, maxRetries?: number): Promise<T>;
-export declare function userFromActiveSessionKey(pool: pg.Pool, sessionKey: string): Promise<{
+export declare function withPgPoolTransaction<T>(pool: InstanceType<typeof pg.Pool>, callback: (_pgClient: PgClientInTransaction) => Promise<T>, retryCount?: number, maxRetries?: number): Promise<T>;
+export declare function userFromActiveSessionKey(pgClient: QueryExecutor, sessionKey: string): Promise<{
     user: DbUser;
     sessionId: DbSession["id"];
 } | null>;
 declare class DatabaseNotifier extends stream.EventEmitter {
-    private client;
+    private pgClient;
     constructor(connectionString: string);
     close(): Promise<void>;
     listen(): Promise<void>;
 }
 export declare const notifier: DatabaseNotifier;
-export declare function getTransferCursor(pool: pg.Pool, { casinoId, }: {
+export declare function getTransferCursor(pgClient: QueryExecutor, { casinoId, }: {
     casinoId: string;
 }): Promise<string | undefined>;
-export declare function setTransferCursor(pool: pg.Pool, { cursor, casinoId, }: {
+export declare function setTransferCursor(pgClient: QueryExecutor, { cursor, casinoId, }: {
     casinoId: string;
     cursor: string;
 }): Promise<void>;
-export declare function upsertUser(pool: pg.Pool, { uname, casinoId, mpUserId, }: {
+export declare function upsertUser(pgClient: QueryExecutor, { uname, casinoId, mpUserId, }: {
     uname: string;
     casinoId: string;
     mpUserId: string;
 }): Promise<DbUser>;
-export declare function upsertExperience(pool: pg.Pool, { casinoId, mpExperienceId, name, }: {
+export declare function upsertExperience(pgClient: QueryExecutor, { casinoId, mpExperienceId, name, }: {
     casinoId: string;
     mpExperienceId: string;
     name: string;
 }): Promise<DbExperience>;
-export declare function insertDeposit(pool: pg.Pool, o: {
+export declare function insertDeposit(pool: InstanceType<typeof pg.Pool>, o: {
     casinoId: string;
     mpTransferId: string;
     userId: string;
@@ -54,7 +54,7 @@ export declare function insertDeposit(pool: pg.Pool, o: {
     amount: number;
     currency: string;
 }): Promise<null | undefined>;
-export declare function processWithdrawal(pool: pg.Pool, { casinoId, mpTransferId, userId, experienceId, amount, currency, status, }: {
+export declare function processWithdrawal(pgClient: PgClientInTransaction, { casinoId, mpTransferId, userId, experienceId, amount, currency, status, }: {
     casinoId: string;
     mpTransferId: string;
     userId: string;
@@ -63,14 +63,14 @@ export declare function processWithdrawal(pool: pg.Pool, { casinoId, mpTransferI
     currency: string;
     status: Extract<TransferStatusKind, "PENDING" | "COMPLETED" | "CANCELED">;
 }): Promise<void>;
-export declare function getUnconfirmedWithdrawals(pool: pg.Pool, { casinoId, limit, }: {
+export declare function getUnconfirmedWithdrawals(pgClient: QueryExecutor, { casinoId, limit, }: {
     casinoId: string;
     limit: number;
 }): Promise<(DbWithdrawal & {
     mp_experience_id: string;
     mp_user_id: string;
 })[]>;
-export declare function getPendingWithdrawals(pool: pg.Pool, { casinoId, limit, }: {
+export declare function getPendingWithdrawals(pgClient: QueryExecutor, { casinoId, limit, }: {
     casinoId: string;
     limit: number;
 }): Promise<(DbWithdrawal & {
@@ -81,7 +81,7 @@ export declare function settleWithdrawal({ withdrawalId, newStatus, }: {
     withdrawalId: string;
     newStatus: Extract<DbTransferStatusKind, "COMPLETED" | "CANCELED">;
 }): Promise<void>;
-export declare function listCasinos(pool: pg.Pool): Promise<DbCasino[]>;
+export declare function listCasinos(pgClient: QueryExecutor): Promise<DbCasino[]>;
 export declare function upsertCurrencies(pgClient: QueryExecutor, { casinoId, currencies, }: {
     casinoId: string;
     currencies: {

package/dist/src/db/index.js

@@ -1,4 +1,4 @@
-import pg from "pg";
+import * as pg from "pg";
 import config from "../config.js";
 import stream from "node:stream";
 import { exactlyOneRow, maybeOneRow } from "./util.js";
@@ -31,25 +31,25 @@ const PG_ERROR_CODE = {
     serializationFailure: "40001",
 };
 export async function withPgPoolTransaction(pool, callback, retryCount = 0, maxRetries = 3) {
-    let client = null;
+    let pgClient = null;
     try {
-        client = await pool.connect();
-        await client.query("begin isolation level serializable");
-        client._inTransaction = true;
-        const result = await callback(client);
-        await client.query("commit");
+        pgClient = await pool.connect();
+        await pgClient.query("begin isolation level serializable");
+        pgClient._inTransaction = true;
+        const result = await callback(pgClient);
+        await pgClient.query("commit");
         return result;
     }
     catch (error) {
-        if (client) {
+        if (pgClient) {
             try {
-                await client.query("rollback");
+                await pgClient.query("rollback");
             }
             catch (rollbackError) {
                 logger.error("Original error:", error);
                 logger.error("Rollback failed:", rollbackError);
-                client.release(true);
-                client = null;
+                pgClient.release(true);
+                pgClient = null;
                 throw error;
             }
             if (retryCount < maxRetries &&
@@ -65,13 +65,13 @@ export async function withPgPoolTransaction(pool, callback, retryCount = 0, maxR
         throw error;
     }
     finally {
-        if (client) {
-            client.release();
+        if (pgClient) {
+            pgClient.release();
         }
     }
 }
-export async function userFromActiveSessionKey(pool, sessionKey) {
-    const result = await pool
+export async function userFromActiveSessionKey(pgClient, sessionKey) {
+    const result = await pgClient
         .query(`
         select u.id, u.uname, u.casino_id, s.experience_id, u.mp_user_id, s.id as session_id
         from hub.active_session s
@@ -90,20 +90,20 @@ export async function userFromActiveSessionKey(pool, sessionKey) {
     };
 }
 class DatabaseNotifier extends stream.EventEmitter {
-    client;
+    pgClient;
     constructor(connectionString) {
         super();
-        this.client = new pg.Client({ connectionString });
+        this.pgClient = new pg.Client({ connectionString });
     }
     async close() {
-        await this.client.end();
+        await this.pgClient.end();
         logger.info("[DatabaseNotifier] Database connection closed");
     }
     async listen() {
         logger.info("[DatabaseNotifier] listening for balance updates");
-        await this.client.connect();
-        await this.client.query("LISTEN balance_update");
-        this.client.on("notification", (notification) => {
+        await this.pgClient.connect();
+        await this.pgClient.query("LISTEN balance_update");
+        this.pgClient.on("notification", (notification) => {
             if (!notification.payload) {
                 logger.error("[DatabaseNotifier] postgres notification missing payload");
                 return;
@@ -121,23 +121,23 @@ class DatabaseNotifier extends stream.EventEmitter {
     }
 }
 export const notifier = new DatabaseNotifier(config.DATABASE_URL);
-export async function getTransferCursor(pool, { casinoId, }) {
-    const row = await pool
+export async function getTransferCursor(pgClient, { casinoId, }) {
+    const row = await pgClient
         .query("select cursor from hub_hidden.transfer_cursor where casino_id = $1", [casinoId])
         .then(maybeOneRow);
     return row?.cursor;
 }
-export async function setTransferCursor(pool, { cursor, casinoId, }) {
+export async function setTransferCursor(pgClient, { cursor, casinoId, }) {
     console.log(`[setTransferCursor] SETTING CURSOR..... ${cursor}`);
-    await pool.query(`
+    await pgClient.query(`
     insert into hub_hidden.transfer_cursor (casino_id, cursor)
     values ($1, $2)
     on conflict (casino_id) do update set cursor = $2
     returning cursor
     `, [casinoId, cursor]);
 }
-export async function upsertUser(pool, { uname, casinoId, mpUserId, }) {
-    const user = await pool
+export async function upsertUser(pgClient, { uname, casinoId, mpUserId, }) {
+    const user = await pgClient
         .query(`
         WITH ins AS (
             INSERT INTO hub.user (casino_id, mp_user_id, uname)
@@ -154,8 +154,8 @@ export async function upsertUser(pool, { uname, casinoId, mpUserId, }) {
         .then(exactlyOneRow);
     return user;
 }
-export async function upsertExperience(pool, { casinoId, mpExperienceId, name, }) {
-    return pool
+export async function upsertExperience(pgClient, { casinoId, mpExperienceId, name, }) {
+    return pgClient
         .query(`
             WITH ins AS (
                 INSERT INTO hub.experience (casino_id, mp_experience_id, name)
@@ -200,9 +200,9 @@ export async function insertDeposit(pool, o) {
       `, [o.casinoId, o.userId, o.experienceId, o.currency, o.amount]);
     });
 }
-export async function processWithdrawal(pool, { casinoId, mpTransferId, userId, experienceId, amount, currency, status, }) {
-    return withPgPoolTransaction(pool, async (client) => {
-        await client.query(`
+export async function processWithdrawal(pgClient, { casinoId, mpTransferId, userId, experienceId, amount, currency, status, }) {
+    assert(pgClient._inTransaction, "pgClient must be in transaction");
+    await pgClient.query(`
       INSERT INTO hub.withdrawal (
         casino_id, 
         mp_transfer_id, 
@@ -223,18 +223,17 @@ export async function processWithdrawal(pool, { casinoId, mpTransferId, userId,
             ELSE withdrawal.status_at 
           END
       `, [
-            casinoId,
-            mpTransferId,
-            userId,
-            experienceId,
-            amount,
-            currency,
-            status,
-        ]);
-    });
+        casinoId,
+        mpTransferId,
+        userId,
+        experienceId,
+        amount,
+        currency,
+        status,
+    ]);
 }
-export async function getUnconfirmedWithdrawals(pool, { casinoId, limit, }) {
-    const result = await pool.query(`
+export async function getUnconfirmedWithdrawals(pgClient, { casinoId, limit, }) {
+    const result = await pgClient.query(`
         select 
           e.mp_experience_id mp_experience_id, 
           u.mp_user_id mp_user_id,
@@ -249,8 +248,8 @@ export async function getUnconfirmedWithdrawals(pool, { casinoId, limit, }) {
     `, [casinoId, limit]);
     return result.rows;
 }
-export async function getPendingWithdrawals(pool, { casinoId, limit, }) {
-    const result = await pool.query(`
+export async function getPendingWithdrawals(pgClient, { casinoId, limit, }) {
+    const result = await pgClient.query(`
         select 
           e.mp_experience_id mp_experience_id, 
           u.mp_user_id mp_user_id,
@@ -316,8 +315,8 @@ export async function settleWithdrawal({ withdrawalId, newStatus, }) {
         }
     });
 }
-export async function listCasinos(pool) {
-    const result = await pool.query("select * from hub.casino");
+export async function listCasinos(pgClient) {
+    const result = await pgClient.query("select * from hub.casino");
     return result.rows;
 }
 export async function upsertCurrencies(pgClient, { casinoId, currencies, }) {

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

@@ -1,7 +1,8 @@
-import { Pool } from "pg";
+import * as pg from "pg";
 import { DbCasino, DbCasinoSecret } from "./types.js";
+import { QueryExecutor } from "./index.js";
 type NewCasino = Pick<DbCasino, "name" | "base_url" | "graphql_url"> & Pick<DbCasinoSecret, "controller_id" | "api_key">;
-export declare function dbInsertCasino(pool: Pool, input: NewCasino): Promise<DbCasino>;
-export declare function dbGetCasinoById(pool: Pool, casinoId: DbCasino["id"]): Promise<DbCasino | undefined>;
-export declare function dbGetCasinoSecretById(pool: Pool, casinoId: DbCasino["id"]): Promise<DbCasinoSecret | undefined>;
+export declare function dbInsertCasino(pool: InstanceType<typeof pg.Pool>, input: NewCasino): Promise<DbCasino>;
+export declare function dbGetCasinoById(pgClient: QueryExecutor, casinoId: DbCasino["id"]): Promise<DbCasino | undefined>;
+export declare function dbGetCasinoSecretById(pgClient: QueryExecutor, casinoId: DbCasino["id"]): Promise<DbCasinoSecret | undefined>;
 export {};

package/dist/src/db/internal.js

@@ -1,20 +1,23 @@
 import { exactlyOneRow, maybeOneRow } from "./util.js";
+import { withPgPoolTransaction } from "./index.js";
 export async function dbInsertCasino(pool, input) {
-    const casino = await pool
-        .query(`
+    return withPgPoolTransaction(pool, async (pgClient) => {
+        const casino = await pgClient
+            .query(`
     INSERT INTO hub.casino (name, base_url, graphql_url)
     VALUES ($1, $2, $3)
     RETURNING *
   `, [input.name, input.base_url, input.graphql_url])
-        .then(exactlyOneRow);
-    await pool.query(`
+            .then(exactlyOneRow);
+        await pgClient.query(`
     INSERT INTO hub.casino_secret (id, controller_id, api_key)
     VALUES ($1, $2, $3)
   `, [casino.id, input.controller_id, input.api_key]);
-    return casino;
+        return casino;
+    });
 }
-export async function dbGetCasinoById(pool, casinoId) {
-    return pool
+export async function dbGetCasinoById(pgClient, casinoId) {
+    return pgClient
         .query(`
     SELECT *
     FROM hub.casino
@@ -22,8 +25,8 @@ export async function dbGetCasinoById(pool, casinoId) {
   `, [casinoId])
         .then(maybeOneRow);
 }
-export async function dbGetCasinoSecretById(pool, casinoId) {
-    return pool
+export async function dbGetCasinoSecretById(pgClient, casinoId) {
+    return pgClient
         .query(`
     SELECT *
     FROM hub.casino_secret

package/dist/src/index.d.ts

@@ -1,5 +1,6 @@
 import { Express } from "express";
 import { Logger } from "./logger.js";
+export { MakeOutcomeBetPlugin } from "./plugins/hub-make-outcome-bet.js";
 export { defaultPlugins, type PluginContext, type PluginIdentity, type UserSessionContext, } from "./server/graphile.config.js";
 export type ServerOptions = {
     configureApp?: (app: Express) => void;

package/dist/src/index.js

@@ -5,6 +5,7 @@ import { createHubServer } from "./server/index.js";
 import { initializeTransferProcessors } from "./process-transfers.js";
 import { join } from "path";
 import { logger, setLogger } from "./logger.js";
+export { MakeOutcomeBetPlugin } from "./plugins/hub-make-outcome-bet.js";
 export { defaultPlugins, } from "./server/graphile.config.js";
 async function initialize(options) {
     if (options.logger) {
@@ -54,6 +55,9 @@ async function initialize(options) {
     });
 }
 export async function startAndListen(options) {
+    if (options.plugins && options.plugins.some((p) => typeof p === "function")) {
+        throw new Error("`plugins` should be an array of GraphileConfig.Plugin but one of the items is a function. Did you forget to call it?");
+    }
     if (options.userDatabaseMigrationsPath &&
         !options.userDatabaseMigrationsPath.startsWith("/")) {
         throw new Error(`userDatabaseMigrationsPath must be an absolute path, got ${options.userDatabaseMigrationsPath}`);

package/dist/src/pg-versions/005-outcome-bet.sql

@@ -0,0 +1,56 @@
+create type hub.outcome as (
+    weight float,
+    profit float
+);
+
+create table hub.outcome_bet (
+    id           uuid primary key default hub_hidden.uuid_generate_v7(),
+
+    -- Operator-given kind like "WHEEL", "PLINKO", 
+    -- Probably not worth using a postgres enum here since they are not flexible.
+    kind         text not null,
+
+    user_id       uuid not null references hub.user(id),
+    experience_id uuid not null references hub.experience(id),
+    casino_id     uuid not null references hub.casino(id),
+
+    currency_key text not null,
+    wager        float not null,
+
+    -- -1 = lose wager, -2 = lose 2x wager
+    -- 0.5 = 1.5x wager, 1 = 2x wager
+    -- In other words, a multiplier in a game might say "2.5x", 
+    -- but the profit is multiplier-1 = 1.5 profit
+    profit       float not null,
+
+    -- null when no outcomes saved
+    outcome_idx  smallint null,
+    outcomes     hub.outcome[] not null default '{}',
+
+    -- Operator-provided data per bet
+    metadata     jsonb not null default '{}',
+
+    foreign key (currency_key, casino_id) references hub.currency(key, casino_id)
+);
+
+create index outcome_bet_user_id_idx on hub.outcome_bet(user_id);
+create index outcome_bet_experience_id_idx on hub.outcome_bet(experience_id);
+create index outcome_bet_casino_id_idx on hub.outcome_bet(casino_id);
+create index outcome_bet_kind_idx on hub.outcome_bet(kind);
+
+-- GRANT
+
+grant select on hub.outcome_bet to app_postgraphile;
+
+-- RLS
+
+alter table hub.outcome_bet enable row level security;
+
+create policy select_outcome_bet on hub.outcome_bet for select using (
+    hub_hidden.is_operator() or
+    (
+        user_id = hub_hidden.current_user_id() and
+        experience_id = hub_hidden.current_experience_id() and
+        casino_id = hub_hidden.current_casino_id()
+    )
+);

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

@@ -1,7 +1,8 @@
 import { object } from "grafast";
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
-import { superuserPool, withPgPoolTransaction } from "../db/index.js";
+import { superuserPool, withPgPoolTransaction, } from "../db/index.js";
 import { constant, context, sideEffect } from "postgraphile/grafast";
+import { assert } from "tsafe";
 const CLAIM_AMOUNT = 1000;
 export const HubClaimFaucetPlugin = makeExtendSchemaPlugin(() => {
     return {
@@ -74,6 +75,7 @@ export const HubClaimFaucetPlugin = makeExtendSchemaPlugin(() => {
     };
 });
 async function upsertPlayCurrency(pgClient, casinoId) {
+    assert(pgClient._inTransaction, "pgClient must be in transaction");
     return pgClient.query({
         text: `
       insert into hub.currency (casino_id, key, display_unit_name, display_unit_scale)

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

@@ -0,0 +1,57 @@
+import { z } from "zod";
+declare const InputSchema: z.ZodObject<{
+    kind: z.ZodString;
+    wager: z.ZodNumber;
+    currency: z.ZodString;
+    outcomes: z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodObject<{
+        weight: z.ZodNumber;
+        profit: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        weight: number;
+        profit: number;
+    }, {
+        weight: number;
+        profit: number;
+    }>, "many">, {
+        weight: number;
+        profit: number;
+    }[], {
+        weight: number;
+        profit: number;
+    }[]>, {
+        weight: number;
+        profit: number;
+    }[], {
+        weight: number;
+        profit: number;
+    }[]>;
+}, "strict", z.ZodTypeAny, {
+    currency: string;
+    kind: string;
+    wager: number;
+    outcomes: {
+        weight: number;
+        profit: number;
+    }[];
+}, {
+    currency: string;
+    kind: string;
+    wager: number;
+    outcomes: {
+        weight: number;
+        profit: number;
+    }[];
+}>;
+type Input = z.infer<typeof InputSchema>;
+type BetConfig = {
+    houseEdge: number;
+    saveOutcomes: boolean;
+    getMetadata?: (input: Input) => Promise<Record<string, any>>;
+};
+export type BetConfigMap<BetKind extends string> = {
+    [betKind in BetKind]: BetConfig;
+};
+export declare function MakeOutcomeBetPlugin<BetKind extends string>({ betConfigs }: {
+    betConfigs: BetConfigMap<BetKind>;
+}): GraphileConfig.Plugin;
+export {};