@tego/core 1.3.44

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

@@ -0,0 +1,149 @@
+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();
+  }
+  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,
+    callbackCaller
+  }) {
+    if (!debounce) {
+      await callback.bind(callbackCaller)(message);
+      return;
+    }
+    const messageHash = channel + await this.getMessageHash(message);
+    if (!this.uniqueMessageHandlers.has(messageHash)) {
+      this.uniqueMessageHandlers.set(messageHash, this.debounce(callback.bind(callbackCaller), 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, callbackCaller } = options;
+    return async (wrappedMessage) => {
+      let json;
+      if (this.adapterType !== "MemoryPubSubAdapter") {
+        json = JSON.parse(wrappedMessage);
+      } else {
+        json = wrappedMessage;
+      }
+      if (!this.verifyMessage(json)) {
+        return;
+      }
+      await this.handleMessage({ channel, message: json.message, debounce, callback, callbackCaller });
+    };
+  }
+  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,3 @@
+export * from './handler-manager';
+export * from './pub-sub-manager';
+export * from './types';

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

@@ -0,0 +1,25 @@
+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/memory-pub-sub-adapter.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from 'node:events';
+import { IPubSubAdapter } from './types';
+declare class TestEventEmitter extends EventEmitter {
+    emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
+}
+export declare class MemoryPubSubAdapter implements IPubSubAdapter {
+    protected options: any;
+    protected emitter: TestEventEmitter;
+    connected: boolean;
+    static instances: Map<string, MemoryPubSubAdapter>;
+    static create(name?: string, options?: any): MemoryPubSubAdapter;
+    constructor(options?: any);
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    isConnected(): Promise<boolean>;
+    subscribe(channel: any, callback: any): Promise<void>;
+    unsubscribe(channel: any, callback: any): Promise<void>;
+    publish(channel: any, message: any): Promise<void>;
+    subscribeAll(callback: any): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,82 @@
+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 memory_pub_sub_adapter_exports = {};
+__export(memory_pub_sub_adapter_exports, {
+  MemoryPubSubAdapter: () => MemoryPubSubAdapter
+});
+module.exports = __toCommonJS(memory_pub_sub_adapter_exports);
+var import_node_events = require("node:events");
+var import_utils = require("@tachybase/utils");
+const sleep = /* @__PURE__ */ __name((ms) => new Promise((resolve) => setTimeout(resolve, ms)), "sleep");
+const _TestEventEmitter = class _TestEventEmitter extends import_node_events.EventEmitter {
+};
+__name(_TestEventEmitter, "TestEventEmitter");
+let TestEventEmitter = _TestEventEmitter;
+(0, import_utils.applyMixins)(TestEventEmitter, [import_utils.AsyncEmitter]);
+const _MemoryPubSubAdapter = class _MemoryPubSubAdapter {
+  constructor(options = {}) {
+    this.options = options;
+    this.connected = false;
+    this.emitter = new TestEventEmitter();
+  }
+  static create(name, options) {
+    if (!name) {
+      name = (0, import_utils.uid)();
+    }
+    if (!this.instances.has(name)) {
+      this.instances.set(name, new _MemoryPubSubAdapter(options));
+    }
+    return this.instances.get(name);
+  }
+  async connect() {
+    this.connected = true;
+  }
+  async close() {
+    this.connected = false;
+  }
+  async isConnected() {
+    return this.connected;
+  }
+  async subscribe(channel, callback) {
+    this.emitter.on(channel, callback);
+  }
+  async unsubscribe(channel, callback) {
+    this.emitter.off(channel, callback);
+  }
+  async publish(channel, message) {
+    if (!this.connected) {
+      return;
+    }
+    await this.emitter.emitAsync(channel, message);
+    await this.emitter.emitAsync("__publish__", channel, message);
+    if (this.options.debounce) {
+      await sleep(Number(this.options.debounce));
+    }
+  }
+  async subscribeAll(callback) {
+    this.emitter.on("__publish__", callback);
+  }
+};
+__name(_MemoryPubSubAdapter, "MemoryPubSubAdapter");
+_MemoryPubSubAdapter.instances = /* @__PURE__ */ new Map();
+let MemoryPubSubAdapter = _MemoryPubSubAdapter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryPubSubAdapter
+});

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

@@ -0,0 +1,19 @@
+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;
+    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,108 @@
+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("@tachybase/utils");
+var import_handler_manager = require("./handler-manager");
+var import_memory_pub_sub_adapter = require("./memory-pub-sub-adapter");
+const createPubSubManager = /* @__PURE__ */ __name((app, options) => {
+  const pubSubManager = new PubSubManager(options);
+  pubSubManager.setAdapter(import_memory_pub_sub_adapter.MemoryPubSubAdapter.create());
+  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);
+  }
+  get channelPrefix() {
+    var _a;
+    return ((_a = this.options) == null ? void 0 : _a.channelPrefix) ? `${this.options.channelPrefix}.` : "";
+  }
+  setAdapter(adapter) {
+    this.adapter = adapter;
+    this.handlerManager.adapterType = adapter.constructor.name;
+  }
+  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 messageRow = {
+      publisherId: this.publisherId,
+      ...options,
+      message
+    };
+    const wrappedMessage = this.adapter.constructor.name === "MemoryPubSubAdapter" ? messageRow : JSON.stringify(messageRow);
+    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,20 @@
+export interface PubSubManagerOptions {
+    channelPrefix?: string;
+}
+export interface PubSubManagerPublishOptions {
+    skipSelf?: boolean;
+    onlySelf?: boolean;
+}
+export interface PubSubManagerSubscribeOptions {
+    debounce?: number;
+    callbackCaller?: any;
+}
+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 | object): Promise<any>;
+}

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

@@ -0,0 +1,15 @@
+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,16 @@
+import { Transactionable } from '@tachybase/database';
+import Application from './application';
+import { PubSubCallback, PubSubManagerPublishOptions } from './pub-sub-manager';
+export declare class SyncMessageManager {
+    protected app: Application;
+    protected options: any;
+    protected versionManager: SyncMessageVersionManager;
+    constructor(app: Application, options?: any);
+    get debounce(): any;
+    publish(channel: string, message: any, options?: PubSubManagerPublishOptions & Transactionable): Promise<any>;
+    subscribe(channel: string, callback: PubSubCallback, callbackCaller: any): 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,112 @@
+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 {
+  // protected pubSubManager: PubSubManager;
+  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, plugin);
+    });
+    app.on("beforeStop", async () => {
+      const promises = [];
+      for (const [P, plugin] of app.pm.getPlugins()) {
+        if (!plugin.name) {
+          continue;
+        }
+        promises.push(this.unsubscribe(plugin.name, plugin.handleSyncMessage));
+      }
+      await Promise.all(promises);
+    });
+  }
+  get debounce() {
+    let defaultDebounce;
+    if (this.app.pubSubManager.adapter.constructor.name === "MemoryPubSubAdapter") {
+      defaultDebounce = 0;
+    } else {
+      defaultDebounce = 1e3;
+    }
+    return this.options.debounce || defaultDebounce;
+  }
+  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, callbackCaller) {
+    return await this.app.pubSubManager.subscribe(`${this.app.name}.sync.${channel}`, callback, {
+      debounce: this.debounce,
+      callbackCaller
+    });
+  }
+  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
+});

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@tego/core",
+  "version": "1.3.44",
+  "license": "Apache-2.0",
+  "main": "lib/index.js",
+  "types": "./lib/index.d.ts",
+  "dependencies": {
+    "@koa/cors": "^5.0.0",
+    "@types/decompress": "4.2.7",
+    "@types/ini": "^1.3.34",
+    "async-mutex": "^0.5.0",
+    "axios": "0.29.0",
+    "commander": "^9.5.0",
+    "compression": "^1.7.5",
+    "dayjs": "1.11.13",
+    "decompress": "4.2.1",
+    "execa": "^5.1.1",
+    "fast-glob": "^3.3.2",
+    "fs-extra": "^11.3.0",
+    "glob": "11.0.0",
+    "i18next": "23.16.8",
+    "ini": "^4.1.3",
+    "koa": "^2.15.3",
+    "koa-bodyparser": "^4.4.1",
+    "koa-compose": "^4.1.0",
+    "lodash": "^4.17.21",
+    "nanoid": "3.3.8",
+    "qs": "^6.14.0",
+    "semver": "7.7.2",
+    "serve-handler": "^6.1.6",
+    "winston": "^3.17.0",
+    "ws": "^8.18.0",
+    "xpipe": "^1.0.8",
+    "@tachybase/acl": "1.3.44",
+    "@tachybase/auth": "1.3.44",
+    "@tachybase/actions": "1.3.44",
+    "@tachybase/database": "1.3.44",
+    "@tachybase/data-source": "1.3.44",
+    "@tachybase/cache": "1.3.44",
+    "@tachybase/di": "1.3.44",
+    "@tachybase/globals": "1.3.44",
+    "@tachybase/resourcer": "1.3.44",
+    "@tachybase/logger": "1.3.44",
+    "@tachybase/utils": "1.3.44"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "11.0.4",
+    "@types/koa": "^2.15.0",
+    "@types/koa__cors": "^5.0.0",
+    "@types/koa-bodyparser": "^4.3.12",
+    "@types/koa-compose": "3.2.8",
+    "@types/lodash": "4.17.20",
+    "@types/qs": "^6.14.0",
+    "@types/semver": "^7.5.8",
+    "@types/serve-handler": "^6.1.4",
+    "@types/ws": "^8.5.13"
+  }
+}