@nocobase/server 2.0.0-alpha.9 → 2.0.0-beta.2

package/lib/acl/available-action.js

@@ -56,7 +56,7 @@ const availableActions = {
   update: {
     displayName: '{{t("Edit")}}',
     type: "old-data",
-    aliases: ["update", "move", "add", "set", "remove", "toggle"],
+    aliases: ["update", "move"],
     allowConfigureFields: true
   },
   destroy: {

package/lib/aes-encryptor.js

@@ -109,6 +109,10 @@ const _AesEncryptor = class _AesEncryptor {
     return appKeyPath;
   }
   static async create(app) {
+    if (process.env.APP_AES_SECRET_KEY) {
+      const key2 = Buffer.from(process.env.APP_AES_SECRET_KEY, "hex");
+      return new _AesEncryptor(key2);
+    }
     const KEY_PATH = process.env.APP_AES_SECRET_KEY_PATH;
     const keyPath = KEY_PATH ? (0, import_path.resolve)(process.cwd(), KEY_PATH) : await this.getKeyPath(app.name);
     const key = await _AesEncryptor.getOrGenerateKey(keyPath);

package/lib/app-command.d.ts

@@ -14,6 +14,7 @@ export declare class AppCommand extends Command {
     auth(): this;
     preload(): this;
     hasCommand(name: string): boolean;
+    findCommand(name: string): any;
     isHandleByIPCServer(): boolean;
     createCommand(name?: string): AppCommand;
     parseHandleByIPCServer(argv: any, parseOptions?: any): Boolean;

package/lib/app-command.js

@@ -51,6 +51,9 @@ const _AppCommand = class _AppCommand extends import_commander.Command {
     const names = this.commands.map((c) => c.name());
     return names.includes(name);
   }
+  findCommand(name) {
+    return this._findCommand(name);
+  }
   isHandleByIPCServer() {
     return this._handleByIPCServer;
   }

package/lib/app-supervisor.d.ts

@@ -8,6 +8,7 @@
  */
 /// <reference types="node" />
 import { AsyncEmitter } from '@nocobase/utils';
+import { Mutex } from 'async-mutex';
 import { EventEmitter } from 'events';
 import Application, { ApplicationOptions } from './application';
 type BootOptions = {
@@ -16,9 +17,10 @@ type BootOptions = {
     appSupervisor: AppSupervisor;
 };
 type AppBootstrapper = (bootOptions: BootOptions) => Promise<void>;
-type AppStatus = 'initializing' | 'initialized' | 'running' | 'commanding' | 'stopped' | 'error' | 'not_found';
+export type AppStatus = 'preparing' | 'initializing' | 'initialized' | 'running' | 'commanding' | 'stopped' | 'error' | 'not_found';
 export declare class AppSupervisor extends EventEmitter implements AsyncEmitter {
     private static instance;
+    private bootstrapQueue;
     runningMode: 'single' | 'multiple';
     singleAppName: string | null;
     emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
@@ -48,7 +50,8 @@ export declare class AppSupervisor extends EventEmitter implements AsyncEmitter
     reset(): Promise<void>;
     destroy(): Promise<void>;
     setAppStatus(appName: string, status: AppStatus, options?: {}): void;
-    getMutexOfApp(appName: string): any;
+    getMutexOfApp(appName: string): Mutex;
+    private _bootStrapApp;
     bootStrapApp(appName: string, options?: {}): Promise<void>;
     getApp(appName: string, options?: {
         withOutBootStrap?: boolean;
@@ -61,6 +64,8 @@ export declare class AppSupervisor extends EventEmitter implements AsyncEmitter
     touchApp(appName: string): void;
     addApp(app: Application): Application<import("./application").DefaultState, import("./application").DefaultContext>;
     getAppsNames(): Promise<string[]>;
+    startApp(appName: string): Promise<void>;
+    stopApp(appName: string): Promise<void>;
     removeApp(appName: string): Promise<void>;
     subApps(): Application<import("./application").DefaultState, import("./application").DefaultContext>[];
     on(eventName: string | symbol, listener: (...args: any[]) => void): this;

package/lib/app-supervisor.js

@@ -47,7 +47,9 @@ var import_async_mutex = require("async-mutex");
 var import_events = require("events");
 var import_application = __toESM(require("./application"));
 var import_handler = require("./errors/handler");
+var import_p_queue = __toESM(require("p-queue"));
 const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
+  bootstrapQueue;
   runningMode = "multiple";
   singleAppName = null;
   apps = {};
@@ -64,6 +66,12 @@ const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
       this.runningMode = "single";
       this.singleAppName = process.env.STARTUP_SUBAPP;
     }
+    this.bootstrapQueue = new import_p_queue.default({
+      concurrency: process.env.SUBAPP_BOOTSTRAP_CONCURRENCY ? parseInt(process.env.SUBAPP_BOOTSTRAP_CONCURRENCY) : Infinity,
+      intervalCap: process.env.SUBAPP_BOOTSTRAP_INTERVAL_CAP ? parseInt(process.env.SUBAPP_BOOTSTRAP_INTERVAL_CAP) : Infinity,
+      interval: process.env.SUBAPP_BOOTSTRAP_INTERVAL ? parseInt(process.env.SUBAPP_BOOTSTRAP_INTERVAL) : 0,
+      timeout: 1 * 60 * 1e3
+    });
   }
   static getInstance() {
     if (!_AppSupervisor.instance) {
@@ -113,24 +121,42 @@ const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
     }
     return this.appMutexes[appName];
   }
+  async _bootStrapApp(appName, options = {}) {
+    this.setAppStatus(appName, "initializing");
+    if (this.appBootstrapper) {
+      await this.appBootstrapper({
+        appSupervisor: this,
+        appName,
+        options
+      });
+    }
+    if (!this.hasApp(appName)) {
+      this.setAppStatus(appName, "not_found");
+    } else if (!this.getAppStatus(appName) || this.getAppStatus(appName) === "initializing") {
+      this.setAppStatus(appName, "initialized");
+    }
+  }
   async bootStrapApp(appName, options = {}) {
-    await this.getMutexOfApp(appName).runExclusive(async () => {
-      if (!this.hasApp(appName)) {
-        this.setAppStatus(appName, "initializing");
-        if (this.appBootstrapper) {
-          await this.appBootstrapper({
-            appSupervisor: this,
-            appName,
-            options
-          });
+    const mutex = this.getMutexOfApp(appName);
+    try {
+      await (0, import_async_mutex.tryAcquire)(mutex).runExclusive(async () => {
+        if (this.hasApp(appName) && this.getAppStatus(appName) !== "preparing") {
+          return;
         }
-        if (!this.hasApp(appName)) {
-          this.setAppStatus(appName, "not_found");
-        } else if (!this.getAppStatus(appName) || this.getAppStatus(appName) == "initializing") {
-          this.setAppStatus(appName, "initialized");
+        if (appName === "main") {
+          return this._bootStrapApp(appName, options);
         }
+        this.setAppStatus(appName, "preparing");
+        await this.bootstrapQueue.add(async () => {
+          await this._bootStrapApp(appName, options);
+        });
+      });
+    } catch (e) {
+      console.log(e);
+      if (e === import_async_mutex.E_ALREADY_LOCKED) {
+        return;
       }
-    });
+    }
   }
   async getApp(appName, options = {}) {
     if (!options.withOutBootStrap) {
@@ -170,7 +196,7 @@ const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
     this.apps[app.name] = app;
     this.emit("afterAppAdded", app);
     if (!this.getAppStatus(app.name) || this.getAppStatus(app.name) == "not_found") {
-      this.setAppStatus(app.name, "initialized");
+      this.setAppStatus(app.name, "preparing");
     }
     return app;
   }
@@ -179,12 +205,25 @@ const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
     const apps = Object.values(this.apps);
     return apps.map((app) => app.name);
   }
+  async startApp(appName) {
+    const appInstance = await _AppSupervisor.getInstance().getApp(appName);
+    await appInstance.runCommand("start", "--quickstart");
+  }
+  async stopApp(appName) {
+    if (!this.apps[appName]) {
+      console.log(`app ${appName} not exists`);
+      return;
+    }
+    await this.apps[appName].runCommand("stop");
+    this.apps[appName] = null;
+  }
   async removeApp(appName) {
     if (!this.apps[appName]) {
       console.log(`app ${appName} not exists`);
       return;
     }
     await this.apps[appName].runCommand("destroy");
+    this.apps[appName] = null;
   }
   subApps() {
     return Object.values(this.apps).filter((app) => app.name !== "main");

package/lib/application.d.ts

@@ -34,10 +34,9 @@ import { SyncMessageManager } from './sync-message-manager';
 import AesEncryptor from './aes-encryptor';
 import { AuditManager } from './audit-manager';
 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 { ServiceContainer } from './service-container';
 import { WorkerIdAllocator } from './worker-id-allocator';
 export type PluginType = string | typeof Plugin;
 export type PluginConfiguration = PluginType | [PluginType, any];
@@ -89,7 +88,6 @@ export interface ApplicationOptions {
     auditManager?: AuditManager;
     lockManager?: LockManagerOptions;
     eventQueue?: EventQueueOptions;
-    backgroundJobManager?: BackgroundJobManagerOptions;
     /**
      * @internal
      */
@@ -129,7 +127,12 @@ interface StartOptions {
 type MaintainingStatus = 'command_begin' | 'command_end' | 'command_running' | 'command_error';
 export type MaintainingCommandStatus = {
     command: {
+        components?: {
+            maintaining: string;
+            maintainingDialog: string;
+        };
         name: string;
+        [key: string]: any;
     };
     status: MaintainingStatus;
     error?: Error;
@@ -190,9 +193,9 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     container: ServiceContainer;
     lockManager: LockManager;
     eventQueue: EventQueue;
-    backgroundJobManager: BackgroundJobManager;
     constructor(options: ApplicationOptions);
     private static staticCommands;
+    static registerStaticCommand(callback: (app: Application) => void): void;
     static addCommand(callback: (app: Application) => void): void;
     private _sqlLogger;
     get instanceId(): number;
@@ -219,7 +222,7 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     get environment(): Environment;
     protected _cronJobManager: CronJobManager;
     get cronJobManager(): CronJobManager;
-    get mainDataSource(): SequelizeDataSource;
+    get mainDataSource(): SequelizeDataSource<import("@nocobase/data-source-manager").DatabaseIntrospector>;
     get db(): Database;
     get resourceManager(): import("@nocobase/resourcer").ResourceManager;
     /**
@@ -283,7 +286,7 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     setMaintainingMessage(message: string): void;
     /**
      * This method is deprecated and should not be used.
-     * Use {@link #this.version.get()} instead.
+     * Use {@link #this.getPackageVersion} instead.
      * @deprecated
      */
     getVersion(): string;

package/lib/application.js

@@ -50,8 +50,8 @@ var import_database = __toESM(require("@nocobase/database"));
 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_utils = require("@nocobase/utils");
 var import_crypto = require("crypto");
 var import_glob = __toESM(require("glob"));
 var import_koa = __toESM(require("koa"));
@@ -81,12 +81,11 @@ var import_available_action = require("./acl/available-action");
 var import_aes_encryptor = __toESM(require("./aes-encryptor"));
 var import_audit_manager = require("./audit-manager");
 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_service_container = require("./service-container");
 var import_snowflake_id_field = require("./snowflake-id-field");
+var import_worker_id_allocator = require("./worker-id-allocator");
 const _Application = class _Application extends import_koa.default {
   constructor(options) {
     super();
@@ -142,7 +141,9 @@ const _Application = class _Application extends import_koa.default {
   container = new import_service_container.ServiceContainer();
   lockManager;
   eventQueue;
-  backgroundJobManager;
+  static registerStaticCommand(callback) {
+    this.staticCommands.push(callback);
+  }
   static addCommand(callback) {
     this.staticCommands.push(callback);
   }
@@ -336,7 +337,7 @@ const _Application = class _Application extends import_koa.default {
   }
   /**
    * This method is deprecated and should not be used.
-   * Use {@link #this.version.get()} instead.
+   * Use {@link #this.getPackageVersion} instead.
    * @deprecated
    */
   getVersion() {
@@ -777,6 +778,12 @@ const _Application = class _Application extends import_koa.default {
   }
   async upgrade(options = {}) {
     this.log.info("upgrading...");
+    const pkgVersion = this.getPackageVersion();
+    const appVersion = await this.version.get();
+    if (process.env.SKIP_SAME_VERSION_UPGRADE === "true" && pkgVersion === appVersion) {
+      this.log.info(`app is already the latest version (${appVersion})`);
+      return;
+    }
     await this.reInit();
     const migrator1 = await this.loadCoreMigrations();
     await migrator1.beforeLoad.up();
@@ -800,7 +807,9 @@ const _Application = class _Application extends import_koa.default {
     await migrator3.afterLoad.up();
     await this.pm.repository.updateVersions();
     await this.version.update();
-    await this.emitAsync("afterUpgrade", this, options);
+    if (!options.quickstart) {
+      await this.emitAsync("afterUpgrade", this, options);
+    }
     await this.restart();
   }
   toJSON() {
@@ -911,7 +920,6 @@ const _Application = class _Application extends import_koa.default {
     this.pubSubManager = (0, import_pub_sub_manager.createPubSubManager)(this, options.pubSubManager);
     this.syncMessageManager = new import_sync_message_manager.SyncMessageManager(this, options.syncMessageManager);
     this.eventQueue = new import_event_queue.EventQueue(this, options.eventQueue);
-    this.backgroundJobManager = new import_background_job_manager.BackgroundJobManager(this, options.backgroundJobManager);
     this.lockManager = new import_lock_manager.LockManager({
       defaultAdapter: process.env.LOCK_ADAPTER_DEFAULT,
       ...options.lockManager
@@ -927,8 +935,8 @@ const _Application = class _Application extends import_koa.default {
       plugins: plugins || []
     });
     this._telemetry = new import_telemetry.Telemetry({
-      serviceName: `nocobase-${this.name}`,
-      version: this.getVersion(),
+      appName: this.name,
+      version: this.getPackageVersion(),
       ...options.telemetry
     });
     this._authManager = new import_auth.AuthManager({
@@ -941,6 +949,11 @@ const _Application = class _Application extends import_koa.default {
       name: "auth",
       actions: import_auth.actions
     });
+    this._dataSourceManager.beforeAddDataSource((dataSource) => {
+      if (dataSource.collectionManager instanceof import_data_source_manager.SequelizeCollectionManager) {
+        (0, import_snowflake_id_field.setupSnowflakeIdField)(this, dataSource.collectionManager.db);
+      }
+    });
     this._dataSourceManager.afterAddDataSource((dataSource) => {
       if (dataSource.collectionManager instanceof import_data_source_manager.SequelizeCollectionManager) {
         for (const [actionName, actionParams] of Object.entries(import_available_action.availableActions)) {
@@ -948,7 +961,7 @@ const _Application = class _Application extends import_koa.default {
         }
       }
     });
-    this._dataSourceManager.use(this._authManager.middleware(), { tag: "auth" });
+    this._dataSourceManager.use(this._authManager.middleware(), { tag: "auth", before: "default" });
     this._dataSourceManager.use(import_validate_filter_params.default, { tag: "validate-filter-params", before: ["auth"] });
     this._dataSourceManager.use(import_middlewares.parseVariables, {
       group: "parseVariables",
@@ -982,7 +995,6 @@ 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/commands/index.js

@@ -53,6 +53,7 @@ var import_start = __toESM(require("./start"));
 var import_stop = __toESM(require("./stop"));
 var import_upgrade = __toESM(require("./upgrade"));
 var import_console = __toESM(require("./console"));
+var import_repair = __toESM(require("./repair"));
 /* istanbul ignore file -- @preserve */
 function registerCli(app) {
   (0, import_console.default)(app);
@@ -68,6 +69,7 @@ function registerCli(app) {
   (0, import_destroy.default)(app);
   (0, import_start.default)(app);
   (0, import_refresh.default)(app);
+  (0, import_repair.default)(app);
   app.command("build").argument("[packages...]");
   app.command("clean");
   app.command("dev").usage("[options]").option("-p, --port [port]").option("--client").option("--server");

package/lib/commands/pm.js

@@ -38,6 +38,17 @@ var pm_default = /* @__PURE__ */ __name((app) => {
   pm.command("create").argument("plugin").option("--force-recreate").action(async (plugin, options) => {
     await app.pm.create(plugin, options);
   });
+  pm.command("pull").arguments("<packageNames...>").option("--registry [registry]").option("--auth-token [authToken]").option("--version [version]").action(async (packageNames, options, cli) => {
+    try {
+      let name = packageNames;
+      if (Array.isArray(packageNames) && packageNames.length === 1) {
+        name = packageNames[0];
+      }
+      await app.pm.pull(name, { ...options });
+    } catch (error) {
+      throw new import_plugin_command_error.PluginCommandError(`Failed to pull plugin`, { cause: error });
+    }
+  });
   pm.command("add").ipc().preload().arguments("<packageNames...>").option("--registry [registry]").option("--auth-token [authToken]").option("--version [version]").action(async (packageNames, options, cli) => {
     try {
       let name = packageNames;

package/lib/commands/repair.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import Application from '../application';
+declare const _default: (app: Application) => void;
+export default _default;

package/lib/commands/repair.js

@@ -0,0 +1,43 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var repair_exports = {};
+__export(repair_exports, {
+  default: () => repair_default
+});
+module.exports = __toCommonJS(repair_exports);
+var repair_default = /* @__PURE__ */ __name((app) => {
+  app.command("repair").auth().preload().action(async (options) => {
+    app.log.info("start repair data...");
+    const Collection = app.db.getCollection("collections");
+    if (Collection) {
+      await Collection.repository.setApp(app);
+      await Collection.repository.load();
+    }
+    await app.emitAsync("repair", options);
+  });
+}, "default");

package/lib/commands/start.js

@@ -61,7 +61,7 @@ var start_default = /* @__PURE__ */ __name((app) => {
       }
     } else if (options.quickstart) {
       if (await app.isInstalled()) {
-        await app.upgrade();
+        await app.upgrade({ quickstart: true });
       } else {
         await app.install();
       }

package/lib/event-queue.d.ts

@@ -23,6 +23,12 @@ export type QueueEventOptions = {
      */
     interval?: number;
     concurrency?: number;
+    /**
+     * Shared across multiple applications.
+     * Will not use app prefix for channel name.
+     * @experimental
+     */
+    shared?: boolean;
     idle(): boolean;
     process: QueueCallback;
 };
@@ -84,7 +90,7 @@ export declare class EventQueue {
     protected events: Map<string, QueueEventOptions>;
     get channelPrefix(): string;
     constructor(app: Application, options?: EventQueueOptions);
-    getFullChannel(channel: string): string;
+    getFullChannel(channel: string, shared?: boolean): string;
     setAdapter<A extends IEventQueueAdapter>(adapter: A): void;
     isConnected(): boolean;
     connect(): Promise<void>;

package/lib/event-queue.js

@@ -270,16 +270,14 @@ const _EventQueue = class _EventQueue {
   constructor(app, options = {}) {
     this.app = app;
     this.options = options;
-    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();
-      });
-    }
+    this.setAdapter(new MemoryEventQueueAdapter({ appName: this.app.name, logger: this.app.logger }));
+    app.on("afterStart", async () => {
+      await this.connect();
+    });
+    app.on("afterStop", async () => {
+      app.logger.info("[queue] gracefully shutting down...");
+      await this.close();
+    });
   }
   adapter;
   events = /* @__PURE__ */ new Map();
@@ -287,7 +285,10 @@ const _EventQueue = class _EventQueue {
     var _a;
     return (_a = this.options) == null ? void 0 : _a.channelPrefix;
   }
-  getFullChannel(channel) {
+  getFullChannel(channel, shared = false) {
+    if (shared) {
+      return [this.channelPrefix, channel].filter(Boolean).join(".");
+    }
     return [this.app.name, this.channelPrefix, channel].filter(Boolean).join(".");
   }
   setAdapter(adapter) {
@@ -303,14 +304,10 @@ 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);
+      this.adapter.subscribe(this.getFullChannel(channel, event.shared), event);
     }
   }
   async close() {
@@ -318,8 +315,8 @@ const _EventQueue = class _EventQueue {
       return;
     }
     await this.adapter.close();
-    for (const channel of this.events.keys()) {
-      this.adapter.unsubscribe(this.getFullChannel(channel));
+    for (const [channel, event] of this.events.entries()) {
+      this.adapter.unsubscribe(this.getFullChannel(channel, event.shared));
     }
   }
   subscribe(channel, options) {
@@ -329,16 +326,17 @@ const _EventQueue = class _EventQueue {
     }
     this.events.set(channel, options);
     if (this.isConnected()) {
-      this.adapter.subscribe(this.getFullChannel(channel), options);
+      this.adapter.subscribe(this.getFullChannel(channel, options.shared), this.events.get(channel));
     }
   }
   unsubscribe(channel) {
+    var _a;
     if (!this.events.has(channel)) {
       return;
     }
     this.events.delete(channel);
     if (this.isConnected()) {
-      this.adapter.unsubscribe(this.getFullChannel(channel));
+      this.adapter.unsubscribe(this.getFullChannel(channel, (_a = this.events.get(channel)) == null ? void 0 : _a.shared));
     }
   }
   async publish(channel, message, options = {}) {
@@ -348,7 +346,11 @@ const _EventQueue = class _EventQueue {
     if (!this.isConnected()) {
       throw new Error("event queue not connected, cannot publish");
     }
-    const c = this.getFullChannel(channel);
+    const event = this.events.get(channel);
+    if (!event) {
+      throw new Error(`event queue not subscribed on channel "${channel}", cannot publish`);
+    }
+    const c = this.getFullChannel(channel, event.shared);
     this.app.logger.debug(`event queue publishing to channel(${c})`, { message });
     await this.adapter.publish(c, message, {
       timeout: QUEUE_DEFAULT_ACK_TIMEOUT,