@moneypot/hub 1.15.0 → 1.16.0-dev.3

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,53 @@ 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 userInsertResult = 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],
+                            WITH user_inserts AS (
+                              INSERT INTO hub.user(casino_id, mp_user_id, uname)
+                              VALUES 
+                                ($1, $2, $3),
+                                ($1, $4, $5)
+                              ON CONFLICT (casino_id, mp_user_id) DO UPDATE
+                                SET uname = EXCLUDED.uname
+                                WHERE hub.user.uname IS DISTINCT FROM EXCLUDED.uname
+                              RETURNING id, mp_user_id
+                            )
+                            SELECT 
+                              MAX(CASE WHEN mp_user_id = $2 THEN id END) as auth_user_id,
+                              MAX(CASE WHEN mp_user_id = $2 THEN uname END) as auth_user_uname,
+                              MAX(CASE WHEN mp_user_id = $4 THEN id END) as owner_user_id,
+                              MAX(CASE WHEN mp_user_id = $4 THEN uname END) as owner_user_uname
+                            FROM user_inserts
+                          `,
+                                        values: [
+                                            casino.id,
+                                            mpUserId,
+                                            uname,
+                                            mpExperience.userByUserId.id,
+                                            mpExperience.userByUserId.uname,
+                                        ],
                                     })
                                         .then(exactlyOneRow);
-                                    const userId = dbUser.id;
-                                    const mpExperience = result.experience;
-                                    assert(mpExperience);
+                                    const userId = userInsertResult.auth_user_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,
+                                            userInsertResult.owner_user_id,
                                         ],
                                     })
                                         .then(exactlyOneRow);
@@ -172,7 +191,7 @@ export const HubAuthenticatePlugin = makeExtendSchemaPlugin(() => {
                                         .then(exactlyOneRow);
                                     const ret = {
                                         userId,
-                                        uname: dbUser.uname,
+                                        uname: userInsertResult.auth_user_uname,
                                         experienceId: dbExperience.id,
                                         sessionKey: dbSession.key,
                                     };
@@ -185,14 +204,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/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;

package/dist/src/server/index.js

@@ -45,7 +45,7 @@ function createExpressServer(context) {
     });
     return app;
 }
-export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, }) {
+export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, enableChat, enablePlayground, }) {
     const expressServer = createExpressServer(context);
     const preset = createPreset({
         plugins: plugins ?? defaultPlugins,
@@ -53,6 +53,8 @@ export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, ex
         extraPgSchemas: extraPgSchemas ?? [],
         abortSignal,
         context,
+        enableChat,
+        enablePlayground,
     });
     const pgl = postgraphile.default(preset);
     const serv = pgl.createServ(grafserv);

package/dist/src/server/middleware/authentication.js

@@ -35,6 +35,7 @@ const authentication = (context) => {
                     user: result.user,
                     sessionId: result.sessionId,
                     isPlayground: result.isPlayground,
+                    isExperienceOwner: result.isExperienceOwner,
                 };
             }
             return next();

package/dist/src/util.d.ts

@@ -1,3 +1,4 @@
+import z from "zod/v4";
 export declare function isUuid(input: any): boolean;
 export type Result<V, E> = {
     ok: true;
@@ -6,3 +7,5 @@ export type Result<V, E> = {
     ok: false;
     error: E;
 };
+export declare function extractFirstZodErrorMessage(e: z.ZodError): string;
+export declare function uuidEqual(a: string, b: string): boolean;

package/dist/src/util.js

@@ -2,3 +2,12 @@ const UUID_REGEX = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA
 export function isUuid(input) {
     return typeof input === "string" && UUID_REGEX.test(input);
 }
+export function extractFirstZodErrorMessage(e) {
+    return e.issues[0].message;
+}
+export function uuidEqual(a, b) {
+    return normalizeUuid(a) === normalizeUuid(b);
+}
+function normalizeUuid(uuid) {
+    return uuid.toLowerCase();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.15.0",
+  "version": "1.16.0-dev.3",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [