@nocobase/server 1.9.0-beta.1 → 1.9.0-beta.11

package/lib/application.d.ts

@@ -37,6 +37,8 @@ import { Environment } from './environment';
 import { ServiceContainer } from './service-container';
 import { EventQueue, EventQueueOptions } from './event-queue';
 import { BackgroundJobManager, BackgroundJobManagerOptions } from './background-job-manager';
+import { RedisConfig, RedisConnectionManager } from './redis-connection-manager';
+import { WorkerIdAllocator } from './worker-id-allocator';
 export type PluginType = string | typeof Plugin;
 export type PluginConfiguration = PluginType | [PluginType, any];
 export interface ResourceManagerOptions {
@@ -57,8 +59,9 @@ export interface AppTelemetryOptions extends TelemetryOptions {
     enabled?: boolean;
 }
 export interface ApplicationOptions {
-    instanceId?: string;
+    instanceId?: number;
     database?: IDatabaseOptions | Database;
+    redisConfig?: RedisConfig;
     cacheManager?: CacheManagerOptions;
     /**
      * this property is deprecated and should not be used.
@@ -131,9 +134,12 @@ export type MaintainingCommandStatus = {
     status: MaintainingStatus;
     error?: Error;
 };
+interface SnowflakeIdGenerator {
+    generate(): number | BigInt;
+}
 export declare class Application<StateT = DefaultState, ContextT = DefaultContext> extends Koa implements AsyncEmitter {
     options: ApplicationOptions;
-    readonly instanceId: string;
+    private _instanceId;
     /**
      * @internal
      */
@@ -168,6 +174,9 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     /**
      * @internal
      */
+    redisConnectionManager: RedisConnectionManager;
+    workerIdAllocator: WorkerIdAllocator;
+    snowflakeIdGenerator: SnowflakeIdGenerator;
     pubSubManager: PubSubManager;
     syncMessageManager: SyncMessageManager;
     requestLogger: Logger;
@@ -186,6 +195,7 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     private static staticCommands;
     static addCommand(callback: (app: Application) => void): void;
     private _sqlLogger;
+    get instanceId(): number;
     get sqlLogger(): Logger;
     protected _logger: SystemLogger;
     get logger(): SystemLogger;
@@ -309,6 +319,7 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     actions(handlers: any, options?: ActionsOptions): void;
     command(name: string, desc?: string, opts?: CommandOptions): AppCommand;
     findCommand(name: string): Command;
+    private disposeServices;
     /**
      * @internal
      */

package/lib/application.js

@@ -51,12 +51,12 @@ var import_logger = require("@nocobase/logger");
 var import_telemetry = require("@nocobase/telemetry");
 var import_lock_manager = require("@nocobase/lock-manager");
 var import_utils = require("@nocobase/utils");
+var import_snowflake_id = require("@nocobase/snowflake-id");
 var import_crypto = require("crypto");
 var import_glob = __toESM(require("glob"));
 var import_koa = __toESM(require("koa"));
 var import_koa_compose = __toESM(require("koa-compose"));
 var import_lodash = __toESM(require("lodash"));
-var import_nanoid = require("nanoid");
 var import_path = __toESM(require("path"));
 var import_semver = __toESM(require("semver"));
 var import_acl = require("./acl");
@@ -84,11 +84,13 @@ var import_environment = require("./environment");
 var import_service_container = require("./service-container");
 var import_event_queue = require("./event-queue");
 var import_background_job_manager = require("./background-job-manager");
+var import_redis_connection_manager = require("./redis-connection-manager");
+var import_worker_id_allocator = require("./worker-id-allocator");
+var import_snowflake_id_field = require("./snowflake-id-field");
 const _Application = class _Application extends import_koa.default {
   constructor(options) {
     super();
     this.options = options;
-    this.instanceId = options.instanceId || (0, import_nanoid.nanoid)();
     this.context.reqId = (0, import_crypto.randomUUID)();
     this.rawOptions = this.name == "main" ? import_lodash.default.cloneDeep(options) : {};
     this.init();
@@ -96,7 +98,7 @@ const _Application = class _Application extends import_koa.default {
       this._appSupervisor.addApp(this);
     }
   }
-  instanceId;
+  _instanceId;
   /**
    * @internal
    */
@@ -124,6 +126,9 @@ const _Application = class _Application extends import_koa.default {
   /**
    * @internal
    */
+  redisConnectionManager;
+  workerIdAllocator;
+  snowflakeIdGenerator;
   pubSubManager;
   syncMessageManager;
   requestLogger;
@@ -142,6 +147,9 @@ const _Application = class _Application extends import_koa.default {
     this.staticCommands.push(callback);
   }
   _sqlLogger;
+  get instanceId() {
+    return this._instanceId;
+  }
   get sqlLogger() {
     return this._sqlLogger;
   }
@@ -279,6 +287,9 @@ const _Application = class _Application extends import_koa.default {
     if (!WORKER_MODE) {
       return true;
     }
+    if (WORKER_MODE === "-") {
+      return false;
+    }
     const topics = WORKER_MODE.trim().split(",");
     if (key) {
       if (WORKER_MODE === "*") {
@@ -389,16 +400,10 @@ const _Application = class _Application extends import_koa.default {
   findCommand(name) {
     return this.cli._findCommand(name);
   }
-  /**
-   * @internal
-   */
-  async reInit() {
-    if (!this._loaded) {
-      return;
+  async disposeServices() {
+    if (this.redisConnectionManager) {
+      await this.redisConnectionManager.close();
     }
-    this.log.info("app reinitializing");
-    await this.emitAsync("beforeStop");
-    await this.emitAsync("afterStop");
     if (this.cacheManager) {
       await this.cacheManager.close();
     }
@@ -408,6 +413,19 @@ const _Application = class _Application extends import_koa.default {
     if (this.telemetry.started) {
       await this.telemetry.shutdown();
     }
+    await this.workerIdAllocator.release();
+  }
+  /**
+   * @internal
+   */
+  async reInit() {
+    if (!this._loaded) {
+      return;
+    }
+    this.log.info("app reinitializing");
+    await this.emitAsync("beforeStop");
+    await this.emitAsync("afterStop");
+    await this.disposeServices();
     this.closeLogger();
     const oldDb = this.db;
     this.init();
@@ -431,12 +449,7 @@ const _Application = class _Application extends import_koa.default {
     if (options == null ? void 0 : options.reload) {
       this.setMaintainingMessage("app reload");
       this.log.info(`app.reload()`, { method: "load" });
-      if (this.cacheManager) {
-        await this.cacheManager.close();
-      }
-      if (this.telemetry.started) {
-        await this.telemetry.shutdown();
-      }
+      await this.disposeServices();
       const oldDb = this.db;
       this.init();
       if (!oldDb.closed()) {
@@ -457,6 +470,15 @@ const _Application = class _Application extends import_koa.default {
     if ((options == null ? void 0 : options.hooks) !== false) {
       await this.emitAsync("beforeLoad", this, options);
     }
+    if (!this._instanceId) {
+      this._instanceId = await this.workerIdAllocator.getWorkerId();
+      this.log.info(`allocate worker id: ${this._instanceId}`, { method: "load" });
+    }
+    if (!this.snowflakeIdGenerator) {
+      this.snowflakeIdGenerator = new import_snowflake_id.Snowflake({
+        workerId: this._instanceId
+      });
+    }
     if (!this.telemetry.started) {
       this.telemetry.init();
       if ((_a = this.options.telemetry) == null ? void 0 : _a.enabled) {
@@ -704,12 +726,7 @@ const _Application = class _Application extends import_koa.default {
     } catch (e) {
       log.error(e.message, { method: "stop", err: e.stack });
     }
-    if (this.cacheManager) {
-      await this.cacheManager.close();
-    }
-    if (this.telemetry.started) {
-      await this.telemetry.shutdown();
-    }
+    await this.disposeServices();
     await this.emitAsync("afterStop", this, options);
     this.emit("__stopped", this, options);
     this.stopped = true;
@@ -873,6 +890,7 @@ const _Application = class _Application extends import_koa.default {
   }
   init() {
     const options = this.options;
+    this._instanceId = options.instanceId;
     this.initLogger(options.logger);
     this.reInitEvents();
     this.middleware = new import_utils.Toposort();
@@ -881,6 +899,11 @@ const _Application = class _Application extends import_koa.default {
       this.db.removeAllListeners();
     }
     this.createMainDataSource(options);
+    this.redisConnectionManager = new import_redis_connection_manager.RedisConnectionManager({
+      redisConfig: options.redisConfig,
+      logger: this._logger.child({ module: "redis-connection-manager" })
+    });
+    this.workerIdAllocator = new import_worker_id_allocator.WorkerIdAllocator();
     this._cronJobManager = new import_cron_job_manager.CronJobManager(this);
     this._env = new import_environment.Environment();
     this._cli = this.createCLI();
@@ -959,6 +982,7 @@ const _Application = class _Application extends import_koa.default {
       app: this
     });
     this.dataSourceManager.dataSources.set("main", mainDataSourceInstance);
+    (0, import_snowflake_id_field.setupSnowflakeIdField)(this);
   }
   createDatabase(options) {
     const logging = /* @__PURE__ */ __name((...args) => {

package/lib/audit-manager/index.js

@@ -252,6 +252,9 @@ const _AuditManager = class _AuditManager {
   async output(ctx, reqId, metadata) {
     var _a;
     try {
+      if (!ctx.action) {
+        return;
+      }
       const { resourceName, actionName } = ctx.action;
       const action = this.getAction(actionName, resourceName);
       if (!action) {

package/lib/event-queue.d.ts

@@ -7,6 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import Application from './application';
+import { SystemLogger } from '@nocobase/logger';
 export declare const QUEUE_DEFAULT_INTERVAL = 250;
 export declare const QUEUE_DEFAULT_CONCURRENCY = 1;
 export declare const QUEUE_DEFAULT_ACK_TIMEOUT = 15000;
@@ -15,7 +16,7 @@ export type QueueCallbackOptions = {
     retried?: number;
     signal?: AbortSignal;
 };
-export type QueueCallback = (message: any, options: QueueCallbackOptions) => Promise<void> | void;
+export type QueueCallback = (message: any, options: QueueCallbackOptions) => Promise<void>;
 export type QueueEventOptions = {
     /**
      * @experimental
@@ -53,11 +54,12 @@ export declare class MemoryEventQueueAdapter implements IEventQueueAdapter {
         content: any;
         options?: QueueMessageOptions;
     }[]>;
-    get processing(): Promise<void[]>;
+    get processing(): Promise<Promise<void>[][]>;
     private get storagePath();
-    listen: (channel: string) => Promise<void>;
+    listen: (channel: string) => void;
     constructor(options: {
         appName: string;
+        logger: SystemLogger;
     });
     isConnected(): boolean;
     setConnected(connected: boolean): void;
@@ -69,7 +71,7 @@ export declare class MemoryEventQueueAdapter implements IEventQueueAdapter {
     unsubscribe(channel: string): void;
     publish(channel: string, content: any, options?: QueueMessageOptions): void;
     consume(channel: string, once?: boolean): Promise<void>;
-    read(channel: string): Promise<void>;
+    read(channel: string, n: number): Promise<void>[];
     process(channel: string, { id, message }: {
         id: any;
         message: any;

package/lib/event-queue.js

@@ -73,26 +73,35 @@ const _MemoryEventQueueAdapter = class _MemoryEventQueueAdapter {
   get storagePath() {
     return import_path.default.resolve(process.cwd(), "storage", "apps", this.options.appName, "event-queue.json");
   }
-  listen = /* @__PURE__ */ __name(async (channel) => {
+  listen = /* @__PURE__ */ __name((channel) => {
     if (!this.connected) {
       return;
     }
-    if (this.reading.has(channel)) {
-      console.debug(`memory queue (${channel}) is already reading, waiting last reading to end...`);
-      await this.reading.get(channel);
-    }
+    const { logger } = this.options;
     const event = this.events.get(channel);
     if (!event) {
-      console.warn(`memory queue (${channel}) not found, skipping...`);
+      logger.warn(`memory queue (${channel}) not found, skipping...`);
       return;
     }
     if (!event.idle()) {
-      console.debug(`memory queue (${channel}) is not idle, skipping...`);
       return;
     }
-    const reading = this.read(channel);
+    const reading = this.reading.get(channel) || [];
+    const count = (event.concurrency || QUEUE_DEFAULT_CONCURRENCY) - reading.length;
+    if (count <= 0) {
+      return;
+    }
+    logger.debug(`reading more from queue (${channel}), count: ${count}`);
+    this.read(channel, count).forEach((promise) => {
+      reading.push(promise);
+      promise.finally(() => {
+        const index = reading.indexOf(promise);
+        if (index > -1) {
+          reading.splice(index, 1);
+        }
+      });
+    });
     this.reading.set(channel, reading);
-    await reading;
   }, "listen");
   isConnected() {
     return this.connected;
@@ -103,20 +112,21 @@ const _MemoryEventQueueAdapter = class _MemoryEventQueueAdapter {
   async loadFromStorage() {
     let queues = {};
     let exists = false;
+    const { logger } = this.options;
     try {
       await import_promises.default.stat(this.storagePath);
       exists = true;
     } catch (ex) {
-      console.info(`memory queue storage file not found, skip`);
+      logger.info(`memory queue storage file not found, skip`);
     }
     if (exists) {
       try {
         const queueJson = await import_promises.default.readFile(this.storagePath);
         queues = JSON.parse(queueJson.toString());
-        console.debug("memory queue loaded from storage", queues);
+        logger.debug("memory queue loaded from storage", queues);
         await import_promises.default.unlink(this.storagePath);
       } catch (ex) {
-        console.error("failed to load queue from storage", ex);
+        logger.error("failed to load queue from storage", ex);
       }
     }
     this.queues = new Map(Object.entries(queues));
@@ -128,12 +138,13 @@ const _MemoryEventQueueAdapter = class _MemoryEventQueueAdapter {
       }
       return acc;
     }, {});
+    const { logger } = this.options;
     if (Object.keys(queues).length) {
       await import_promises.default.mkdir(import_path.default.dirname(this.storagePath), { recursive: true });
       await import_promises.default.writeFile(this.storagePath, JSON.stringify(queues));
-      console.debug("memory queue saved to storage", queues);
+      logger.debug("memory queue saved to storage", queues);
     } else {
-      console.debug("memory queue empty, no need to save to storage");
+      logger.debug("memory queue empty, no need to save to storage");
     }
   }
   async connect() {
@@ -149,13 +160,17 @@ const _MemoryEventQueueAdapter = class _MemoryEventQueueAdapter {
     });
   }
   async close() {
+    if (!this.connected) {
+      return;
+    }
+    const { logger } = this.options;
     this.connected = false;
     if (this.processing) {
-      console.info("memory queue waiting for processing job...");
+      logger.info("memory queue waiting for processing job...");
       await this.processing;
-      console.info("memory queue job cleaned");
+      logger.info("memory queue job cleaned");
     }
-    console.log("memory queue gracefully shutting down...");
+    logger.info("memory queue gracefully shutting down...");
     await this.saveToStorage();
   }
   subscribe(channel, options) {
@@ -181,6 +196,7 @@ const _MemoryEventQueueAdapter = class _MemoryEventQueueAdapter {
   publish(channel, content, options = { timestamp: Date.now() }) {
     const event = this.events.get(channel);
     if (!event) {
+      console.debug(`memory queue (${channel}) not subscribed, skip`);
       return;
     }
     if (!this.queues.get(channel)) {
@@ -189,7 +205,8 @@ const _MemoryEventQueueAdapter = class _MemoryEventQueueAdapter {
     const queue = this.queues.get(channel);
     const message = { id: (0, import_crypto.randomUUID)(), content, options };
     queue.push(message);
-    console.debug(`memory queue (${channel}) published message`, content);
+    const { logger } = this.options;
+    logger.debug(`memory queue (${channel}) published message`, content);
     setImmediate(() => {
       this.emitter.emit(channel, channel);
     });
@@ -200,7 +217,7 @@ const _MemoryEventQueueAdapter = class _MemoryEventQueueAdapter {
       const interval = event.interval || QUEUE_DEFAULT_INTERVAL;
       const queue = this.queues.get(channel);
       if (event.idle() && (queue == null ? void 0 : queue.length)) {
-        await this.listen(channel);
+        this.listen(channel);
       }
       if (once) {
         break;
@@ -208,47 +225,43 @@ const _MemoryEventQueueAdapter = class _MemoryEventQueueAdapter {
       await (0, import_utils.sleep)(interval);
     }
   }
-  async read(channel) {
-    const event = this.events.get(channel);
-    if (!event) {
-      this.reading.delete(channel);
-      return;
-    }
+  read(channel, n) {
     const queue = this.queues.get(channel);
-    if (queue == null ? void 0 : queue.length) {
-      const messages = queue.slice(0, event.concurrency || QUEUE_DEFAULT_CONCURRENCY);
-      console.debug(`memory queue (${channel}) read ${messages.length} messages`, messages);
-      queue.splice(0, messages.length);
-      const batch = messages.map(({ id, ...message }) => this.process(channel, { id, message }));
-      await Promise.all(batch);
-    }
-    this.reading.delete(channel);
+    if (!(queue == null ? void 0 : queue.length)) {
+      return [];
+    }
+    const { logger } = this.options;
+    const messages = queue.slice(0, n);
+    logger.debug(`memory queue (${channel}) read ${messages.length} messages`, messages);
+    queue.splice(0, messages.length);
+    const batch = messages.map(({ id, ...message }) => this.process(channel, { id, message }));
+    return batch;
   }
   async process(channel, { id, message }) {
     const event = this.events.get(channel);
     const { content, options: { timeout = QUEUE_DEFAULT_ACK_TIMEOUT, maxRetries = 0, retried = 0 } = {} } = message;
-    try {
-      console.debug(`memory queue (${channel}) processing message (${id})...`, content);
-      await event.process(content, {
-        id,
-        retried,
-        signal: AbortSignal.timeout(timeout)
-      });
-      console.debug(`memory queue (${channel}) consumed message (${id})`);
-    } catch (ex) {
+    const { logger } = this.options;
+    logger.debug(`memory queue (${channel}) processing message (${id})...`, content);
+    return (async () => event.process(content, {
+      id,
+      retried,
+      signal: AbortSignal.timeout(timeout)
+    }))().then(() => {
+      logger.debug(`memory queue (${channel}) consumed message (${id})`);
+    }).catch((ex) => {
       if (maxRetries > 0 && retried < maxRetries) {
         const currentRetry = retried + 1;
-        console.warn(
+        logger.warn(
           `memory queue (${channel}) consum message (${id}) failed, retrying (${currentRetry} / ${maxRetries})...`,
           ex
         );
-        setImmediate(() => {
+        setTimeout(() => {
           this.publish(channel, content, { timeout, maxRetries, retried: currentRetry, timestamp: Date.now() });
-        });
+        }, 500);
       } else {
-        console.error(ex);
+        logger.error(ex);
       }
-    }
+    });
   }
 };
 __name(_MemoryEventQueueAdapter, "MemoryEventQueueAdapter");
@@ -257,14 +270,16 @@ const _EventQueue = class _EventQueue {
   constructor(app, options = {}) {
     this.app = app;
     this.options = options;
-    this.setAdapter(new MemoryEventQueueAdapter({ appName: this.app.name }));
-    app.on("afterStart", async () => {
-      await this.connect();
-    });
-    app.on("beforeStop", async () => {
-      app.logger.info("[queue] gracefully shutting down...");
-      await this.close();
-    });
+    if (app.serving()) {
+      this.setAdapter(new MemoryEventQueueAdapter({ appName: this.app.name, logger: this.app.logger }));
+      app.on("afterStart", async () => {
+        await this.connect();
+      });
+      app.on("beforeStop", async () => {
+        app.logger.info("[queue] gracefully shutting down...");
+        await this.close();
+      });
+    }
   }
   adapter;
   events = /* @__PURE__ */ new Map();
@@ -288,7 +303,12 @@ const _EventQueue = class _EventQueue {
     if (!this.adapter) {
       throw new Error("no adapter set, cannot connect");
     }
+    if (!this.app.serving()) {
+      this.app.logger.warn("app is not serving, will not connect to event queue");
+      return;
+    }
     await this.adapter.connect();
+    this.app.logger.debug(`connected to adapter, using memory? ${this.adapter instanceof MemoryEventQueueAdapter}`);
     for (const [channel, event] of this.events.entries()) {
       this.adapter.subscribe(this.getFullChannel(channel), event);
     }
@@ -329,7 +349,7 @@ const _EventQueue = class _EventQueue {
       throw new Error("event queue not connected, cannot publish");
     }
     const c = this.getFullChannel(channel);
-    this.app.logger.debug("event queue publishing:", { channel: c, message });
+    this.app.logger.debug(`event queue publishing to channel(${c})`, { message });
     await this.adapter.publish(c, message, {
       timeout: QUEUE_DEFAULT_ACK_TIMEOUT,
       ...options,

package/lib/gateway/index.d.ts

@@ -47,6 +47,8 @@ export declare class Gateway extends EventEmitter {
     private port;
     private host;
     private socketPath;
+    private terminating;
+    private onTerminate;
     private constructor();
     static getInstance(options?: any): Gateway;
     static getIPCSocketClient(): Promise<false | IPCSocketClient>;

package/lib/gateway/index.js

@@ -86,10 +86,37 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
   port = import_node_process.default.env.APP_PORT ? parseInt(import_node_process.default.env.APP_PORT) : null;
   host = "0.0.0.0";
   socketPath = (0, import_path.resolve)(import_node_process.default.cwd(), "storage", "gateway.sock");
+  terminating = false;
+  onTerminate = /* @__PURE__ */ __name(async (signal) => {
+    var _a;
+    if (this.terminating) {
+      return;
+    }
+    this.terminating = true;
+    const supervisor = import_app_supervisor.AppSupervisor.getInstance();
+    const apps = Object.values(supervisor.apps || {});
+    try {
+      for (const app of apps) {
+        try {
+          await app.destroy({ signal });
+        } catch (error) {
+          const logger = (app == null ? void 0 : app.log) ?? console;
+          (_a = logger.error) == null ? void 0 : _a.call(logger, error);
+        }
+      }
+      await supervisor.destroy();
+    } catch (error) {
+      console.error("Failed to shutdown applications gracefully", error);
+    } finally {
+      this.destroy();
+    }
+  }, "onTerminate");
   constructor() {
     super();
     this.reset();
     this.socketPath = getSocketPath();
+    import_node_process.default.once("SIGTERM", this.onTerminate);
+    import_node_process.default.once("SIGINT", this.onTerminate);
   }
   static getInstance(options = {}) {
     if (!_Gateway.instance) {
@@ -106,6 +133,8 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     }
   }
   destroy() {
+    import_node_process.default.off("SIGTERM", this.onTerminate);
+    import_node_process.default.off("SIGINT", this.onTerminate);
     this.reset();
     _Gateway.instance = null;
   }
@@ -137,6 +166,10 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
       this.ipcSocketServer.close();
       this.ipcSocketServer = null;
     }
+    if (this.wsServer) {
+      this.wsServer.close();
+      this.wsServer = null;
+    }
   }
   addAppSelectorMiddleware(middleware, options) {
     if (this.selectorMiddlewares.nodes.some((existingFunc) => existingFunc.toString() === middleware.toString())) {

package/lib/gateway/ws-server.js

@@ -172,6 +172,20 @@ const _WSServer = class _WSServer extends import_events.default {
         message
       );
     });
+    app.on("ws:sendToUser", ({ userId, message }) => {
+      this.sendToAppUser(app.name, userId, message);
+      app.logger.trace(`[broadcasting message] ws:sendToUser for user ${userId}`, { message });
+      app.pubSubManager.publish(
+        "ws:sendToUser",
+        {
+          userId,
+          message
+        },
+        {
+          skipSelf: true
+        }
+      );
+    });
     app.on("ws:sendToClient", ({ clientId, message }) => {
       this.sendToClient(clientId, message);
     });
@@ -184,6 +198,12 @@ const _WSServer = class _WSServer extends import_events.default {
     app.on("ws:authorized", ({ clientId, userId }) => {
       this.sendToClient(clientId, { type: "authorized" });
     });
+    app.on("afterLoad", () => {
+      app.pubSubManager.subscribe("ws:sendToUser", ({ userId, message }) => {
+        app.logger.debug(`[receive broadcasting message] ws:sendToUser for user ${userId}`, { message });
+        this.sendToAppUser(app.name, userId, message);
+      });
+    });
   }
   addNewConnection(ws, request) {
     const id = (0, import_nanoid.nanoid)();

package/lib/helper.d.ts

@@ -16,3 +16,4 @@ export declare const createAppProxy: (app: Application) => Application<import(".
 export declare const getCommandFullName: (command: Command) => string;
 export declare const tsxRerunning: () => Promise<void>;
 export declare const enablePerfHooks: (app: Application) => void;
+export declare function getBodyLimit(): string;

package/lib/helper.js

@@ -41,6 +41,7 @@ __export(helper_exports, {
   createI18n: () => createI18n,
   createResourcer: () => createResourcer,
   enablePerfHooks: () => enablePerfHooks,
+  getBodyLimit: () => getBodyLimit,
   getCommandFullName: () => getCommandFullName,
   registerMiddlewares: () => registerMiddlewares,
   tsxRerunning: () => tsxRerunning
@@ -99,7 +100,7 @@ function registerMiddlewares(app, options) {
     }
   );
   if (options.bodyParser !== false) {
-    const bodyLimit = "10mb";
+    const bodyLimit = getBodyLimit();
     app.use(
       (0, import_koa_bodyparser.default)({
         jsonLimit: bodyLimit,
@@ -188,12 +189,17 @@ const enablePerfHooks = /* @__PURE__ */ __name((app) => {
   });
   app.acl.allow("perf", "*", "public");
 }, "enablePerfHooks");
+function getBodyLimit() {
+  return process.env.REQUEST_BODY_LIMIT || "10mb";
+}
+__name(getBodyLimit, "getBodyLimit");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createAppProxy,
   createI18n,
   createResourcer,
   enablePerfHooks,
+  getBodyLimit,
   getCommandFullName,
   registerMiddlewares,
   tsxRerunning