@moneypot/hub 0.0.1

package/dist/src/plugins/caas-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 CaasWithdrawPlugin = makeExtendSchemaPlugin((build) => {
+    const caasWithdrawalRequests = build.input.pgRegistry.pgResources.caas_withdrawal_request;
+    return {
+        typeDefs: gql `
+      input CaasWithdrawInput {
+        amount: Int!
+        currency: String!
+      }
+
+      type CaasWithdrawPayload {
+        withdrawalRequest: CaasWithdrawalRequest!
+        query: Query
+      }
+
+      extend type Mutation {
+        caasWithdraw(input: CaasWithdrawInput!): CaasWithdrawPayload
+      }
+    `,
+        plans: {
+            Mutation: {
+                caasWithdraw(_, { $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 caas.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 caas.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 caas.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 caas.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),
+                    });
+                },
+            },
+            CaasWithdrawPayload: {
+                withdrawalRequest($data) {
+                    const $id = $data.get("withdrawalRequestId");
+                    return caasWithdrawalRequests.get({ id: $id });
+                },
+            },
+        },
+    };
+});

package/dist/src/plugins/debug.d.ts

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

package/dist/src/plugins/debug.js

@@ -0,0 +1,14 @@
+import { logger } from "../logger.js";
+export const DebugPlugin = {
+    name: "DebugPlugin",
+    description: "A place to artificially slow down the server to test client",
+    version: "0.0.1",
+    grafserv: {
+        hooks: {
+            processGraphQLRequestBody(info, event) {
+                const { body } = event;
+                logger.debug("GraphQL request:", body.operationName, body.variableValues);
+            },
+        },
+    },
+};

package/dist/src/plugins/hub-add-casino.d.ts

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

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

@@ -0,0 +1,150 @@
+import { constant, context, object, sideEffect } from "postgraphile/grafast";
+import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+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 { logger } from "../logger.js";
+import { assert, is } from "tsafe";
+import * as jwtService from "../services/jwt-service.js";
+import { startTransferProcessor } from "../process-transfers.js";
+const GET_CURRENT_CONTROLLER = generatedGql(`
+  query GetCurrentController {
+    currentController {
+      id
+    }
+    allCurrencies {
+      nodes {
+        id
+        displayUnitName
+        displayUnitScale
+      }
+    }
+  }
+`);
+export const HubAddCasinoPlugin = makeExtendSchemaPlugin((build) => {
+    const casinoTable = build.input.pgRegistry.pgResources.hub_casino;
+    return {
+        typeDefs: gql `
+      input HubAddCasinoInput {
+        name: String!
+        baseUrl: String!
+        graphqlUrl: String!
+        apiKey: String!
+      }
+
+      type HubAddCasinoPayload {
+        casino: HubCasino
+        query: Query
+      }
+
+      extend type Mutation {
+        hubAddCasino(input: HubAddCasinoInput!): HubAddCasinoPayload
+      }
+    `,
+        plans: {
+            Mutation: {
+                hubAddCasino(_, { $input }) {
+                    const $identity = context().get("identity");
+                    const $casinoId = sideEffect([$input, $identity], ([input, identity]) => {
+                        return withPgPoolTransaction(superuserPool, async (pgClient) => {
+                            if (identity?.kind !== "operator") {
+                                throw new GraphQLError("Unauthorized");
+                            }
+                            assert(is(input));
+                            const { name, baseUrl, graphqlUrl, apiKey } = input;
+                            const graphqlClient = new GraphQLClient(graphqlUrl, {
+                                headers: {
+                                    Authorization: `apikey:${apiKey}`,
+                                },
+                            });
+                            console.log(`[hubAddCasino] Making request to ${graphqlUrl}`);
+                            const result = await graphqlClient
+                                .request(GET_CURRENT_CONTROLLER)
+                                .catch((e) => {
+                                if (e.cause?.code === "ECONNREFUSED" ||
+                                    e.cause?.code === "ENOTFOUND") {
+                                    throw new GraphQLError(`Cannot connect to graphqlUrl`);
+                                }
+                                throw e;
+                            });
+                            if (!result) {
+                                throw new GraphQLError("Invalid API key");
+                            }
+                            if (!result.currentController) {
+                                throw new GraphQLError("Invalid API key");
+                            }
+                            let casino;
+                            try {
+                                casino = await pgClient
+                                    .query({
+                                    text: `
+                    INSERT INTO hub.casino(name, base_url, graphql_url)
+                    VALUES($1, $2, $3)
+                    returning id
+                  `,
+                                    values: [name, baseUrl, graphqlUrl],
+                                })
+                                    .then((res) => {
+                                    console.log("res", res.rows);
+                                    return res;
+                                })
+                                    .then(exactlyOneRow);
+                            }
+                            catch (e) {
+                                if (e instanceof Error &&
+                                    "code" in e &&
+                                    e.code === "23505" &&
+                                    "constraint" in e) {
+                                    switch (e.constraint) {
+                                        case "casino_graphql_url_idx":
+                                            throw new GraphQLError("Casino with that graphqlUrl already exists");
+                                        case "casino_base_url_idx":
+                                            throw new GraphQLError("Casino with that baseUrl already exists");
+                                        default:
+                                            throw new GraphQLError(`Duplicate constraint violation: ${e.constraint}`);
+                                    }
+                                }
+                                logger.error("Error adding casino", e);
+                                throw e;
+                            }
+                            await pgClient.query({
+                                text: `
+                    INSERT INTO hub.casino_secret(id, controller_id, api_key)
+                    VALUES($1, $2, $3)
+                  `,
+                                values: [casino.id, result.currentController.id, apiKey],
+                            });
+                            const currencies = result.allCurrencies?.nodes.flatMap((x) => x || []) || [];
+                            await upsertCurrencies(pgClient, {
+                                casinoId: casino.id,
+                                currencies,
+                            });
+                            await pgClient.query({
+                                text: `
+                    INSERT INTO hub.bankroll (casino_id, currency_key)
+                    SELECT casino_id, key
+                    FROM hub.currency 
+                    WHERE casino_id = $1
+                  `,
+                                values: [casino.id],
+                            });
+                            logger.info(`Fetching JWKS for new casino from ${graphqlUrl}...`);
+                            await jwtService.refreshCasinoJwksTask(pgClient, {
+                                graphqlClient,
+                                casinoId: casino.id,
+                            });
+                            startTransferProcessor({ casinoId: casino.id });
+                            return casino.id;
+                        });
+                    });
+                    return object({
+                        casino: casinoTable.get({ id: $casinoId }),
+                        query: constant(true),
+                    });
+                },
+            },
+        },
+    };
+});

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

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

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

@@ -0,0 +1,175 @@
+import { GraphQLError } from "graphql";
+import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+import { assert, is } 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 { superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { logger } from "../logger.js";
+import * as jwtService from "../services/jwt-service.js";
+import { extractGraphQLErrorInfo, isGraphQLError } from "../GraphQLError.js";
+export const HubAuthenticatePlugin = makeExtendSchemaPlugin(() => {
+    return {
+        typeDefs: gql `
+      input HubAuthenticateInput {
+        casinoBaseUrl: String!
+        userToken: String!
+      }
+
+      type HubAuthenticateSuccess {
+        experienceId: UUID!
+        sessionKey: UUID!
+        userId: UUID!
+        uname: String!
+      }
+
+      type HubAuthenticatePayload {
+        query: Query
+        success: HubAuthenticateSuccess
+      }
+
+      extend type Mutation {
+        hubAuthenticate(input: HubAuthenticateInput!): HubAuthenticatePayload
+      }
+    `,
+        plans: {
+            Mutation: {
+                hubAuthenticate(_, { $input }) {
+                    try {
+                        const $context = context();
+                        const $success = sideEffect([$input, $context], ([input, context]) => {
+                            return withPgPoolTransaction(superuserPool, async (pgClient) => {
+                                assert(is(input));
+                                const { userToken: jwt, casinoBaseUrl } = input;
+                                const casino = await pgClient
+                                    .query({
+                                    text: `
+                      SELECT c.*, s.api_key
+                      FROM hub.casino c
+                      LEFT JOIN hub.casino_secret s ON c.id = s.id
+                      WHERE c.base_url = $1`,
+                                    values: [casinoBaseUrl],
+                                })
+                                    .then(maybeOneRow);
+                                if (!casino) {
+                                    throw new GraphQLError(`CAAS is unaware of casino with a base url of provided casinoBaseUrl`);
+                                }
+                                if (!casino.api_key) {
+                                    throw new GraphQLError("Casino secret not configured");
+                                }
+                                const graphqlClient = createGraphqlClient({
+                                    graphqlUrl: casino.graphql_url,
+                                    apiKey: casino.api_key,
+                                });
+                                const verifyResult = await jwtService.verifyJwtFromDbCacheAndEnsureNotAlreadyUsed(pgClient, {
+                                    casinoId: casino.id,
+                                    jwt,
+                                });
+                                if (!verifyResult.ok) {
+                                    throw new GraphQLError(`Error verifying userToken: ${verifyResult.error}`);
+                                }
+                                const { userToken } = verifyResult.value;
+                                let res;
+                                try {
+                                    res = await graphqlClient.request(GET_USER_FROM_USER_TOKEN, {
+                                        token: userToken,
+                                    });
+                                }
+                                catch (e) {
+                                    logger.error(`[hubAuthenticate] Error when making GET_USER_FROM_USER_TOKEN to casino:`, e);
+                                    if (isGraphQLError(e)) {
+                                        const errorInfo = extractGraphQLErrorInfo(e);
+                                        if (errorInfo.code === "UNAUTHENTICATED") {
+                                            throw new GraphQLError("Invalid api key");
+                                        }
+                                        else {
+                                            throw new GraphQLError(errorInfo.message);
+                                        }
+                                    }
+                                    throw error;
+                                }
+                                const result = res.userFromUserToken;
+                                if (!result || !result.user || !result.experience) {
+                                    return null;
+                                }
+                                const mpUserId = result.user.id;
+                                assert(mpUserId);
+                                const uname = result.user.uname;
+                                assert(uname);
+                                const dbUser = 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, uname
+                `,
+                                    values: [casino.id, mpUserId, uname],
+                                })
+                                    .then(exactlyOneRow);
+                                const userId = dbUser.id;
+                                const mpExperience = result.experience;
+                                assert(mpExperience);
+                                const dbExperience = await pgClient
+                                    .query({
+                                    text: `
+                INSERT INTO hub.experience(casino_id, mp_experience_id, name)
+                VALUES($1, $2, $3)
+                ON CONFLICT (casino_id, mp_experience_id) DO UPDATE
+                  SET name = EXCLUDED.name
+                RETURNING id
+              `,
+                                    values: [casino.id, mpExperience.id, mpExperience.name],
+                                })
+                                    .then(exactlyOneRow);
+                                const dbSession = await pgClient
+                                    .query({
+                                    text: `
+                INSERT INTO hub.session(casino_id, user_id, experience_id, user_token)
+                  VALUES($1, $2, $3, $4)
+                RETURNING id, key
+              `,
+                                    values: [casino.id, userId, dbExperience.id, userToken],
+                                })
+                                    .then(exactlyOneRow);
+                                const ret = {
+                                    userId,
+                                    uname: dbUser.uname,
+                                    experienceId: dbExperience.id,
+                                    sessionKey: dbSession.key,
+                                };
+                                context.identity = {
+                                    kind: "user",
+                                    session: {
+                                        user_id: userId,
+                                        mp_user_id: mpUserId,
+                                        casino_id: casino.id,
+                                        experience_id: dbExperience.id,
+                                        session_id: dbSession.id,
+                                    },
+                                };
+                                context.pgSettings = {
+                                    "session.user_id": userId,
+                                    "session.casino_id": casino.id,
+                                    "session.experience_id": dbExperience.id,
+                                    "session.session_id": dbSession.id,
+                                };
+                                return ret;
+                            });
+                        });
+                        return object({
+                            query: constant(true),
+                            success: $success,
+                        });
+                    }
+                    catch (error) {
+                        logger.error(error);
+                        throw error;
+                    }
+                },
+            },
+        },
+    };
+});

package/dist/src/plugins/hub-balance-alert.d.ts

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

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

@@ -0,0 +1,43 @@
+import { makeExtendSchemaPlugin, gql } from "postgraphile/utils";
+import { context, lambda, listen } from "postgraphile/grafast";
+import { jsonParse } from "postgraphile/@dataplan/json";
+export const HubBalanceAlertPlugin = makeExtendSchemaPlugin(() => {
+    return {
+        typeDefs: gql `
+      extend type Subscription {
+        hubBalanceAlert: HubBalanceAlertPayload
+      }
+
+      type HubBalanceAlertPayload {
+        currencyKey: String
+      }
+    `,
+        plans: {
+            Subscription: {
+                hubBalanceAlert: {
+                    subscribePlan(_$root) {
+                        const $pgSubscriber = context().get("pgSubscriber");
+                        const $identity = context().get("identity");
+                        const $channelKey = lambda($identity, (identity) => {
+                            if (identity?.kind === "user") {
+                                return `hub:user:${identity.session.user_id}:balance_alert`;
+                            }
+                            else {
+                                return "";
+                            }
+                        });
+                        return listen($pgSubscriber, $channelKey, jsonParse);
+                    },
+                    plan($event) {
+                        return $event;
+                    },
+                },
+            },
+            HubBalanceAlertPayload: {
+                currencyKey($event) {
+                    return $event.get("currency_key");
+                },
+            },
+        },
+    };
+});

package/dist/src/plugins/hub-claim-faucet.d.ts

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

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

@@ -0,0 +1,85 @@
+import { object } from "grafast";
+import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+import { superuserPool, withPgPoolTransaction } from "../db/index.js";
+import { constant, context, sideEffect } from "postgraphile/grafast";
+const CLAIM_AMOUNT = 1000;
+export const HubClaimFaucetPlugin = makeExtendSchemaPlugin(() => {
+    return {
+        typeDefs: gql `
+      type HubClaimFaucetPayload {
+        success: Boolean!
+        query: Query
+      }
+
+      extend type Mutation {
+        hubClaimFaucet: HubClaimFaucetPayload
+      }
+    `,
+        plans: {
+            Mutation: {
+                hubClaimFaucet() {
+                    const $identity = context().get("identity");
+                    const $result = sideEffect([$identity], ([identity]) => {
+                        if (identity?.kind !== "user") {
+                            throw new Error("Must be logged in as user");
+                        }
+                        const { session } = identity;
+                        return withPgPoolTransaction(superuserPool, async (pgClient) => {
+                            await upsertPlayCurrency(pgClient, session.casino_id);
+                            await pgClient.query({
+                                text: `
+                  insert into hub.faucet_claim (user_id, casino_id, experience_id, currency_key, amount)
+                  values ($1, $2, $3, $4, $5)
+                `,
+                                values: [
+                                    session.user_id,
+                                    session.casino_id,
+                                    session.experience_id,
+                                    "PLAY",
+                                    CLAIM_AMOUNT,
+                                ],
+                            });
+                            await pgClient.query({
+                                text: `
+                  INSERT INTO hub.balance (user_id, experience_id, casino_id, currency_key, amount)
+                  VALUES ($1, $2, $3, $4, $5)
+                  ON CONFLICT (user_id, experience_id, casino_id, currency_key) DO UPDATE
+                  SET amount = balance.amount + EXCLUDED.amount
+               `,
+                                values: [
+                                    session.user_id,
+                                    session.experience_id,
+                                    session.casino_id,
+                                    "PLAY",
+                                    CLAIM_AMOUNT,
+                                ],
+                            });
+                            return true;
+                        });
+                    });
+                    return object({
+                        result: $result,
+                    });
+                },
+            },
+            HubClaimFaucetPayload: {
+                success($data) {
+                    return $data.get("result");
+                },
+                query() {
+                    return constant(true);
+                },
+            },
+        },
+    };
+});
+async function upsertPlayCurrency(pgClient, casinoId) {
+    return pgClient.query({
+        text: `
+      insert into hub.currency (casino_id, key, display_unit_name, display_unit_scale)
+      values ($1, 'PLAY', 'tokens', 1)
+      on conflict (casino_id, key) do nothing
+    `,
+        values: [casinoId],
+    });
+}

package/dist/src/plugins/hub-current-x.d.ts

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