@moneypot/hub 1.15.0 → 1.16.0-dev.4

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

@@ -0,0 +1,146 @@
+import { extendSchema, gql } from "postgraphile/utils";
+import { context, inhibitOnNull, sideEffect } from "../../grafast.js";
+import { GraphQLError } from "graphql";
+import z, { object } from "zod/v4";
+import { extractFirstZodErrorMessage } from "../../util.js";
+import { maybeOneRow, withPgPoolTransaction, } from "../../db/index.js";
+import { PgAdvisoryLock } from "../../pg-advisory-lock.js";
+import { logger } from "../../logger.js";
+const InputSchema = z.object({
+    userId: z.uuid("Invalid user ID"),
+});
+export const HubChatUnmuteUserPlugin = extendSchema((build) => {
+    const chatMuteTable = build.input.pgRegistry.pgResources.hub_chat_mute;
+    return {
+        typeDefs: gql `
+      input HubChatUnmuteUserInput {
+        userId: UUID!
+      }
+
+      type HubChatUnmuteUserPayload {
+        chatMute: HubChatMute!
+      }
+
+      extend type Mutation {
+        hubChatUnmuteUser(
+          input: HubChatUnmuteUserInput!
+        ): HubChatUnmuteUserPayload
+      }
+    `,
+        objects: {
+            Mutation: {
+                plans: {
+                    hubChatUnmuteUser(_, { $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 currentUserIsChatMod = 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 (!identity.session.is_experience_owner &&
+                                !currentUserIsChatMod) {
+                                throw new GraphQLError("Unauthorized");
+                            }
+                            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");
+                            }
+                            return withPgPoolTransaction(superuserPool, async (pgClient) => {
+                                await PgAdvisoryLock.forChatUserAction(pgClient, {
+                                    userId: dbTargetUser.id,
+                                    experienceId: identity.session.experience_id,
+                                    casinoId: identity.session.casino_id,
+                                });
+                                const dbActiveMute = await pgClient
+                                    .query({
+                                    text: `
+                        SELECT id
+                        FROM hub.active_chat_mute
+                        WHERE user_id = $1 AND experience_id = $2 AND casino_id = $3
+                      `,
+                                    values: [
+                                        dbTargetUser.id,
+                                        identity.session.experience_id,
+                                        identity.session.casino_id,
+                                    ],
+                                })
+                                    .then(maybeOneRow);
+                                if (!dbActiveMute) {
+                                    throw new GraphQLError("User is not muted");
+                                }
+                                await pgClient
+                                    .query({
+                                    text: `
+                        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
+                      `,
+                                    values: [
+                                        dbTargetUser.id,
+                                        identity.session.experience_id,
+                                        identity.session.casino_id,
+                                    ],
+                                })
+                                    .then((res) => {
+                                    if (res.rowCount !== 1) {
+                                        logger.warn("Expected 1 chat_mute row to be revoked when unmuting user, got %s", res.rowCount);
+                                    }
+                                });
+                                const notifyPayload = {
+                                    type: "unmute",
+                                    user_id: dbTargetUser.id,
+                                };
+                                await pgClient.query({
+                                    text: `
+                  SELECT pg_notify('hub:chat:${identity.session.experience_id}', $1::text)
+                  `,
+                                    values: [JSON.stringify(notifyPayload)],
+                                });
+                                return dbActiveMute.id;
+                            });
+                        });
+                        return object({
+                            chatMute: chatMuteTable.get({ id: inhibitOnNull($muteId) }),
+                        });
+                    },
+                },
+            },
+        },
+    };
+});

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

@@ -1,5 +1,5 @@
 import { GraphQLError } from "graphql";
-import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+import { extendSchema, gql } from "postgraphile/utils";
 import { assert } from "tsafe";
 import { GET_USER_FROM_USER_TOKEN } from "../graphql-queries.js";
 import { exactlyOneRow, maybeOneRow } from "../db/util.js";
@@ -22,7 +22,7 @@ const InputSchema = z.object({
     casinoBaseUrl: BaseUrlSchema,
     userToken: z.string().min(1, "User token required"),
 });
-export const HubAuthenticatePlugin = makeExtendSchemaPlugin(() => {
+export const HubAuthenticatePlugin = extendSchema(() => {
     return {
         typeDefs: gql `
       input HubAuthenticateInput {
@@ -124,34 +124,52 @@ export const HubAuthenticatePlugin = makeExtendSchemaPlugin(() => {
                                     assert(mpUserId);
                                     const uname = result.user.uname;
                                     assert(uname);
-                                    const dbUser = await pgClient
+                                    const mpExperience = result.experience;
+                                    assert(mpExperience);
+                                    assert(mpExperience.userByUserId, "Expected mpExperience.userByUserId");
+                                    const authUser = 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
-                `,
+                            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 ownerUser = 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
+                          `,
+                                        values: [
+                                            casino.id,
+                                            mpExperience.userByUserId.id,
+                                            mpExperience.userByUserId.uname,
+                                        ],
+                                    })
+                                        .then(exactlyOneRow);
+                                    const userId = authUser.id;
                                     const dbExperience = await pgClient
                                         .query({
                                         text: `
-                INSERT INTO hub.experience(casino_id, mp_experience_id, name)
-                VALUES($1, $2, $3)
+                INSERT INTO hub.experience(casino_id, mp_experience_id, name, user_id)
+                VALUES($1, $2, $3, $4)
                 ON CONFLICT (casino_id, mp_experience_id) DO UPDATE
                   SET name = EXCLUDED.name
-                RETURNING id
+                RETURNING id, user_id
               `,
                                         values: [
                                             casino.id,
                                             mpExperience.id,
                                             mpExperience.name,
+                                            ownerUser.id,
                                         ],
                                     })
                                         .then(exactlyOneRow);
@@ -172,7 +190,7 @@ export const HubAuthenticatePlugin = makeExtendSchemaPlugin(() => {
                                         .then(exactlyOneRow);
                                     const ret = {
                                         userId,
-                                        uname: dbUser.uname,
+                                        uname: authUser.uname,
                                         experienceId: dbExperience.id,
                                         sessionKey: dbSession.key,
                                     };
@@ -185,14 +203,17 @@ export const HubAuthenticatePlugin = makeExtendSchemaPlugin(() => {
                                             experience_id: dbExperience.id,
                                             session_id: dbSession.id,
                                             is_playground: false,
+                                            is_experience_owner: dbExperience.user_id === userId,
                                         },
                                     };
-                                    context.pgSettings = {
+                                    const pgSettings = {
                                         "session.user_id": userId,
                                         "session.casino_id": casino.id,
                                         "session.experience_id": dbExperience.id,
                                         "session.session_id": dbSession.id,
+                                        "session.is_experience_owner": dbExperience.user_id === userId ? "1" : undefined,
                                     };
+                                    context.pgSettings = pgSettings;
                                     return ret;
                                 });
                             });

package/dist/src/plugins/hub-create-playground-session.js

@@ -4,16 +4,18 @@ import { exactlyOneRow, maybeOneRow } from "../db/util.js";
 import { constant, context, object, sideEffect } from "postgraphile/grafast";
 import { withPgPoolTransaction, } from "../db/index.js";
 import { logger } from "../logger.js";
-import { z } from "zod";
+import { z } from "zod/v4";
 import { prettifyError } from "zod/v4";
 const InputSchema = z.object({
-    dummy: z.string().optional(),
+    experienceClientId: z.uuid().optional(),
+    userClientId: z.uuid().optional(),
 });
 export const HubCreatePlaygroundSessionPlugin = extendSchema(() => {
     return {
         typeDefs: gql `
       input HubCreatePlaygroundSessionInput {
-        dummy: String
+        experienceClientId: UUID
+        userClientId: UUID
       }
 
       extend type Mutation {
@@ -31,9 +33,9 @@ export const HubCreatePlaygroundSessionPlugin = extendSchema(() => {
                             const $superuserPool = $context.get("superuserPool");
                             const $success = sideEffect([$input, $superuserPool, $context], ([rawInput, superuserPool, context]) => {
                                 return withPgPoolTransaction(superuserPool, async (pgClient) => {
-                                    let _input;
+                                    let input;
                                     try {
-                                        _input = InputSchema.parse(rawInput);
+                                        input = InputSchema.parse(rawInput);
                                     }
                                     catch (e) {
                                         if (e instanceof z.ZodError) {
@@ -47,6 +49,7 @@ export const HubCreatePlaygroundSessionPlugin = extendSchema(() => {
                             SELECT c.*
                             FROM hub.casino c
                             WHERE c.is_playground = true
+                            ORDER BY c.id ASC
                             LIMIT 1
                           `,
                                         values: [],
@@ -60,28 +63,51 @@ export const HubCreatePlaygroundSessionPlugin = extendSchema(() => {
                                     const dbUser = await pgClient
                                         .query({
                                         text: `
-                          INSERT INTO hub.user(casino_id, mp_user_id, uname)
-                          VALUES($1, $2, $3)
-                          RETURNING id, uname, mp_user_id
+                            with ins as (
+                              insert into hub.user (casino_id, mp_user_id, uname, client_id)
+                              values ($1, $2, $3, $4)
+                              on conflict (casino_id, client_id) where client_id is not null
+                              do nothing
+                              returning id, uname, mp_user_id
+                            )
+                            select id, uname, mp_user_id from ins
+                            union all
+                            select id, uname, mp_user_id
+                            from hub.user
+                            where casino_id = $1 and client_id = $4
+                            limit 1
                           `,
                                         values: [
                                             dbPlaygroundCasino.id,
                                             DUMMY_MP_ID,
                                             randomUname,
+                                            input.userClientId ?? null,
                                         ],
                                     })
                                         .then(exactlyOneRow);
                                     const dbExperience = await pgClient
                                         .query({
                                         text: `
-                          INSERT INTO hub.experience(casino_id, mp_experience_id, name)
-                          VALUES($1, $2, $3)
-                          RETURNING id
+                            with ins as (
+                              insert into hub.experience (casino_id, mp_experience_id, name, client_id, user_id)
+                              values ($1, $2, $3, $4, $5)
+                              on conflict (casino_id, client_id) where client_id is not null
+                              do nothing
+                              returning id, user_id
+                            )
+                            select id, user_id from ins
+                            union all
+                            select id, user_id
+                            from hub.experience
+                            where casino_id = $1 and client_id = $4
+                            limit 1
                           `,
                                         values: [
                                             dbPlaygroundCasino.id,
                                             DUMMY_MP_ID,
                                             `Playground Experience ${randomUname}`,
+                                            input.experienceClientId ?? null,
+                                            dbUser.id,
                                         ],
                                     })
                                         .then(exactlyOneRow);
@@ -89,6 +115,8 @@ export const HubCreatePlaygroundSessionPlugin = extendSchema(() => {
                                         text: `
                         INSERT INTO hub.balance(user_id, experience_id, casino_id, currency_key, amount)
                         VALUES($1, $2, $3, $4, 1000)
+                        ON CONFLICT (user_id, experience_id, casino_id, currency_key) DO UPDATE
+                        SET amount = 1000
                         `,
                                         values: [
                                             dbUser.id,
@@ -101,7 +129,7 @@ export const HubCreatePlaygroundSessionPlugin = extendSchema(() => {
                                         .query({
                                         text: `
                 INSERT INTO hub.session(casino_id, user_id, experience_id, user_token, expired_at)
-                  VALUES($1, $2, $3, $4, now() + interval '1 hour')
+                  VALUES($1, $2, $3, $4, now() + interval '1 week')
                 RETURNING id, key
               `,
                                         values: [
@@ -127,14 +155,17 @@ export const HubCreatePlaygroundSessionPlugin = extendSchema(() => {
                                             experience_id: dbExperience.id,
                                             session_id: dbSession.id,
                                             is_playground: true,
+                                            is_experience_owner: dbExperience.user_id === dbUser.id,
                                         },
                                     };
-                                    context.pgSettings = {
+                                    const pgSettings = {
                                         "session.user_id": dbUser.id,
                                         "session.casino_id": dbPlaygroundCasino.id,
                                         "session.experience_id": dbExperience.id,
                                         "session.session_id": dbSession.id,
+                                        "session.is_experience_owner": dbExperience.user_id === dbUser.id ? "1" : undefined,
                                     };
+                                    context.pgSettings = pgSettings;
                                     return ret;
                                 });
                             });

package/dist/src/plugins/hub-make-outcome-bet.js

@@ -1,8 +1,8 @@
 import { access, context, object, ObjectStep, sideEffect, } from "postgraphile/grafast";
-import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+import { gql, extendSchema } from "postgraphile/utils";
 import * as z from "zod";
 import { GraphQLError } from "graphql";
-import { DbHashKind, dbLockPlayerBalanceAndHouseBankroll, exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
+import { DbHashKind, dbLockHouseBankroll, dbLockPlayerBalance, exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
 import { dbInsertHubHash, dbLockHubHashChain, } from "../hash-chain/db-hash-chain.js";
 import { getIntermediateHash } from "../hash-chain/get-hash.js";
@@ -71,7 +71,7 @@ const BetConfigsSchema = z.record(BetKindSchema, z.object({
 export function MakeOutcomeBetPlugin({ betConfigs }) {
     BetConfigsSchema.parse(betConfigs);
     const betKinds = Object.keys(betConfigs);
-    return makeExtendSchemaPlugin((build) => {
+    return extendSchema((build) => {
         const outcomeBetTable = build.input.pgRegistry.pgResources.hub_outcome_bet;
         const typeDefs = gql `
         enum BetKind {
@@ -171,14 +171,14 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     throw new GraphQLError("Currency not found");
                                 }
                                 return withPgPoolTransaction(superuserPool, async (pgClient) => {
-                                    const { dbPlayerBalance, dbHouseBankroll, found } = await dbLockPlayerBalanceAndHouseBankroll(pgClient, {
+                                    const dbPlayerBalance = await dbLockPlayerBalance(pgClient, {
                                         userId: session.user_id,
                                         casinoId: session.casino_id,
                                         experienceId: session.experience_id,
                                         currencyKey: dbCurrency.key,
                                     });
-                                    if (!found) {
-                                        throw new GraphQLError("No balance entry found for player or house");
+                                    if (!dbPlayerBalance) {
+                                        throw new GraphQLError("No balance entry found for player");
                                     }
                                     const minProfit = Math.min(...input.outcomes.map((o) => o.profit));
                                     const maxPlayerLoss = Math.abs(input.wager * minProfit);
@@ -194,21 +194,6 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         }
                                         throw new GraphQLError("You cannot afford the worst outcome");
                                     }
-                                    const maxProfitMultiplier = Math.max(...input.outcomes.map((o) => o.profit));
-                                    const maxPotentialPayout = input.wager * maxProfitMultiplier;
-                                    const riskResult = validateRisk({
-                                        currency: input.currency,
-                                        wager: input.wager,
-                                        bankroll: dbHouseBankroll.amount,
-                                        maxPotentialPayout,
-                                        riskPolicy: betConfig.riskPolicy,
-                                        displayUnitName: dbCurrency.display_unit_name,
-                                        displayUnitScale: dbCurrency.display_unit_scale,
-                                        outcomes: input.outcomes,
-                                    });
-                                    if (!riskResult.ok) {
-                                        throw new GraphQLError(riskResult.error);
-                                    }
                                     const dbHashChain = await dbLockHubHashChain(pgClient, {
                                         userId: session.user_id,
                                         experienceId: session.experience_id,
@@ -289,26 +274,47 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     const outcome = input.outcomes[outcomeIdx];
                                     const netPlayerAmount = input.wager * outcome.profit;
                                     const houseBankrollDelta = -netPlayerAmount;
-                                    await pgClient.query({
-                                        text: `
-                    UPDATE hub.balance
-                    SET amount = amount + $1
-                    WHERE id = $2
-                  `,
-                                        values: [netPlayerAmount, dbPlayerBalance.id],
+                                    const dbHouseBankroll = await dbLockHouseBankroll(pgClient, {
+                                        casinoId: session.casino_id,
+                                        currencyKey: dbCurrency.key,
                                     });
+                                    if (!dbHouseBankroll) {
+                                        throw new GraphQLError("No house bankroll found");
+                                    }
+                                    const maxProfitMultiplier = Math.max(...input.outcomes.map((o) => o.profit));
+                                    const maxPotentialPayout = input.wager * maxProfitMultiplier;
+                                    const riskResult = validateRisk({
+                                        currency: input.currency,
+                                        wager: input.wager,
+                                        bankroll: dbHouseBankroll.amount,
+                                        maxPotentialPayout,
+                                        riskPolicy: betConfig.riskPolicy,
+                                        displayUnitName: dbCurrency.display_unit_name,
+                                        displayUnitScale: dbCurrency.display_unit_scale,
+                                        outcomes: input.outcomes,
+                                    });
+                                    if (!riskResult.ok) {
+                                        throw new GraphQLError(riskResult.error);
+                                    }
                                     await pgClient.query({
                                         text: `
+                    WITH balance_update AS (
+                      UPDATE hub.balance
+                      SET amount = amount + $1
+                      WHERE id = $2
+                    )
                     UPDATE hub.bankroll
-                    SET amount = amount + $2,
-                        bets = bets + 1,
-                        wagered = wagered + $3
-                    WHERE id = $1
+                    SET amount = amount + $3,
+                        wagered = wagered + $4,
+                        bets = bets + 1
+                    WHERE id = $5
                   `,
                                         values: [
-                                            dbHouseBankroll.id,
+                                            netPlayerAmount,
+                                            dbPlayerBalance.id,
                                             houseBankrollDelta,
                                             input.wager,
+                                            dbHouseBankroll.id,
                                         ],
                                     });
                                     const immutableData = structuredClone({

package/dist/src/server/graphile.config.d.ts

@@ -8,6 +8,7 @@ export type UserSessionContext = {
     experience_id: string;
     session_id: string;
     is_playground: boolean;
+    is_experience_owner: boolean;
 };
 export type PluginIdentity = {
     kind: "user";
@@ -15,12 +16,23 @@ export type PluginIdentity = {
 } | {
     kind: "operator";
 };
+export type OurPgSettings = {
+    "session.user_id": string;
+    "session.experience_id": string;
+    "session.casino_id": string;
+    "session.session_id": string;
+    "session.is_experience_owner": "1" | undefined;
+} | {
+    "operator.api_key": string;
+};
 export declare const requiredPlugins: readonly GraphileConfig.Plugin[];
 export declare const defaultPlugins: readonly GraphileConfig.Plugin[];
-export declare function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, }: {
+export declare function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, enableChat, enablePlayground, }: {
     plugins: readonly GraphileConfig.Plugin[];
     exportSchemaSDLPath?: string;
     extraPgSchemas: string[];
     abortSignal: AbortSignal;
     context: ServerContext;
+    enableChat: boolean;
+    enablePlayground: boolean;
 }): GraphileConfig.Preset;

package/dist/src/server/graphile.config.js

@@ -25,6 +25,13 @@ import { HubOutcomeInputNonNullFieldsPlugin } from "../plugins/hub-outcome-input
 import { HubPutAlertPlugin } from "../plugins/hub-put-alert.js";
 import { HubRevealHashChainPlugin } from "../hash-chain/plugins/hub-reveal-hash-chain.js";
 import { HubPreimageHashFieldPlugin } from "../hash-chain/plugins/hub-preimage-hash-field.js";
+import { HubChatCreateUserMessagePlugin } from "../plugins/chat/hub-chat-create-user-message.js";
+import { HubChatSubscriptionPlugin } from "../plugins/chat/hub-chat-subscription.js";
+import { HubCreatePlaygroundSessionPlugin } from "../plugins/hub-create-playground-session.js";
+import { HubChatUnmuteUserPlugin } from "../plugins/chat/hub-chat-unmute-user.js";
+import { HubChatMuteUserPlugin } from "../plugins/chat/hub-chat-mute-user.js";
+import { HubChatCreateSystemMessagePlugin } from "../plugins/chat/hub-chat-create-system-message.js";
+import { HubChatAfterIdConditionPlugin } from "../plugins/chat/hub-chat-after-id-condition.js";
 export const requiredPlugins = [
     SmartTagsPlugin,
     IdToNodeIdPlugin,
@@ -48,7 +55,7 @@ export const defaultPlugins = [
     HubPreimageHashFieldPlugin,
     customPgOmitArchivedPlugin("deleted"),
 ];
-export function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, }) {
+export function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, enableChat, enablePlayground, }) {
     if (exportSchemaSDLPath) {
         if (!exportSchemaSDLPath.startsWith("/")) {
             throw new Error("exportSchemaSDLPath must be an absolute path");
@@ -65,6 +72,12 @@ export function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abo
             mutablePlugins.unshift(requiredPlugin);
         }
     }
+    if (enablePlayground) {
+        mutablePlugins.push(HubCreatePlaygroundSessionPlugin);
+    }
+    if (enableChat) {
+        mutablePlugins.push(HubChatCreateUserMessagePlugin, HubChatCreateSystemMessagePlugin, HubChatSubscriptionPlugin, HubChatMuteUserPlugin, HubChatUnmuteUserPlugin, HubChatAfterIdConditionPlugin);
+    }
     const preset = {
         extends: [PostGraphileAmberPreset],
         disablePlugins: ["NodePlugin"],
@@ -116,19 +129,29 @@ export function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abo
                             experience_id: reqIdentity.user.experience_id,
                             session_id: reqIdentity.sessionId,
                             is_playground: reqIdentity.isPlayground,
+                            is_experience_owner: reqIdentity.isExperienceOwner,
                         },
                     };
                 }
                 const pgSettings = {};
+                let ourPgSettings;
                 if (reqIdentity?.kind === "user") {
-                    pgSettings["session.user_id"] = reqIdentity.user.id;
-                    pgSettings["session.experience_id"] = reqIdentity.user.experience_id;
-                    pgSettings["session.casino_id"] = reqIdentity.user.casino_id;
-                    pgSettings["session.session_id"] = reqIdentity.sessionId;
+                    ourPgSettings = {
+                        "session.user_id": reqIdentity.user.id,
+                        "session.experience_id": reqIdentity.user.experience_id,
+                        "session.casino_id": reqIdentity.user.casino_id,
+                        "session.session_id": reqIdentity.sessionId,
+                        "session.is_experience_owner": reqIdentity.isExperienceOwner
+                            ? "1"
+                            : undefined,
+                    };
                 }
                 else if (reqIdentity?.kind === "operator") {
-                    pgSettings["operator.api_key"] = reqIdentity.apiKey;
+                    ourPgSettings = {
+                        "operator.api_key": reqIdentity.apiKey,
+                    };
                 }
+                Object.assign(pgSettings, ourPgSettings);
                 return {
                     pgSettings,
                     identity: pluginIdentity,
@@ -165,14 +188,17 @@ async function handleWebsocketContext(context, ws) {
         experience_id: result.user.experience_id,
         session_id: result.sessionId,
         is_playground: result.isPlayground,
+        is_experience_owner: result.isExperienceOwner,
+    };
+    const pgSettings = {
+        "session.user_id": result.user.id,
+        "session.experience_id": result.user.experience_id,
+        "session.casino_id": result.user.casino_id,
+        "session.session_id": result.sessionId,
+        "session.is_experience_owner": result.isExperienceOwner ? "1" : undefined,
     };
     return {
-        pgSettings: {
-            "session.user_id": result.user.id,
-            "session.experience_id": result.user.experience_id,
-            "session.casino_id": result.user.casino_id,
-            "session.session_id": result.sessionId,
-        },
+        pgSettings,
         identity: {
             kind: "user",
             session,

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

@@ -4,7 +4,9 @@ export type HubServer = {
     listen: () => Promise<void>;
     shutdown: () => Promise<void>;
 };
-export declare function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, }: Pick<ServerOptions, "plugins" | "exportSchemaSDLPath" | "extraPgSchemas" | "configureApp"> & {
+export declare function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, enableChat, enablePlayground, }: Pick<ServerOptions, "plugins" | "exportSchemaSDLPath" | "extraPgSchemas" | "configureApp"> & {
     abortSignal: AbortSignal;
     context: ServerContext;
+    enableChat: boolean;
+    enablePlayground: boolean;
 }): HubServer;