@nocobase/server 1.8.0-beta.9 → 1.9.0-alpha.1

package/lib/application.d.ts

@@ -35,6 +35,8 @@ 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';
 export type PluginType = string | typeof Plugin;
 export type PluginConfiguration = PluginType | [PluginType, any];
 export interface ResourceManagerOptions {
@@ -55,6 +57,7 @@ export interface AppTelemetryOptions extends TelemetryOptions {
     enabled?: boolean;
 }
 export interface ApplicationOptions {
+    instanceId?: string;
     database?: IDatabaseOptions | Database;
     cacheManager?: CacheManagerOptions;
     /**
@@ -82,6 +85,8 @@ export interface ApplicationOptions {
     authManager?: AuthManagerOptions;
     auditManager?: AuditManager;
     lockManager?: LockManagerOptions;
+    eventQueue?: EventQueueOptions;
+    backgroundJobManager?: BackgroundJobManagerOptions;
     /**
      * @internal
      */
@@ -128,6 +133,7 @@ export type MaintainingCommandStatus = {
 };
 export declare class Application<StateT = DefaultState, ContextT = DefaultContext> extends Koa implements AsyncEmitter {
     options: ApplicationOptions;
+    readonly instanceId: string;
     /**
      * @internal
      */
@@ -174,6 +180,8 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     private _actionCommand;
     container: ServiceContainer;
     lockManager: LockManager;
+    eventQueue: EventQueue;
+    backgroundJobManager: BackgroundJobManager;
     constructor(options: ApplicationOptions);
     private static staticCommands;
     static addCommand(callback: (app: Application) => void): void;
@@ -246,6 +254,11 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     get dataSourceManager(): DataSourceManager;
     protected _aesEncryptor: AesEncryptor;
     get aesEncryptor(): AesEncryptor;
+    /**
+     * Check if the application is serving as a specific worker.
+     * @experimental
+     */
+    serving(key?: string): boolean;
     /**
      * @internal
      */

package/lib/application.js

@@ -56,6 +56,7 @@ 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");
@@ -81,10 +82,13 @@ 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");
 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();
@@ -92,6 +96,7 @@ const _Application = class _Application extends import_koa.default {
       this._appSupervisor.addApp(this);
     }
   }
+  instanceId;
   /**
    * @internal
    */
@@ -131,6 +136,8 @@ const _Application = class _Application extends import_koa.default {
   _actionCommand;
   container = new import_service_container.ServiceContainer();
   lockManager;
+  eventQueue;
+  backgroundJobManager;
   static addCommand(callback) {
     this.staticCommands.push(callback);
   }
@@ -263,6 +270,31 @@ const _Application = class _Application extends import_koa.default {
   get aesEncryptor() {
     return this._aesEncryptor;
   }
+  /**
+   * Check if the application is serving as a specific worker.
+   * @experimental
+   */
+  serving(key) {
+    const { WORKER_MODE = "" } = process.env;
+    if (!WORKER_MODE) {
+      return true;
+    }
+    const topics = WORKER_MODE.trim().split(",");
+    if (key) {
+      if (WORKER_MODE === "*") {
+        return true;
+      }
+      if (topics.includes(key)) {
+        return true;
+      }
+      return false;
+    } else {
+      if (topics.includes("!")) {
+        return true;
+      }
+      return false;
+    }
+  }
   /**
    * @internal
    */
@@ -855,6 +887,8 @@ const _Application = class _Application extends import_koa.default {
     this._i18n = (0, import_helper.createI18n)(options);
     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

package/lib/background-job-manager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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';
+import { QueueEventOptions, QueueMessageOptions } from './event-queue';
+export interface BackgroundJobManagerOptions {
+    channel?: string;
+}
+type BackgroundJobEventOptions = Pick<QueueEventOptions, 'process' | 'idle'>;
+declare class BackgroundJobManager {
+    private app;
+    private options;
+    static DEFAULT_CHANNEL: string;
+    private subscriptions;
+    private processing;
+    private get channel();
+    private onAfterStart;
+    private onBeforeStop;
+    private process;
+    constructor(app: Application, options?: BackgroundJobManagerOptions);
+    private get idle();
+    /**
+     * 订阅指定主题的任务处理器
+     * @param options 订阅选项
+     */
+    subscribe(topic: string, options: BackgroundJobEventOptions): void;
+    /**
+     * 取消订阅指定主题
+     * @param topic 主题名称
+     */
+    unsubscribe(topic: string): void;
+    publish(topic: string, payload: any, options?: QueueMessageOptions): Promise<void>;
+}
+export { BackgroundJobManager };
+export default BackgroundJobManager;

package/lib/background-job-manager.js

@@ -0,0 +1,111 @@
+/**
+ * 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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var background_job_manager_exports = {};
+__export(background_job_manager_exports, {
+  BackgroundJobManager: () => BackgroundJobManager,
+  default: () => background_job_manager_default
+});
+module.exports = __toCommonJS(background_job_manager_exports);
+const _BackgroundJobManager = class _BackgroundJobManager {
+  constructor(app, options = {}) {
+    this.app = app;
+    this.options = options;
+    this.app.on("afterStart", this.onAfterStart);
+    this.app.on("beforeStop", this.onBeforeStop);
+  }
+  subscriptions = /* @__PURE__ */ new Map();
+  // topic -> handler
+  processing = null;
+  get channel() {
+    return this.options.channel ?? _BackgroundJobManager.DEFAULT_CHANNEL;
+  }
+  onAfterStart = /* @__PURE__ */ __name(() => {
+    this.app.eventQueue.subscribe(this.channel, {
+      idle: /* @__PURE__ */ __name(() => this.idle, "idle"),
+      process: this.process
+    });
+  }, "onAfterStart");
+  onBeforeStop = /* @__PURE__ */ __name(() => {
+    this.app.eventQueue.unsubscribe(this.channel);
+  }, "onBeforeStop");
+  process = /* @__PURE__ */ __name(async ({ topic, payload }, options) => {
+    const event = this.subscriptions.get(topic);
+    if (!event) {
+      this.app.logger.warn(`No handler found for topic: ${topic}, event skipped.`);
+      return;
+    }
+    this.processing = event.process(payload, options);
+    try {
+      await this.processing;
+      this.app.logger.debug(`Completed background job ${topic}:${options.id}`);
+    } catch (error) {
+      this.app.logger.error(`Failed to process background job ${topic}:${options.id}`, error);
+      throw error;
+    } finally {
+      this.processing = null;
+    }
+  }, "process");
+  get idle() {
+    return !this.processing && [...this.subscriptions.values()].every((event) => event.idle());
+  }
+  /**
+   * 订阅指定主题的任务处理器
+   * @param options 订阅选项
+   */
+  subscribe(topic, options) {
+    if (this.subscriptions.has(topic)) {
+      this.app.logger.warn(`Topic "${topic}" already has a handler, skip...`);
+      return;
+    }
+    this.subscriptions.set(topic, options);
+    this.app.logger.debug(`Subscribed to background job topic: ${topic}`);
+  }
+  /**
+   * 取消订阅指定主题
+   * @param topic 主题名称
+   */
+  unsubscribe(topic) {
+    if (this.subscriptions.has(topic)) {
+      this.subscriptions.delete(topic);
+      this.app.logger.debug(`Unsubscribed from background job topic: ${topic}`);
+    }
+  }
+  async publish(topic, payload, options) {
+    await this.app.eventQueue.publish(this.channel, { topic, payload }, options);
+  }
+};
+__name(_BackgroundJobManager, "BackgroundJobManager");
+__publicField(_BackgroundJobManager, "DEFAULT_CHANNEL", "background-jobs");
+let BackgroundJobManager = _BackgroundJobManager;
+var background_job_manager_default = BackgroundJobManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BackgroundJobManager
+});

package/lib/event-queue.d.ts

@@ -0,0 +1,94 @@
+/**
+ * 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';
+export declare const QUEUE_DEFAULT_INTERVAL = 250;
+export declare const QUEUE_DEFAULT_CONCURRENCY = 1;
+export declare const QUEUE_DEFAULT_ACK_TIMEOUT = 15000;
+export type QueueCallbackOptions = {
+    id?: string;
+    retried?: number;
+    signal?: AbortSignal;
+};
+export type QueueCallback = (message: any, options: QueueCallbackOptions) => Promise<void> | void;
+export type QueueEventOptions = {
+    /**
+     * @experimental
+     */
+    interval?: number;
+    concurrency?: number;
+    idle(): boolean;
+    process: QueueCallback;
+};
+export type QueueMessageOptions = {
+    timeout?: number;
+    maxRetries?: number;
+    retried?: number;
+    timestamp?: number;
+};
+export interface IEventQueueAdapter {
+    isConnected(): boolean;
+    connect(): Promise<void> | void;
+    close(): Promise<void> | void;
+    subscribe(channel: string, event: QueueEventOptions): void;
+    unsubscribe(channel: string): void;
+    publish(channel: string, message: any, options: QueueMessageOptions): Promise<void> | void;
+}
+export interface EventQueueOptions {
+    channelPrefix?: string;
+}
+export declare class MemoryEventQueueAdapter implements IEventQueueAdapter {
+    private options;
+    private connected;
+    private emitter;
+    private reading;
+    protected events: Map<string, QueueEventOptions>;
+    protected queues: Map<string, {
+        id: string;
+        content: any;
+        options?: QueueMessageOptions;
+    }[]>;
+    get processing(): Promise<void[]>;
+    private get storagePath();
+    listen: (channel: string) => Promise<void>;
+    constructor(options: {
+        appName: string;
+    });
+    isConnected(): boolean;
+    setConnected(connected: boolean): void;
+    loadFromStorage(): Promise<void>;
+    private saveToStorage;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    subscribe(channel: string, options: QueueEventOptions): void;
+    unsubscribe(channel: string): void;
+    publish(channel: string, content: any, options?: QueueMessageOptions): void;
+    consume(channel: string, once?: boolean): Promise<void>;
+    read(channel: string): Promise<void>;
+    process(channel: string, { id, message }: {
+        id: any;
+        message: any;
+    }): Promise<void>;
+}
+export declare class EventQueue {
+    protected app: Application;
+    protected options: EventQueueOptions;
+    protected adapter: IEventQueueAdapter;
+    protected events: Map<string, QueueEventOptions>;
+    get channelPrefix(): string;
+    constructor(app: Application, options?: EventQueueOptions);
+    getFullChannel(channel: string): string;
+    setAdapter<A extends IEventQueueAdapter>(adapter: A): void;
+    isConnected(): boolean;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    subscribe(channel: string, options: QueueEventOptions): void;
+    unsubscribe(channel: string): void;
+    publish(channel: string, message: any, options?: QueueMessageOptions): Promise<void>;
+}
+export default EventQueue;

package/lib/event-queue.js

@@ -0,0 +1,350 @@
+/**
+ * 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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var event_queue_exports = {};
+__export(event_queue_exports, {
+  EventQueue: () => EventQueue,
+  MemoryEventQueueAdapter: () => MemoryEventQueueAdapter,
+  QUEUE_DEFAULT_ACK_TIMEOUT: () => QUEUE_DEFAULT_ACK_TIMEOUT,
+  QUEUE_DEFAULT_CONCURRENCY: () => QUEUE_DEFAULT_CONCURRENCY,
+  QUEUE_DEFAULT_INTERVAL: () => QUEUE_DEFAULT_INTERVAL,
+  default: () => event_queue_default
+});
+module.exports = __toCommonJS(event_queue_exports);
+var import_crypto = require("crypto");
+var import_events = require("events");
+var import_path = __toESM(require("path"));
+var import_promises = __toESM(require("fs/promises"));
+var import_utils = require("@nocobase/utils");
+const QUEUE_DEFAULT_INTERVAL = 250;
+const QUEUE_DEFAULT_CONCURRENCY = 1;
+const QUEUE_DEFAULT_ACK_TIMEOUT = 15e3;
+const _MemoryEventQueueAdapter = class _MemoryEventQueueAdapter {
+  constructor(options) {
+    this.options = options;
+    this.emitter.setMaxListeners(0);
+  }
+  connected = false;
+  emitter = new import_events.EventEmitter();
+  reading = /* @__PURE__ */ new Map();
+  events = /* @__PURE__ */ new Map();
+  queues = /* @__PURE__ */ new Map();
+  get processing() {
+    const processing = Array.from(this.reading.values());
+    if (processing.length > 0) {
+      return Promise.all(processing);
+    }
+    return null;
+  }
+  get storagePath() {
+    return import_path.default.resolve(process.cwd(), "storage", "apps", this.options.appName, "event-queue.json");
+  }
+  listen = /* @__PURE__ */ __name(async (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 event = this.events.get(channel);
+    if (!event) {
+      console.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);
+    this.reading.set(channel, reading);
+    await reading;
+  }, "listen");
+  isConnected() {
+    return this.connected;
+  }
+  setConnected(connected) {
+    this.connected = connected;
+  }
+  async loadFromStorage() {
+    let queues = {};
+    let exists = false;
+    try {
+      await import_promises.default.stat(this.storagePath);
+      exists = true;
+    } catch (ex) {
+      console.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);
+        await import_promises.default.unlink(this.storagePath);
+      } catch (ex) {
+        console.error("failed to load queue from storage", ex);
+      }
+    }
+    this.queues = new Map(Object.entries(queues));
+  }
+  async saveToStorage() {
+    const queues = Array.from(this.queues.entries()).reduce((acc, [channel, queue]) => {
+      if (queue == null ? void 0 : queue.length) {
+        acc[channel] = queue;
+      }
+      return acc;
+    }, {});
+    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);
+    } else {
+      console.debug("memory queue empty, no need to save to storage");
+    }
+  }
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    await this.loadFromStorage();
+    this.connected = true;
+    setImmediate(() => {
+      for (const channel of this.events.keys()) {
+        this.consume(channel);
+      }
+    });
+  }
+  async close() {
+    this.connected = false;
+    if (this.processing) {
+      console.info("memory queue waiting for processing job...");
+      await this.processing;
+      console.info("memory queue job cleaned");
+    }
+    console.log("memory queue gracefully shutting down...");
+    await this.saveToStorage();
+  }
+  subscribe(channel, options) {
+    if (this.events.has(channel)) {
+      return;
+    }
+    this.events.set(channel, options);
+    if (!this.queues.has(channel)) {
+      this.queues.set(channel, []);
+    }
+    this.emitter.on(channel, this.listen);
+    if (this.connected) {
+      this.consume(channel);
+    }
+  }
+  unsubscribe(channel) {
+    if (!this.events.has(channel)) {
+      return;
+    }
+    this.events.delete(channel);
+    this.emitter.off(channel, this.listen);
+  }
+  publish(channel, content, options = { timestamp: Date.now() }) {
+    const event = this.events.get(channel);
+    if (!event) {
+      return;
+    }
+    if (!this.queues.get(channel)) {
+      this.queues.set(channel, []);
+    }
+    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);
+    setImmediate(() => {
+      this.emitter.emit(channel, channel);
+    });
+  }
+  async consume(channel, once = false) {
+    while (this.connected && this.events.get(channel)) {
+      const event = this.events.get(channel);
+      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);
+      }
+      if (once) {
+        break;
+      }
+      await (0, import_utils.sleep)(interval);
+    }
+  }
+  async read(channel) {
+    const event = this.events.get(channel);
+    if (!event) {
+      this.reading.delete(channel);
+      return;
+    }
+    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);
+  }
+  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) {
+      if (maxRetries > 0 && retried < maxRetries) {
+        const currentRetry = retried + 1;
+        console.warn(
+          `memory queue (${channel}) consum message (${id}) failed, retrying (${currentRetry} / ${maxRetries})...`,
+          ex
+        );
+        setImmediate(() => {
+          this.publish(channel, content, { timeout, maxRetries, retried: currentRetry, timestamp: Date.now() });
+        });
+      } else {
+        console.error(ex);
+      }
+    }
+  }
+};
+__name(_MemoryEventQueueAdapter, "MemoryEventQueueAdapter");
+let MemoryEventQueueAdapter = _MemoryEventQueueAdapter;
+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();
+    });
+  }
+  adapter;
+  events = /* @__PURE__ */ new Map();
+  get channelPrefix() {
+    var _a;
+    return (_a = this.options) == null ? void 0 : _a.channelPrefix;
+  }
+  getFullChannel(channel) {
+    return [this.app.name, this.channelPrefix, channel].filter(Boolean).join(".");
+  }
+  setAdapter(adapter) {
+    this.adapter = adapter;
+  }
+  isConnected() {
+    if (!this.adapter) {
+      return false;
+    }
+    return this.adapter.isConnected();
+  }
+  async connect() {
+    if (!this.adapter) {
+      throw new Error("no adapter set, cannot connect");
+    }
+    await this.adapter.connect();
+    for (const [channel, event] of this.events.entries()) {
+      this.adapter.subscribe(this.getFullChannel(channel), event);
+    }
+  }
+  async close() {
+    if (!this.adapter) {
+      return;
+    }
+    await this.adapter.close();
+    for (const channel of this.events.keys()) {
+      this.adapter.unsubscribe(this.getFullChannel(channel));
+    }
+  }
+  subscribe(channel, options) {
+    if (this.events.has(channel)) {
+      this.app.logger.warn(`event queue already subscribed on channel "${channel}", new subscription will be ignored`);
+      return;
+    }
+    this.events.set(channel, options);
+    if (this.isConnected()) {
+      this.adapter.subscribe(this.getFullChannel(channel), options);
+    }
+  }
+  unsubscribe(channel) {
+    if (!this.events.has(channel)) {
+      return;
+    }
+    this.events.delete(channel);
+    if (this.isConnected()) {
+      this.adapter.unsubscribe(this.getFullChannel(channel));
+    }
+  }
+  async publish(channel, message, options = {}) {
+    if (!this.adapter) {
+      throw new Error("no adapter set, cannot publish");
+    }
+    if (!this.isConnected()) {
+      throw new Error("event queue not connected, cannot publish");
+    }
+    const c = this.getFullChannel(channel);
+    this.app.logger.debug("event queue publishing:", { channel: c, message });
+    await this.adapter.publish(c, message, {
+      timeout: QUEUE_DEFAULT_ACK_TIMEOUT,
+      ...options,
+      timestamp: Date.now()
+    });
+  }
+};
+__name(_EventQueue, "EventQueue");
+let EventQueue = _EventQueue;
+var event_queue_default = EventQueue;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventQueue,
+  MemoryEventQueueAdapter,
+  QUEUE_DEFAULT_ACK_TIMEOUT,
+  QUEUE_DEFAULT_CONCURRENCY,
+  QUEUE_DEFAULT_INTERVAL
+});

package/lib/index.d.ts

@@ -17,6 +17,8 @@ export * from './migration';
 export * from './plugin';
 export * from './plugin-manager';
 export * from './pub-sub-manager';
+export * from './event-queue';
+export * from './background-job-manager';
 export declare const OFFICIAL_PLUGIN_PREFIX = "@nocobase/plugin-";
 export { appendToBuiltInPlugins, findAllPlugins, findBuiltInPlugins, findLocalPlugins, packageNameTrim, } from './plugin-manager/findPackageNames';
 export { runPluginStaticImports } from './run-plugin-static-imports';

package/lib/index.js

@@ -59,6 +59,8 @@ __reExport(src_exports, require("./migration"), module.exports);
 __reExport(src_exports, require("./plugin"), module.exports);
 __reExport(src_exports, require("./plugin-manager"), module.exports);
 __reExport(src_exports, require("./pub-sub-manager"), module.exports);
+__reExport(src_exports, require("./event-queue"), module.exports);
+__reExport(src_exports, require("./background-job-manager"), module.exports);
 var import_findPackageNames = require("./plugin-manager/findPackageNames");
 var import_run_plugin_static_imports = require("./run-plugin-static-imports");
 const OFFICIAL_PLUGIN_PREFIX = "@nocobase/plugin-";
@@ -80,5 +82,7 @@ const OFFICIAL_PLUGIN_PREFIX = "@nocobase/plugin-";
   ...require("./migration"),
   ...require("./plugin"),
   ...require("./plugin-manager"),
-  ...require("./pub-sub-manager")
+  ...require("./pub-sub-manager"),
+  ...require("./event-queue"),
+  ...require("./background-job-manager")
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/server",
-  "version": "1.8.0-beta.9",
+  "version": "1.9.0-alpha.1",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "AGPL-3.0",
@@ -10,19 +10,19 @@
     "@koa/cors": "^5.0.0",
     "@koa/multer": "^3.1.0",
     "@koa/router": "^13.1.0",
-    "@nocobase/acl": "1.8.0-beta.9",
-    "@nocobase/actions": "1.8.0-beta.9",
-    "@nocobase/auth": "1.8.0-beta.9",
-    "@nocobase/cache": "1.8.0-beta.9",
-    "@nocobase/data-source-manager": "1.8.0-beta.9",
-    "@nocobase/database": "1.8.0-beta.9",
-    "@nocobase/evaluators": "1.8.0-beta.9",
-    "@nocobase/lock-manager": "1.8.0-beta.9",
-    "@nocobase/logger": "1.8.0-beta.9",
-    "@nocobase/resourcer": "1.8.0-beta.9",
-    "@nocobase/sdk": "1.8.0-beta.9",
-    "@nocobase/telemetry": "1.8.0-beta.9",
-    "@nocobase/utils": "1.8.0-beta.9",
+    "@nocobase/acl": "1.9.0-alpha.1",
+    "@nocobase/actions": "1.9.0-alpha.1",
+    "@nocobase/auth": "1.9.0-alpha.1",
+    "@nocobase/cache": "1.9.0-alpha.1",
+    "@nocobase/data-source-manager": "1.9.0-alpha.1",
+    "@nocobase/database": "1.9.0-alpha.1",
+    "@nocobase/evaluators": "1.9.0-alpha.1",
+    "@nocobase/lock-manager": "1.9.0-alpha.1",
+    "@nocobase/logger": "1.9.0-alpha.1",
+    "@nocobase/resourcer": "1.9.0-alpha.1",
+    "@nocobase/sdk": "1.9.0-alpha.1",
+    "@nocobase/telemetry": "1.9.0-alpha.1",
+    "@nocobase/utils": "1.9.0-alpha.1",
     "@types/decompress": "4.2.7",
     "@types/ini": "^1.3.31",
     "@types/koa-send": "^4.1.3",
@@ -57,5 +57,5 @@
     "@types/serve-handler": "^6.1.1",
     "@types/ws": "^8.5.5"
   },
-  "gitHead": "a3449d646c72965845f8c52e52fff9dba759c564"
+  "gitHead": "71ebde8a27da3c5c4d64194571804eeab6e95ce0"
 }