@moneypot/hub 0.0.1

package/dist/src/plugins/hub-current-x.js

@@ -0,0 +1,62 @@
+import { gql, makeExtendSchemaPlugin } from "graphile-utils";
+import { context, inhibitOnNull, lambda } from "postgraphile/grafast";
+export const HubCurrentXPlugin = makeExtendSchemaPlugin((build) => {
+    const userTable = build.input.pgRegistry.pgResources.hub_user;
+    const casinoTable = build.input.pgRegistry.pgResources.hub_casino;
+    const experienceTable = build.input.pgRegistry.pgResources.hub_experience;
+    const sessionTable = build.input.pgRegistry.pgResources.hub_session;
+    return {
+        typeDefs: gql `
+      extend type Query {
+        hubCurrentUser: HubUser
+        hubCurrentCasino: HubCasino
+        hubCurrentExperience: HubExperience
+        hubCurrentSession: HubSession
+      }
+    `,
+        plans: {
+            Query: {
+                hubCurrentUser() {
+                    const $identity = context().get("identity");
+                    const $userId = lambda($identity, (identity) => {
+                        if (identity?.kind === "user") {
+                            return identity.session.user_id;
+                        }
+                        return null;
+                    });
+                    return userTable.get({ id: inhibitOnNull($userId) });
+                },
+                hubCurrentCasino() {
+                    const $identity = context().get("identity");
+                    const $casinoId = lambda($identity, (identity) => {
+                        if (identity?.kind === "user") {
+                            return identity.session.casino_id;
+                        }
+                        return null;
+                    });
+                    return casinoTable.get({ id: inhibitOnNull($casinoId) });
+                },
+                hubCurrentExperience() {
+                    const $identity = context().get("identity");
+                    const $experienceId = lambda($identity, (identity) => {
+                        if (identity?.kind === "user") {
+                            return identity.session.experience_id;
+                        }
+                        return null;
+                    });
+                    return experienceTable.get({ id: inhibitOnNull($experienceId) });
+                },
+                hubCurrentSession() {
+                    const $identity = context().get("identity");
+                    const $sessionId = lambda($identity, (identity) => {
+                        if (identity?.kind === "user") {
+                            return identity.session.session_id;
+                        }
+                        return null;
+                    });
+                    return sessionTable.get({ id: inhibitOnNull($sessionId) });
+                },
+            },
+        },
+    };
+});

package/dist/src/plugins/hub-schema-prefix.d.ts

@@ -0,0 +1 @@
+export declare const HubPrefixPlugin: GraphileConfig.Plugin;

package/dist/src/plugins/hub-schema-prefix.js

@@ -0,0 +1,25 @@
+export const HubPrefixPlugin = {
+    name: "HubPrefixPlugin",
+    version: "1.0.0",
+    after: ["PgTablesPlugin"],
+    inflection: {
+        replace: {
+            _schemaPrefix(previous, options, { pgNamespace, serviceName, }) {
+                const pgService = options.pgServices?.find((db) => db.name === serviceName);
+                const databasePrefix = serviceName === "main" ? "" : `${serviceName}_`;
+                let schemaPrefix;
+                if (pgNamespace.nspname === "hub" ||
+                    pgNamespace.nspname.startsWith("hub_")) {
+                    schemaPrefix = `${pgNamespace.nspname}_`;
+                }
+                else if (pgNamespace.nspname === pgService?.schemas?.[0]) {
+                    schemaPrefix = "";
+                }
+                else {
+                    schemaPrefix = `${pgNamespace.nspname}_`;
+                }
+                return `${databasePrefix}${schemaPrefix}`;
+            },
+        },
+    },
+};

package/dist/src/plugins/hub-user-balance-by-currency.d.ts

@@ -0,0 +1 @@
+export declare const HubUserBalanceByCurrencyPlugin: GraphileConfig.Plugin;

package/dist/src/plugins/hub-user-balance-by-currency.js

@@ -0,0 +1,55 @@
+import { access, context, loadOne, object, } from "postgraphile/grafast";
+import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+import { superuserPool } from "../db/index.js";
+import { pgSelectSingleFromRecord, } from "postgraphile/@dataplan/pg";
+export const HubUserBalanceByCurrencyPlugin = makeExtendSchemaPlugin((build) => {
+    const balances = build.input.pgRegistry.pgResources.hub_balance;
+    return {
+        typeDefs: gql `
+        extend type HubUser {
+          balanceByCurrency(currency: String!): HubBalance
+        }
+      `,
+        plans: {
+            HubUser: {
+                balanceByCurrency: ($record, { $currency }) => {
+                    const $identity = context().get("identity");
+                    const $params = object({
+                        currency: $currency,
+                        targetUserId: $record.get("id"),
+                        casino_id: access($identity, ["session", "casino_id"]),
+                        experience_id: access($identity, ["session", "experience_id"]),
+                    });
+                    const $balance = loadOne($params, batchGetUserBalanceByCurrency);
+                    return pgSelectSingleFromRecord(balances, $balance);
+                },
+            },
+        },
+    };
+});
+async function batchGetUserBalanceByCurrency(paramsArray) {
+    const values = [];
+    const valuePlaceholders = [];
+    paramsArray.forEach((p, index) => {
+        const baseIndex = index * 4 + 1;
+        valuePlaceholders.push(`($${baseIndex}, $${baseIndex + 1}::uuid, $${baseIndex + 2}::uuid, $${baseIndex + 3}::uuid)`);
+        values.push(p.currency, p.targetUserId, p.casino_id, p.experience_id);
+    });
+    const sql = `
+    SELECT b.*
+    FROM hub.balance b
+    JOIN (
+      VALUES
+        ${valuePlaceholders.join(",\n        ")}
+    ) AS vals(currency_key, user_id, casino_id, experience_id)
+    ON b.currency_key = vals.currency_key
+    AND b.user_id = vals.user_id
+    AND b.casino_id = vals.casino_id
+    AND b.experience_id = vals.experience_id
+  `;
+    const { rows } = await superuserPool.query(sql, values);
+    return paramsArray.map((p) => rows.find((row) => row.currency_key === p.currency &&
+        row.user_id === p.targetUserId &&
+        row.casino_id === p.casino_id &&
+        row.experience_id === p.experience_id));
+}

package/dist/src/plugins/hub-withdraw.d.ts

@@ -0,0 +1 @@
+export declare const HubWithdrawPlugin: GraphileConfig.Plugin;

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

@@ -0,0 +1,133 @@
+import { constant, context, object, sideEffect } from "postgraphile/grafast";
+import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+import { superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { exactlyOneRow, maybeOneRow } from "../db/util.js";
+import { GraphQLError } from "graphql";
+export const HubWithdrawPlugin = makeExtendSchemaPlugin((build) => {
+    const hubWithdrawalRequests = build.input.pgRegistry.pgResources.hub_withdrawal_request;
+    return {
+        typeDefs: gql `
+      input HubWithdrawInput {
+        amount: Int!
+        currency: String!
+      }
+
+      type HubWithdrawPayload {
+        withdrawalRequest: HubWithdrawalRequest!
+        query: Query
+      }
+
+      extend type Mutation {
+        hubWithdraw(input: HubWithdrawInput!): HubWithdrawPayload
+      }
+    `,
+        plans: {
+            Mutation: {
+                hubWithdraw(_, { $input }) {
+                    const $identity = context().get("identity");
+                    const $withdrawalRequestId = sideEffect([$input, $identity], ([input, identity]) => {
+                        if (identity?.kind !== "user") {
+                            throw new GraphQLError("You must be logged in");
+                        }
+                        const { session } = identity;
+                        return withPgPoolTransaction(superuserPool, async (pgClient) => {
+                            const { amount, currency } = input;
+                            if (amount <= 0) {
+                                throw new GraphQLError("Withdraw amount must be greater than zero");
+                            }
+                            if (!Number.isInteger(amount)) {
+                                throw new GraphQLError("Withdraw amount must be an integer");
+                            }
+                            const dbCurrency = await pgClient
+                                .query({
+                                text: `
+                      SELECT key
+                      FROM hub.currency
+                      WHERE key = $1 AND casino_id = $2
+                    `,
+                                values: [currency, session.casino_id],
+                            })
+                                .then(maybeOneRow);
+                            if (!dbCurrency) {
+                                throw new GraphQLError("Currency not supported");
+                            }
+                            const balance = await pgClient
+                                .query({
+                                text: `
+                      select *
+                      from hub.balance
+                      where currency_key = $1
+                        and user_id = $2
+                        and casino_id = $3
+                        and experience_id = $4
+
+                      FOR UPDATE
+                  `,
+                                values: [
+                                    currency,
+                                    session.user_id,
+                                    session.casino_id,
+                                    session.experience_id,
+                                ],
+                            })
+                                .then(maybeOneRow);
+                            if (!balance || balance.amount < amount) {
+                                throw new GraphQLError("Insufficient funds for withdrawal");
+                            }
+                            const dbWithdrawalRequest = await pgClient
+                                .query({
+                                text: `
+                    insert into hub.withdrawal_request(
+                      user_id, 
+                      experience_id, 
+                      casino_id,
+                      amount, 
+                      currency_key
+                    )
+                    values ($1, $2, $3, $4, $5)
+                    returning id
+                  `,
+                                values: [
+                                    session.user_id,
+                                    session.experience_id,
+                                    session.casino_id,
+                                    amount,
+                                    currency,
+                                ],
+                            })
+                                .then(exactlyOneRow);
+                            await pgClient.query({
+                                text: `
+                  update hub.balance
+                  set amount = amount - $1
+                  where user_id = $2
+                    and experience_id = $3
+                    and currency_key = $4
+                    and casino_id = $5
+                `,
+                                values: [
+                                    amount,
+                                    session.user_id,
+                                    session.experience_id,
+                                    currency,
+                                    session.casino_id,
+                                ],
+                            });
+                            return dbWithdrawalRequest.id;
+                        });
+                    });
+                    return object({
+                        withdrawalRequestId: $withdrawalRequestId,
+                        query: constant(true),
+                    });
+                },
+            },
+            HubWithdrawPayload: {
+                withdrawalRequest($data) {
+                    const $id = $data.get("withdrawalRequestId");
+                    return hubWithdrawalRequests.get({ id: $id });
+                },
+            },
+        },
+    };
+});

package/dist/src/plugins/id-to-node-id.d.ts

@@ -0,0 +1 @@
+export declare const IdToNodeIdPlugin: GraphileConfig.Plugin;

package/dist/src/plugins/id-to-node-id.js

@@ -0,0 +1,31 @@
+export const IdToNodeIdPlugin = {
+    name: "IdToNodeIdPlugin",
+    version: "1.0.0",
+    inflection: {
+        replace: {
+            nodeIdFieldName() {
+                return "nodeId";
+            },
+            attribute(previous, options, details) {
+                if (!previous) {
+                    throw new Error("There was no 'attribute' inflector to replace");
+                }
+                const name = previous(details);
+                if (name === "rowId") {
+                    return "id";
+                }
+                return name;
+            },
+            _attributeName(previous, options, details) {
+                const { codec, attributeName } = details;
+                const attribute = codec.attributes[attributeName];
+                const baseName = attribute.extensions?.tags?.name || attributeName;
+                const name = previous(details);
+                if (baseName === "id" && name === "row_id" && !codec.isAnonymous) {
+                    return "id";
+                }
+                return name;
+            },
+        },
+    },
+};

package/dist/src/plugins/validate-fields.d.ts

@@ -0,0 +1 @@
+export declare const ValidateCasinoFieldsPlugin: GraphileConfig.Plugin;

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

@@ -0,0 +1,61 @@
+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";
+function validate(value, schema) {
+    try {
+        schema.validateSync(value, { strict: true, abortEarly: true });
+    }
+    catch (e) {
+        if (e instanceof Yup.ValidationError) {
+            const errorMessage = e.path ? `${e.path}: ${e.errors[0]}` : e.errors[0];
+            throw new GraphQLError(errorMessage);
+        }
+        else {
+            throw e;
+        }
+    }
+}
+const casinoPatchSchema = Yup.object()
+    .shape({
+    name: Yup.string().trim().min(1),
+    graphqlUrl: v.graphqlUrl(),
+    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({
+    Mutation: {
+        updateHubCasinoById: (plan, $source, fieldArgs) => {
+            const $patch = fieldArgs.getRaw(["input", "hubCasinoPatch"]);
+            sideEffect($patch, (patch) => validate(patch, casinoPatchSchema));
+            return plan();
+        },
+        hubAddCasino: (plan, $source, fieldArgs) => {
+            const $input = fieldArgs.getRaw(["input"]);
+            sideEffect($input, (input) => validate(input, addCasinoSchema));
+            return plan();
+        },
+        updateHubBankrollById: (plan, $source, fieldArgs) => {
+            const $patch = fieldArgs.getRaw(["input", "hubBankrollPatch"]);
+            sideEffect($patch, (patch) => validate(patch, updateBankrollSchema));
+            return plan();
+        },
+    },
+});

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

@@ -0,0 +1,7 @@
+import * as db from "./db/index.js";
+export declare function casinoIdsInProcess(): string[];
+export declare function startTransferProcessor({ casinoId, }: {
+    casinoId: db.DbCasino["id"];
+}): void;
+export declare function stopTransferProcessor(casinoId: string): void;
+export declare function initializeTransferProcessors(): void;