@nocobase/server 1.5.0-beta.1 → 1.6.0-alpha.2

package/lib/plugin-manager/plugin-manager.js

@@ -421,6 +421,37 @@ const _PluginManager = class _PluginManager {
       plugin.state.loaded = true;
       await this.app.emitAsync("afterLoadPlugin", plugin, options);
     }
+    const getSourceAndTargetForAddAction = /* @__PURE__ */ __name(async (ctx) => {
+      const { packageName } = ctx.action.params;
+      return {
+        targetCollection: "applicationPlugins",
+        targetRecordUK: packageName
+      };
+    }, "getSourceAndTargetForAddAction");
+    const getSourceAndTargetForUpdateAction = /* @__PURE__ */ __name(async (ctx) => {
+      let { packageName } = ctx.action.params;
+      if (ctx.file) {
+        packageName = ctx.request.body.packageName;
+      }
+      return {
+        targetCollection: "applicationPlugins",
+        targetRecordUK: packageName
+      };
+    }, "getSourceAndTargetForUpdateAction");
+    const getSourceAndTargetForOtherActions = /* @__PURE__ */ __name(async (ctx) => {
+      const { filterByTk } = ctx.action.params;
+      return {
+        targetCollection: "applicationPlugins",
+        targetRecordUK: filterByTk
+      };
+    }, "getSourceAndTargetForOtherActions");
+    this.app.auditManager.registerActions([
+      { name: "pm:add", getSourceAndTarget: getSourceAndTargetForAddAction },
+      { name: "pm:update", getSourceAndTarget: getSourceAndTargetForUpdateAction },
+      { name: "pm:enable", getSourceAndTarget: getSourceAndTargetForOtherActions },
+      { name: "pm:disable", getSourceAndTarget: getSourceAndTargetForOtherActions },
+      { name: "pm:remove", getSourceAndTarget: getSourceAndTargetForOtherActions }
+    ]);
     this.app.log.debug("plugins loaded");
     this.app.setMaintainingMessage("plugins loaded");
   }

package/lib/plugin.d.ts

@@ -6,12 +6,11 @@
  * 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 { Model } from '@nocobase/database';
+import { Model, Transactionable } from '@nocobase/database';
 import { LoggerOptions } from '@nocobase/logger';
 import type { TFuncKey, TOptions } from 'i18next';
 import { Application } from './application';
 import { InstallOptions } from './plugin-manager';
-import { SyncMessageData } from './sync-manager';
 export interface PluginInterface {
     beforeLoad?: () => void;
     load(): any;
@@ -66,16 +65,8 @@ export declare abstract class Plugin<O = any> implements PluginInterface {
     afterDisable(): Promise<void>;
     beforeRemove(): Promise<void>;
     afterRemove(): Promise<void>;
-    /**
-     * Fired when a sync message is received.
-     * @experimental
-     */
-    onSync(message?: SyncMessageData): Promise<void> | void;
-    /**
-     * Publish a sync message.
-     * @experimental
-     */
-    sync(message?: SyncMessageData): void;
+    handleSyncMessage(message: any): Promise<void>;
+    sendSyncMessage(message: any, options?: Transactionable): Promise<void>;
     /**
      * @deprecated
      */

package/lib/plugin.js

@@ -124,18 +124,13 @@ const _Plugin = class _Plugin {
   }
   async afterRemove() {
   }
-  /**
-   * Fired when a sync message is received.
-   * @experimental
-   */
-  onSync(message = {}) {
+  async handleSyncMessage(message) {
   }
-  /**
-   * Publish a sync message.
-   * @experimental
-   */
-  sync(message) {
-    this.app.syncManager.publish(this.name, message);
+  async sendSyncMessage(message, options) {
+    if (!this.name) {
+      throw new Error(`plugin name invalid`);
+    }
+    await this.app.syncMessageManager.publish(this.name, message, options);
   }
   /**
    * @deprecated

package/lib/pub-sub-manager/handler-manager.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { type PubSubManagerSubscribeOptions } from './types';
+export declare class HandlerManager {
+    protected publisherId: string;
+    handlers: Map<any, any>;
+    uniqueMessageHandlers: Map<any, any>;
+    constructor(publisherId: string);
+    protected getMessageHash(message: any): Promise<string>;
+    protected verifyMessage({ onlySelf, skipSelf, publisherId }: {
+        onlySelf: any;
+        skipSelf: any;
+        publisherId: any;
+    }): boolean;
+    protected debounce(func: any, wait: number): any;
+    handleMessage({ channel, message, callback, debounce }: {
+        channel: any;
+        message: any;
+        callback: any;
+        debounce: any;
+    }): Promise<void>;
+    wrapper(channel: any, callback: any, options: any): (wrappedMessage: any) => Promise<void>;
+    set(channel: string, callback: any, options: PubSubManagerSubscribeOptions): (wrappedMessage: any) => Promise<void>;
+    get(channel: string, callback: any): any;
+    delete(channel: string, callback: any): any;
+    reset(): void;
+    each(callback: any): Promise<void>;
+}

package/lib/pub-sub-manager/handler-manager.js

@@ -0,0 +1,149 @@
+/**
+ * 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 handler_manager_exports = {};
+__export(handler_manager_exports, {
+  HandlerManager: () => HandlerManager
+});
+module.exports = __toCommonJS(handler_manager_exports);
+var import_node_crypto = __toESM(require("node:crypto"));
+var import_lodash = __toESM(require("lodash"));
+const _HandlerManager = class _HandlerManager {
+  constructor(publisherId) {
+    this.publisherId = publisherId;
+    this.reset();
+  }
+  handlers;
+  uniqueMessageHandlers;
+  async getMessageHash(message) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(JSON.stringify(message));
+    const hashBuffer = await import_node_crypto.default.subtle.digest("SHA-256", data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+    return hashHex;
+  }
+  verifyMessage({ onlySelf, skipSelf, publisherId }) {
+    if (onlySelf && publisherId !== this.publisherId) {
+      return;
+    } else if (!onlySelf && skipSelf && publisherId === this.publisherId) {
+      return;
+    }
+    return true;
+  }
+  debounce(func, wait) {
+    if (wait) {
+      return import_lodash.default.debounce(func, wait);
+    }
+    return func;
+  }
+  async handleMessage({ channel, message, callback, debounce }) {
+    if (!debounce) {
+      await callback(message);
+      return;
+    }
+    const messageHash = channel + await this.getMessageHash(message);
+    if (!this.uniqueMessageHandlers.has(messageHash)) {
+      this.uniqueMessageHandlers.set(messageHash, this.debounce(callback, debounce));
+    }
+    const handler = this.uniqueMessageHandlers.get(messageHash);
+    try {
+      await handler(message);
+      setTimeout(() => {
+        this.uniqueMessageHandlers.delete(messageHash);
+      }, debounce);
+    } catch (error) {
+      this.uniqueMessageHandlers.delete(messageHash);
+      throw error;
+    }
+  }
+  wrapper(channel, callback, options) {
+    const { debounce = 0 } = options;
+    return async (wrappedMessage) => {
+      const json = JSON.parse(wrappedMessage);
+      if (!this.verifyMessage(json)) {
+        return;
+      }
+      await this.handleMessage({ channel, message: json.message, debounce, callback });
+    };
+  }
+  set(channel, callback, options) {
+    if (!this.handlers.has(channel)) {
+      this.handlers.set(channel, /* @__PURE__ */ new Map());
+    }
+    const headlerMap = this.handlers.get(channel);
+    const headler = this.wrapper(channel, callback, options);
+    headlerMap.set(callback, headler);
+    return headler;
+  }
+  get(channel, callback) {
+    const headlerMap = this.handlers.get(channel);
+    if (!headlerMap) {
+      return;
+    }
+    return headlerMap.get(callback);
+  }
+  delete(channel, callback) {
+    if (!callback) {
+      return;
+    }
+    const headlerMap = this.handlers.get(channel);
+    if (!headlerMap) {
+      return;
+    }
+    const headler = headlerMap.get(callback);
+    headlerMap.delete(callback);
+    return headler;
+  }
+  reset() {
+    this.handlers = /* @__PURE__ */ new Map();
+    this.uniqueMessageHandlers = /* @__PURE__ */ new Map();
+  }
+  async each(callback) {
+    for (const [channel, headlerMap] of this.handlers) {
+      for (const headler of headlerMap.values()) {
+        await callback(channel, headler);
+      }
+    }
+  }
+};
+__name(_HandlerManager, "HandlerManager");
+let HandlerManager = _HandlerManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HandlerManager
+});

package/lib/pub-sub-manager/index.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.
+ */
+export * from './handler-manager';
+export * from './pub-sub-manager';
+export * from './types';

package/lib/pub-sub-manager/index.js

@@ -0,0 +1,34 @@
+/**
+ * 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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pub_sub_manager_exports = {};
+module.exports = __toCommonJS(pub_sub_manager_exports);
+__reExport(pub_sub_manager_exports, require("./handler-manager"), module.exports);
+__reExport(pub_sub_manager_exports, require("./pub-sub-manager"), module.exports);
+__reExport(pub_sub_manager_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./handler-manager"),
+  ...require("./pub-sub-manager"),
+  ...require("./types")
+});

package/lib/pub-sub-manager/pub-sub-manager.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { HandlerManager } from './handler-manager';
+import { PubSubCallback, type IPubSubAdapter, type PubSubManagerOptions, type PubSubManagerPublishOptions, type PubSubManagerSubscribeOptions } from './types';
+export declare const createPubSubManager: (app: Application, options: PubSubManagerOptions) => PubSubManager;
+export declare class PubSubManager {
+    protected options: PubSubManagerOptions;
+    protected publisherId: string;
+    protected adapter: IPubSubAdapter;
+    protected handlerManager: HandlerManager;
+    constructor(options?: PubSubManagerOptions);
+    get channelPrefix(): string;
+    setAdapter(adapter: IPubSubAdapter): void;
+    isConnected(): Promise<boolean>;
+    connect(): Promise<void>;
+    close(): Promise<any>;
+    subscribe(channel: string, callback: PubSubCallback, options?: PubSubManagerSubscribeOptions): Promise<void>;
+    unsubscribe(channel: string, callback: PubSubCallback): Promise<any>;
+    publish(channel: string, message: any, options?: PubSubManagerPublishOptions): Promise<any>;
+}

package/lib/pub-sub-manager/pub-sub-manager.js

@@ -0,0 +1,116 @@
+/**
+ * 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 pub_sub_manager_exports = {};
+__export(pub_sub_manager_exports, {
+  PubSubManager: () => PubSubManager,
+  createPubSubManager: () => createPubSubManager
+});
+module.exports = __toCommonJS(pub_sub_manager_exports);
+var import_utils = require("@nocobase/utils");
+var import_handler_manager = require("./handler-manager");
+const createPubSubManager = /* @__PURE__ */ __name((app, options) => {
+  const pubSubManager = new PubSubManager(options);
+  app.on("afterStart", async () => {
+    await pubSubManager.connect();
+  });
+  app.on("afterStop", async () => {
+    await pubSubManager.close();
+  });
+  return pubSubManager;
+}, "createPubSubManager");
+const _PubSubManager = class _PubSubManager {
+  constructor(options = {}) {
+    this.options = options;
+    this.publisherId = (0, import_utils.uid)();
+    this.handlerManager = new import_handler_manager.HandlerManager(this.publisherId);
+  }
+  publisherId;
+  adapter;
+  handlerManager;
+  get channelPrefix() {
+    var _a;
+    return ((_a = this.options) == null ? void 0 : _a.channelPrefix) ? `${this.options.channelPrefix}.` : "";
+  }
+  setAdapter(adapter) {
+    this.adapter = adapter;
+  }
+  async isConnected() {
+    if (this.adapter) {
+      return this.adapter.isConnected();
+    }
+    return false;
+  }
+  async connect() {
+    if (!this.adapter) {
+      return;
+    }
+    await this.adapter.connect();
+    await this.handlerManager.each(async (channel, headler) => {
+      await this.adapter.subscribe(`${this.channelPrefix}${channel}`, headler);
+    });
+  }
+  async close() {
+    if (!this.adapter) {
+      return;
+    }
+    return await this.adapter.close();
+  }
+  async subscribe(channel, callback, options = {}) {
+    await this.unsubscribe(channel, callback);
+    const handler = this.handlerManager.set(channel, callback, options);
+    if (await this.isConnected()) {
+      await this.adapter.subscribe(`${this.channelPrefix}${channel}`, handler);
+    }
+  }
+  async unsubscribe(channel, callback) {
+    const handler = this.handlerManager.delete(channel, callback);
+    if (!this.adapter || !handler) {
+      return;
+    }
+    return this.adapter.unsubscribe(`${this.channelPrefix}${channel}`, handler);
+  }
+  async publish(channel, message, options) {
+    var _a;
+    if (!((_a = this.adapter) == null ? void 0 : _a.isConnected())) {
+      return;
+    }
+    const wrappedMessage = JSON.stringify({
+      publisherId: this.publisherId,
+      ...options,
+      message
+    });
+    return this.adapter.publish(`${this.channelPrefix}${channel}`, wrappedMessage);
+  }
+};
+__name(_PubSubManager, "PubSubManager");
+let PubSubManager = _PubSubManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PubSubManager,
+  createPubSubManager
+});

package/lib/pub-sub-manager/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ */
+export interface PubSubManagerOptions {
+    channelPrefix?: string;
+}
+export interface PubSubManagerPublishOptions {
+    skipSelf?: boolean;
+    onlySelf?: boolean;
+}
+export interface PubSubManagerSubscribeOptions {
+    debounce?: number;
+}
+export type PubSubCallback = (message: any) => Promise<void>;
+export interface IPubSubAdapter {
+    isConnected(): Promise<boolean> | boolean;
+    connect(): Promise<any>;
+    close(): Promise<any>;
+    subscribe(channel: string, callback: PubSubCallback): Promise<any>;
+    unsubscribe(channel: string, callback: PubSubCallback): Promise<any>;
+    publish(channel: string, message: string): Promise<any>;
+}

package/lib/pub-sub-manager/types.js

@@ -0,0 +1,24 @@
+/**
+ * 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 __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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/sync-message-manager.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 { Transactionable } from '@nocobase/database';
+import Application from './application';
+import { PubSubCallback, PubSubManager, PubSubManagerPublishOptions } from './pub-sub-manager';
+export declare class SyncMessageManager {
+    protected app: Application;
+    protected options: any;
+    protected versionManager: SyncMessageVersionManager;
+    protected pubSubManager: PubSubManager;
+    constructor(app: Application, options?: any);
+    get debounce(): any;
+    publish(channel: string, message: any, options?: PubSubManagerPublishOptions & Transactionable): Promise<any>;
+    subscribe(channel: string, callback: PubSubCallback): Promise<void>;
+    unsubscribe(channel: string, callback: PubSubCallback): Promise<any>;
+    sync(): Promise<void>;
+}
+export declare class SyncMessageVersionManager {
+}

package/lib/sync-message-manager.js

@@ -0,0 +1,105 @@
+/**
+ * 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 sync_message_manager_exports = {};
+__export(sync_message_manager_exports, {
+  SyncMessageManager: () => SyncMessageManager,
+  SyncMessageVersionManager: () => SyncMessageVersionManager
+});
+module.exports = __toCommonJS(sync_message_manager_exports);
+const _SyncMessageManager = class _SyncMessageManager {
+  constructor(app, options = {}) {
+    this.app = app;
+    this.options = options;
+    this.versionManager = new SyncMessageVersionManager();
+    app.on("beforeLoadPlugin", async (plugin) => {
+      if (!plugin.name) {
+        return;
+      }
+      await this.subscribe(plugin.name, plugin.handleSyncMessage.bind(plugin));
+    });
+  }
+  versionManager;
+  pubSubManager;
+  get debounce() {
+    return this.options.debounce || 1e3;
+  }
+  async publish(channel, message, options) {
+    const { transaction, ...others } = options || {};
+    if (transaction) {
+      return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          reject(
+            new Error(
+              `Publish message to ${channel} timeout, channel: ${channel}, message: ${JSON.stringify(message)}`
+            )
+          );
+        }, 5e4);
+        transaction.afterCommit(async () => {
+          try {
+            const r = await this.app.pubSubManager.publish(`${this.app.name}.sync.${channel}`, message, {
+              skipSelf: true,
+              ...others
+            });
+            resolve(r);
+          } catch (error) {
+            reject(error);
+          } finally {
+            clearTimeout(timer);
+          }
+        });
+      });
+    } else {
+      return await this.app.pubSubManager.publish(`${this.app.name}.sync.${channel}`, message, {
+        skipSelf: true,
+        ...options
+      });
+    }
+  }
+  async subscribe(channel, callback) {
+    return await this.app.pubSubManager.subscribe(`${this.app.name}.sync.${channel}`, callback, {
+      debounce: this.debounce
+    });
+  }
+  async unsubscribe(channel, callback) {
+    return this.app.pubSubManager.unsubscribe(`${this.app.name}.sync.${channel}`, callback);
+  }
+  async sync() {
+  }
+};
+__name(_SyncMessageManager, "SyncMessageManager");
+let SyncMessageManager = _SyncMessageManager;
+const _SyncMessageVersionManager = class _SyncMessageVersionManager {
+  // TODO
+};
+__name(_SyncMessageVersionManager, "SyncMessageVersionManager");
+let SyncMessageVersionManager = _SyncMessageVersionManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SyncMessageManager,
+  SyncMessageVersionManager
+});