@moneypot/hub 1.15.0-dev.3 → 1.16.0-dev.3

package/dist/src/plugins/chat/hub-chat-create-user-message.js

@@ -0,0 +1,231 @@
+import { GraphQLError } from "graphql";
+import { access, context, object, ObjectStep, sideEffect, } from "postgraphile/grafast";
+import { extendSchema, gql } from "postgraphile/utils";
+import z from "zod/v4";
+import { exactlyOneRow, maybeOneRow } from "../../db/util.js";
+import { extractFirstZodErrorMessage } from "../../util.js";
+import { withPgPoolTransaction } from "../../db/index.js";
+import { PgAdvisoryLock } from "../../pg-advisory-lock.js";
+const InputSchema = z.object({
+    clientId: z.uuid("Invalid client ID"),
+    body: z
+        .string()
+        .transform(normalizeUserMessageBody)
+        .refine((body) => body.length > 0, "Body is required")
+        .refine((body) => body.length <= 140, `Max body length: 140 chars`),
+});
+const RATE_LIMITS = [
+    {
+        seconds: 10,
+        cap: 3,
+    },
+    { seconds: 60, cap: 20 },
+];
+const RL_WINDOWS = RATE_LIMITS.map((r) => r.seconds);
+const RL_CAPS = RATE_LIMITS.map((r) => r.cap);
+export const HubChatCreateUserMessagePlugin = extendSchema((build) => {
+    const chatMessageTable = build.input.pgRegistry.pgResources.hub_chat_message;
+    return {
+        typeDefs: gql `
+      input HubChatCreateUserMessageInput {
+        clientId: UUID!
+        body: String!
+      }
+
+      type HubChatCreateUserMessageSuccess {
+        chatMessage: HubChatMessage!
+      }
+
+      type HubChatUserRateLimited {
+        message: String
+      }
+
+      type HubChatUserMuted {
+        message: String
+      }
+
+      union HubChatCreateUserMessageResult =
+          HubChatCreateUserMessageSuccess
+        | HubChatUserRateLimited
+        | HubChatUserMuted
+
+      type HubChatCreateUserMessagePayload {
+        result: HubChatCreateUserMessageResult!
+      }
+
+      extend type Mutation {
+        hubChatCreateUserMessage(
+          input: HubChatCreateUserMessageInput!
+        ): HubChatCreateUserMessagePayload
+      }
+    `,
+        objects: {
+            Mutation: {
+                plans: {
+                    hubChatCreateUserMessage(_, { $input }) {
+                        const $identity = context().get("identity");
+                        const $superuserPool = context().get("superuserPool");
+                        const $payload = sideEffect([$input, $identity, $superuserPool], async ([rawInput, identity, superuserPool]) => {
+                            if (identity?.kind !== "user") {
+                                throw new GraphQLError("Unauthorized");
+                            }
+                            let input;
+                            try {
+                                input = InputSchema.parse(rawInput);
+                            }
+                            catch (e) {
+                                if (e instanceof z.ZodError) {
+                                    throw new GraphQLError(extractFirstZodErrorMessage(e));
+                                }
+                                throw e;
+                            }
+                            return await withPgPoolTransaction(superuserPool, async (pgClient) => {
+                                await PgAdvisoryLock.forChatUserAction(pgClient, {
+                                    userId: identity.session.user_id,
+                                    experienceId: identity.session.experience_id,
+                                    casinoId: identity.session.casino_id,
+                                });
+                                const dbMute = await pgClient
+                                    .query({
+                                    text: `
+                  SELECT id 
+                  FROM hub.active_chat_mute
+                  WHERE casino_id = $1
+                    AND experience_id = $2
+                    AND user_id = $3
+                  `,
+                                    values: [
+                                        identity.session.casino_id,
+                                        identity.session.experience_id,
+                                        identity.session.user_id,
+                                    ],
+                                })
+                                    .then(maybeOneRow);
+                                if (dbMute) {
+                                    return {
+                                        __typename: "HubChatUserMuted",
+                                        message: "You are muted",
+                                    };
+                                }
+                                const dbChatMessage = await pgClient
+                                    .query({
+                                    text: `
+                    with ins as (
+                      insert into hub.chat_message (casino_id, experience_id, user_id, client_id, body, type)
+                      values ($1, $2, $3, $4, $5, 'user')
+                      on conflict (casino_id, experience_id, user_id, client_id) where type = 'user'
+                      do nothing
+                      returning id
+                    )
+                    select id from ins
+                    union all
+                    select id
+                    from hub.chat_message
+                    where casino_id = $1 and experience_id = $2 and user_id = $3 and client_id = $4
+                    limit 1
+                  `,
+                                    values: [
+                                        identity.session.casino_id,
+                                        identity.session.experience_id,
+                                        identity.session.user_id,
+                                        input.clientId,
+                                        input.body,
+                                    ],
+                                })
+                                    .then(exactlyOneRow);
+                                const dbRateLimit = await pgClient
+                                    .query({
+                                    text: `
+                      with wins as (
+                        select *
+                        from unnest($4::int[], $5::int[]) as t(window_seconds, cap)
+                      ),
+                      bumped as (
+                        insert into hub.chat_rate_bucket
+                          (casino_id, experience_id, user_id, window_seconds, bucket_start, count)
+                        select
+                          $1, $2, $3,
+                          w.window_seconds,
+                          to_timestamp(floor(extract(epoch from now())/w.window_seconds)*w.window_seconds),
+                          1
+                        from wins w
+                        on conflict (casino_id, experience_id, user_id, window_seconds, bucket_start)
+                        do update set count = hub.chat_rate_bucket.count + 1
+                        returning window_seconds, count
+                      )
+                      select bool_or(b.count > w.cap) as exceeded
+                      from bumped b
+                      join wins w using (window_seconds)
+                    `,
+                                    values: [
+                                        identity.session.casino_id,
+                                        identity.session.experience_id,
+                                        identity.session.user_id,
+                                        RL_WINDOWS,
+                                        RL_CAPS,
+                                    ],
+                                })
+                                    .then(maybeOneRow);
+                                if (dbRateLimit?.exceeded) {
+                                    return {
+                                        __typename: "HubChatUserRateLimited",
+                                        message: "Rate limit exceeded",
+                                    };
+                                }
+                                const notifyPayload = {
+                                    type: "message",
+                                    chat_message_id: dbChatMessage.id,
+                                };
+                                await pgClient.query({
+                                    text: `
+                  select pg_notify('hub:chat:${identity.session.experience_id}', $1::text)
+                  `,
+                                    values: [JSON.stringify(notifyPayload)],
+                                });
+                                return {
+                                    __typename: "HubChatCreateUserMessageSuccess",
+                                    chatMessageId: dbChatMessage.id,
+                                };
+                            });
+                        });
+                        return object({
+                            result: $payload,
+                        });
+                    },
+                },
+            },
+            HubChatUserMuted: {
+                assertStep: ObjectStep,
+            },
+            HubChatUserRateLimited: {
+                assertStep: ObjectStep,
+            },
+            HubChatCreateUserMessageSuccess: {
+                assertStep: ObjectStep,
+                plans: {
+                    chatMessage($data) {
+                        const $id = access($data, "chatMessageId");
+                        return chatMessageTable.get({ id: $id });
+                    },
+                },
+            },
+            HubChatCreateUserMessagePayload: {
+                assertStep: ObjectStep,
+                plans: {
+                    result($data) {
+                        const $result = $data.get("result");
+                        return $result;
+                    },
+                },
+            },
+        },
+    };
+});
+function normalizeUserMessageBody(body) {
+    return (body
+        .normalize("NFC")
+        .replace(/(\p{M}{1,2})\p{M}+/gu, "$1")
+        .replace(/[\u200B-\u200D\uFEFF]/g, "")
+        .replace(/\s+/g, " ")
+        .trim());
+}

package/dist/src/plugins/chat/hub-chat-mute-user.d.ts

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

package/dist/src/plugins/chat/hub-chat-mute-user.js

@@ -0,0 +1,186 @@
+import { GraphQLError } from "graphql";
+import { context, object, sideEffect } from "postgraphile/grafast";
+import { extendSchema, gql } from "postgraphile/utils";
+import z from "zod/v4";
+import { exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../../db/index.js";
+import { extractFirstZodErrorMessage, uuidEqual } from "../../util.js";
+import { PgAdvisoryLock } from "../../pg-advisory-lock.js";
+const InputSchema = z.object({
+    userId: z.uuid("Invalid user ID"),
+    expiredAt: z.iso
+        .datetime({ offset: true, error: "Invalid expired at" })
+        .optional()
+        .refine((value) => typeof value === "undefined" ||
+        (typeof value === "string" && new Date(value).getTime() > Date.now()), { error: "Expired at must be in the future" })
+        .transform((value) => (value ? new Date(value) : null)),
+    reason: z
+        .string("Invalid reason")
+        .trim()
+        .optional()
+        .refine((value) => typeof value === "undefined" ||
+        (typeof value === "string" && value.length > 0), { error: "Reason must be at least 1 character" })
+        .refine((value) => typeof value === "undefined" ||
+        (typeof value === "string" && value.length <= 140), { error: "Reason must be at most 140 characters" })
+        .transform((value) => (value ? value : null)),
+});
+export const HubChatMuteUserPlugin = extendSchema((build) => {
+    const chatMuteTable = build.input.pgRegistry.pgResources.hub_chat_mute;
+    return {
+        typeDefs: gql `
+      input HubChatMuteUserInput {
+        userId: UUID!
+        expiredAt: Datetime
+        reason: String
+      }
+
+      type HubChatMuteUserPayload {
+        chatMute: HubChatMute!
+      }
+
+      extend type Mutation {
+        hubChatMuteUser(input: HubChatMuteUserInput!): HubChatMuteUserPayload
+      }
+    `,
+        objects: {
+            Mutation: {
+                plans: {
+                    hubChatMuteUser(_, { $input }) {
+                        const $identity = context().get("identity");
+                        const $superuserPool = context().get("superuserPool");
+                        const $muteId = sideEffect([$input, $identity, $superuserPool], async ([rawInput, identity, superuserPool]) => {
+                            if (identity?.kind !== "user") {
+                                throw new GraphQLError("Unauthorized");
+                            }
+                            let input;
+                            try {
+                                input = InputSchema.parse(rawInput);
+                            }
+                            catch (e) {
+                                if (e instanceof z.ZodError) {
+                                    throw new GraphQLError(extractFirstZodErrorMessage(e));
+                                }
+                                throw e;
+                            }
+                            const dbTargetUser = await superuserPool
+                                .query({
+                                text: `
+                  SELECT id
+                  FROM hub.user
+                  WHERE casino_id = $1 AND id = $2
+                  `,
+                                values: [identity.session.casino_id, input.userId],
+                            })
+                                .then(maybeOneRow);
+                            if (!dbTargetUser) {
+                                throw new GraphQLError("User not found");
+                            }
+                            const dbCurrentUserChatMod = await superuserPool
+                                .query({
+                                text: `
+                  SELECT id, user_id
+                  FROM hub.chat_mod
+                  WHERE casino_id = $1 AND experience_id = $2 AND user_id = $3
+                  `,
+                                values: [
+                                    identity.session.casino_id,
+                                    identity.session.experience_id,
+                                    identity.session.user_id,
+                                ],
+                            })
+                                .then(maybeOneRow);
+                            if (!dbCurrentUserChatMod &&
+                                !identity.session.is_experience_owner) {
+                                throw new GraphQLError("Unauthorized");
+                            }
+                            const dbExperience = await superuserPool
+                                .query({
+                                text: `
+                  SELECT id, user_id
+                  FROM hub.experience
+                  WHERE id = $1 AND casino_id = $2
+                  `,
+                                values: [
+                                    identity.session.experience_id,
+                                    identity.session.casino_id,
+                                ],
+                            })
+                                .then(exactlyOneRow);
+                            const targetIsChatMod = await superuserPool
+                                .query({
+                                text: `
+                      select 1
+                      from hub.chat_mod
+                      where casino_id = $1 and experience_id = $2 and user_id = $3
+                    `,
+                                values: [
+                                    identity.session.casino_id,
+                                    identity.session.experience_id,
+                                    dbTargetUser.id,
+                                ],
+                            })
+                                .then(maybeOneRow);
+                            const targetIsExperienceOwner = dbExperience.user_id &&
+                                uuidEqual(dbExperience.user_id, dbTargetUser.id);
+                            if (targetIsExperienceOwner || targetIsChatMod) {
+                                throw new GraphQLError("Cannot mute staff");
+                            }
+                            if (uuidEqual(identity.session.user_id, dbTargetUser.id)) {
+                                throw new GraphQLError("Cannot mute yourself");
+                            }
+                            const muteId = await withPgPoolTransaction(superuserPool, async (pgClient) => {
+                                await PgAdvisoryLock.forChatUserAction(pgClient, {
+                                    userId: dbTargetUser.id,
+                                    experienceId: identity.session.experience_id,
+                                    casinoId: identity.session.casino_id,
+                                });
+                                await pgClient.query(`
+                  UPDATE hub.chat_mute
+                  SET revoked_at = now()
+                  WHERE user_id = $1
+                    AND experience_id = $2
+                    AND casino_id = $3
+                    AND revoked_at IS NULL
+                  `, [
+                                    dbTargetUser.id,
+                                    identity.session.experience_id,
+                                    identity.session.casino_id,
+                                ]);
+                                const dbMute = await pgClient
+                                    .query({
+                                    text: `
+                  INSERT INTO hub.chat_mute (casino_id, experience_id, user_id, reason, expired_at)
+                  VALUES ($1, $2, $3, $4, $5)
+                  RETURNING id
+                  `,
+                                    values: [
+                                        identity.session.casino_id,
+                                        identity.session.experience_id,
+                                        dbTargetUser.id,
+                                        input.reason,
+                                        input.expiredAt,
+                                    ],
+                                })
+                                    .then(exactlyOneRow);
+                                const notifyPayload = {
+                                    type: "mute",
+                                    user_id: dbTargetUser.id,
+                                };
+                                await pgClient.query({
+                                    text: `
+                  SELECT pg_notify('hub:chat:${identity.session.experience_id}', $1::text)
+                  `,
+                                    values: [JSON.stringify(notifyPayload)],
+                                });
+                                return dbMute.id;
+                            });
+                            return muteId;
+                        });
+                        return object({
+                            chatMute: chatMuteTable.get({ id: $muteId }),
+                        });
+                    },
+                },
+            },
+        },
+    };
+});

package/dist/src/plugins/chat/hub-chat-subscription.d.ts

@@ -0,0 +1,14 @@
+import z from "zod/v4";
+declare const ChatPgNotifyPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"message">;
+    chat_message_id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"mute">;
+    user_id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"unmute">;
+    user_id: z.ZodString;
+}, z.core.$strip>]>;
+export type ChatPgNotifyPayload = z.infer<typeof ChatPgNotifyPayloadSchema>;
+export declare const HubChatSubscriptionPlugin: GraphileConfig.Plugin;
+export {};

package/dist/src/plugins/chat/hub-chat-subscription.js

@@ -0,0 +1,133 @@
+import { access, context, lambda, ObjectStep } from "postgraphile/grafast";
+import { extendSchema, gql } from "postgraphile/utils";
+import { jsonParse } from "postgraphile/@dataplan/json";
+import { listenWithFilter } from "../listen-with-filter.js";
+import { logger } from "../../logger.js";
+import z, { prettifyError } from "zod/v4";
+const ChatPgNotifyPayloadSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("message"),
+        chat_message_id: z.string(),
+    }),
+    z.object({
+        type: z.literal("mute"),
+        user_id: z.string(),
+    }),
+    z.object({
+        type: z.literal("unmute"),
+        user_id: z.string(),
+    }),
+]);
+export const HubChatSubscriptionPlugin = extendSchema((build) => {
+    const chatMessageTable = build.input.pgRegistry.pgResources.hub_chat_message;
+    return {
+        typeDefs: gql `
+      type HubChatSubscriptionNewMessage {
+        chatMessage: HubChatMessage!
+      }
+
+      type HubChatSubscriptionMuted {
+        _: Boolean
+      }
+
+      type HubChatSubscriptionUnmuted {
+        _: Boolean
+      }
+
+      union HubChatSubscriptionPayload =
+          HubChatSubscriptionNewMessage
+        | HubChatSubscriptionMuted
+        | HubChatSubscriptionUnmuted
+
+      extend type Subscription {
+        hubChatAlert: HubChatSubscriptionPayload
+      }
+    `,
+        objects: {
+            HubChatSubscriptionMuted: {
+                assertStep: ObjectStep,
+            },
+            HubChatSubscriptionUnmuted: {
+                assertStep: ObjectStep,
+            },
+            HubChatSubscriptionNewMessage: {
+                assertStep: ObjectStep,
+                plans: {
+                    chatMessage($data) {
+                        const $id = access($data, "chatMessageId");
+                        return chatMessageTable.get({ id: $id });
+                    },
+                },
+            },
+            Subscription: {
+                plans: {
+                    hubChatAlert: {
+                        subscribePlan(_$root) {
+                            const $pgSubscriber = context().get("pgSubscriber");
+                            const $identity = context().get("identity");
+                            const $channelKey = lambda($identity, (identity) => {
+                                if (identity?.kind !== "user") {
+                                    return "";
+                                }
+                                return `hub:chat:${identity.session.experience_id}`;
+                            });
+                            return listenWithFilter($pgSubscriber, $channelKey, jsonParse, $identity, (item, identity) => {
+                                if (identity?.kind !== "user") {
+                                    return false;
+                                }
+                                if (typeof item !== "string") {
+                                    logger.warn(item, `hubChatAlert: item is not a string`);
+                                    return false;
+                                }
+                                const payload = JSON.parse(item);
+                                switch (payload.type) {
+                                    case "message":
+                                        break;
+                                    case "mute":
+                                    case "unmute":
+                                        return payload.user_id === identity.session.user_id;
+                                }
+                                return true;
+                            });
+                        },
+                        plan($event) {
+                            return lambda($event, (event) => {
+                                let payload;
+                                try {
+                                    payload = ChatPgNotifyPayloadSchema.parse(event);
+                                }
+                                catch (e) {
+                                    if (e instanceof z.ZodError) {
+                                        throw new Error(`Unexpected payload shape: ${prettifyError(e)}`);
+                                    }
+                                    throw e;
+                                }
+                                switch (payload.type) {
+                                    case "message":
+                                        return {
+                                            __typename: "HubChatSubscriptionNewMessage",
+                                            chatMessageId: payload.chat_message_id,
+                                        };
+                                    case "mute":
+                                        return {
+                                            __typename: "HubChatSubscriptionMuted",
+                                            _: true,
+                                        };
+                                    case "unmute":
+                                        return {
+                                            __typename: "HubChatSubscriptionUnmuted",
+                                            _: true,
+                                        };
+                                    default: {
+                                        const _exhaustiveCheck = payload;
+                                        throw new Error(`Unexpected payload type: ${_exhaustiveCheck}`);
+                                    }
+                                }
+                            });
+                        },
+                    },
+                },
+            },
+        },
+    };
+});

package/dist/src/plugins/chat/hub-chat-unmute-user.d.ts

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