@moneypot/hub 0.0.1

package/dist/src/plugins/caas-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 CaasAddCasinoPlugin = makeExtendSchemaPlugin((build) => {
+    const casinoTable = build.input.pgRegistry.pgResources.caas_casino;
+    return {
+        typeDefs: gql `
+      input CaasAddCasinoInput {
+        name: String!
+        baseUrl: String!
+        graphqlUrl: String!
+        apiKey: String!
+      }
+
+      type CaasAddCasinoPayload {
+        casino: CaasCasino
+        query: Query
+      }
+
+      extend type Mutation {
+        caasAddCasino(input: CaasAddCasinoInput!): CaasAddCasinoPayload
+      }
+    `,
+        plans: {
+            Mutation: {
+                caasAddCasino(_, { $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(`[caasAddCasino] 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 caas.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 caas.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 caas.bankroll (casino_id, currency_key)
+                    SELECT casino_id, key
+                    FROM caas.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/caas-authenticate.d.ts

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

package/dist/src/plugins/caas-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 CaasAuthenticatePlugin = makeExtendSchemaPlugin(() => {
+    return {
+        typeDefs: gql `
+      input CaasAuthenticateInput {
+        casinoBaseUrl: String!
+        userToken: String!
+      }
+
+      type CaasAuthenticateSuccess {
+        experienceId: UUID!
+        sessionKey: UUID!
+        userId: UUID!
+        uname: String!
+      }
+
+      type CaasAuthenticatePayload {
+        query: Query
+        success: CaasAuthenticateSuccess
+      }
+
+      extend type Mutation {
+        caasAuthenticate(input: CaasAuthenticateInput!): CaasAuthenticatePayload
+      }
+    `,
+        plans: {
+            Mutation: {
+                caasAuthenticate(_, { $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 caas.casino c
+                      LEFT JOIN caas.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(`[caasAuthenticate] 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 caas.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 caas.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 caas.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/caas-balance-alert.d.ts

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

package/dist/src/plugins/caas-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 CaasBalanceAlertPlugin = makeExtendSchemaPlugin(() => {
+    return {
+        typeDefs: gql `
+      extend type Subscription {
+        caasBalanceAlert: CaasBalanceAlertPayload
+      }
+
+      type CaasBalanceAlertPayload {
+        currencyKey: String
+      }
+    `,
+        plans: {
+            Subscription: {
+                caasBalanceAlert: {
+                    subscribePlan(_$root) {
+                        const $pgSubscriber = context().get("pgSubscriber");
+                        const $identity = context().get("identity");
+                        const $channelKey = lambda($identity, (identity) => {
+                            if (identity?.kind === "user") {
+                                return `caas:user:${identity.session.user_id}:balance_alert`;
+                            }
+                            else {
+                                return "";
+                            }
+                        });
+                        return listen($pgSubscriber, $channelKey, jsonParse);
+                    },
+                    plan($event) {
+                        return $event;
+                    },
+                },
+            },
+            CaasBalanceAlertPayload: {
+                currencyKey($event) {
+                    return $event.get("currency_key");
+                },
+            },
+        },
+    };
+});

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

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

package/dist/src/plugins/caas-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 CaasClaimFaucetPlugin = makeExtendSchemaPlugin(() => {
+    return {
+        typeDefs: gql `
+      type CaasClaimFaucetPayload {
+        success: Boolean!
+        query: Query
+      }
+
+      extend type Mutation {
+        caasClaimFaucet: CaasClaimFaucetPayload
+      }
+    `,
+        plans: {
+            Mutation: {
+                caasClaimFaucet() {
+                    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 caas.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 caas.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,
+                    });
+                },
+            },
+            CaasClaimFaucetPayload: {
+                success($data) {
+                    return $data.get("result");
+                },
+                query() {
+                    return constant(true);
+                },
+            },
+        },
+    };
+});
+async function upsertPlayCurrency(pgClient, casinoId) {
+    return pgClient.query({
+        text: `
+      insert into caas.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/caas-current-x.d.ts

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

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

@@ -0,0 +1,62 @@
+import { gql, makeExtendSchemaPlugin } from "graphile-utils";
+import { context, inhibitOnNull, lambda } from "postgraphile/grafast";
+export const CaasCurrentXPlugin = makeExtendSchemaPlugin((build) => {
+    const userTable = build.input.pgRegistry.pgResources.caas_user;
+    const casinoTable = build.input.pgRegistry.pgResources.caas_casino;
+    const experienceTable = build.input.pgRegistry.pgResources.caas_experience;
+    const sessionTable = build.input.pgRegistry.pgResources.caas_session;
+    return {
+        typeDefs: gql `
+      extend type Query {
+        caasCurrentUser: CaasUser
+        caasCurrentCasino: CaasCasino
+        caasCurrentExperience: CaasExperience
+        caasCurrentSession: CaasSession
+      }
+    `,
+        plans: {
+            Query: {
+                caasCurrentUser() {
+                    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) });
+                },
+                caasCurrentCasino() {
+                    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) });
+                },
+                caasCurrentExperience() {
+                    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) });
+                },
+                caasCurrentSession() {
+                    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/caas-schema-prefix.d.ts

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

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

@@ -0,0 +1,25 @@
+export const CaasPrefixPlugin = {
+    name: "CaasPrefixPlugin",
+    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 === "caas" ||
+                    pgNamespace.nspname.startsWith("caas_")) {
+                    schemaPrefix = `${pgNamespace.nspname}_`;
+                }
+                else if (pgNamespace.nspname === pgService?.schemas?.[0]) {
+                    schemaPrefix = "";
+                }
+                else {
+                    schemaPrefix = `${pgNamespace.nspname}_`;
+                }
+                return `${databasePrefix}${schemaPrefix}`;
+            },
+        },
+    },
+};

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

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

package/dist/src/plugins/caas-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 CaasUserBalanceByCurrencyPlugin = makeExtendSchemaPlugin((build) => {
+    const balances = build.input.pgRegistry.pgResources.caas_balance;
+    return {
+        typeDefs: gql `
+        extend type CaasUser {
+          balanceByCurrency(currency: String!): CaasBalance
+        }
+      `,
+        plans: {
+            CaasUser: {
+                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 caas.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/caas-withdraw.d.ts

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