@tego/core 1.3.44

package/lib/application.js

@@ -0,0 +1,878 @@
+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 application_exports = {};
+__export(application_exports, {
+  Application: () => Application,
+  Logger: () => import_winston.Logger,
+  default: () => application_default
+});
+module.exports = __toCommonJS(application_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_path = require("node:path");
+var import_actions = require("@tachybase/actions");
+var import_auth = require("@tachybase/auth");
+var import_data_source = require("@tachybase/data-source");
+var import_database = __toESM(require("@tachybase/database"));
+var import_logger = require("@tachybase/logger");
+var import_utils = require("@tachybase/utils");
+var import_commander = require("commander");
+var import_glob = 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_semver = __toESM(require("semver"));
+var import_package = __toESM(require("../package.json"));
+var import_acl = require("./acl");
+var import_aes_encryptor = __toESM(require("./aes-encryptor"));
+var import_app_command = require("./app-command");
+var import_app_supervisor = require("./app-supervisor");
+var import_cache2 = require("./cache");
+var import_commands = require("./commands");
+var import_cron_job_manager = require("./cron/cron-job-manager");
+var import_environment = require("./environment");
+var import_application_not_install = require("./errors/application-not-install");
+var import_gateway = require("./gateway");
+var import_helper = require("./helper");
+var import_application_version = require("./helpers/application-version");
+var import_locale = require("./locale");
+var import_main_data_source = require("./main-data-source");
+var import_middlewares = require("./middlewares");
+var import_data_template = require("./middlewares/data-template");
+var import_notice = require("./notice");
+var import_plugin_manager = require("./plugin-manager");
+var import_pub_sub_manager = require("./pub-sub-manager");
+var import_sync_message_manager = require("./sync-message-manager");
+var import_winston = require("winston");
+const _Application = class _Application extends import_koa.default {
+  constructor(options) {
+    super();
+    this.options = options;
+    /**
+     * @internal
+     */
+    this.stopped = false;
+    /**
+     * @internal
+     */
+    this.ready = false;
+    /**
+     * @internal
+     */
+    this.activatedCommand = null;
+    /**
+     * @internal
+     */
+    this.running = false;
+    /**
+     * @internal
+     */
+    this.perfHistograms = /* @__PURE__ */ new Map();
+    this.plugins = /* @__PURE__ */ new Map();
+    this._appSupervisor = import_app_supervisor.AppSupervisor.getInstance();
+    this._authenticated = false;
+    this._maintaining = false;
+    this.currentId = (0, import_nanoid.nanoid)();
+    this.modules = {};
+    this.middlewareSourceMap = /* @__PURE__ */ new WeakMap();
+    // WebSocket 事件处理器集合
+    this.wsEventHandlers = {
+      close: /* @__PURE__ */ new Set(),
+      error: /* @__PURE__ */ new Set(),
+      message: /* @__PURE__ */ new Set(),
+      connection: /* @__PURE__ */ new Set()
+    };
+    this.context.reqId = (0, import_node_crypto.randomUUID)();
+    this.rawOptions = this.name === "main" ? import_lodash.default.cloneDeep(options) : {};
+    this.init();
+    this._appSupervisor.addApp(this);
+    this._noticeManager = new import_notice.NoticeManager(this);
+    this.setMaxListeners(100);
+    this.initWSEventHandlers();
+  }
+  get noticeManager() {
+    return this._noticeManager;
+  }
+  /**
+   * @internal
+   */
+  get loaded() {
+    return this._loaded;
+  }
+  /**
+   * @internal
+   */
+  get maintainingMessage() {
+    return this._maintainingMessage;
+  }
+  get environment() {
+    return this._env;
+  }
+  get aesEncryptor() {
+    return this._aesEncryptor;
+  }
+  get cronJobManager() {
+    return this._cronJobManager;
+  }
+  get mainDataSource() {
+    var _a;
+    return (_a = this.dataSourceManager) == null ? void 0 : _a.dataSources.get("main");
+  }
+  get db() {
+    if (!this.mainDataSource) {
+      return null;
+    }
+    return this.mainDataSource.collectionManager.db;
+  }
+  get logger() {
+    return this._logger;
+  }
+  get resourcer() {
+    return this.mainDataSource.resourceManager;
+  }
+  get cacheManager() {
+    return this._cacheManager;
+  }
+  get cache() {
+    return this._cache;
+  }
+  /**
+   * @internal
+   */
+  set cache(cache) {
+    this._cache = cache;
+  }
+  get cli() {
+    return this._cli;
+  }
+  get i18n() {
+    return this._i18n;
+  }
+  get pm() {
+    return this._pm;
+  }
+  get acl() {
+    return this.mainDataSource.acl;
+  }
+  get authManager() {
+    return this._authManager;
+  }
+  /**
+   * This method is deprecated and should not be used.
+   * Use {@link #localeManager} instead.
+   * @deprecated
+   */
+  get locales() {
+    return this._locales;
+  }
+  get localeManager() {
+    return this._locales;
+  }
+  get version() {
+    return this._version;
+  }
+  /**
+   * Use {@link logger}
+   * @deprecated
+   */
+  get log() {
+    return this._logger;
+  }
+  get name() {
+    return this.options.name || "main";
+  }
+  get dataSourceManager() {
+    return this._dataSourceManager;
+  }
+  /**
+   * @internal
+   */
+  getMaintaining() {
+    return this._maintainingCommandStatus;
+  }
+  /**
+   * @internal
+   */
+  setMaintaining(_maintainingCommandStatus) {
+    this._maintainingCommandStatus = _maintainingCommandStatus;
+    this.emit("maintaining", _maintainingCommandStatus);
+    if (_maintainingCommandStatus.status === "command_end") {
+      this._maintaining = false;
+      return;
+    }
+    this._maintaining = true;
+  }
+  /**
+   * @internal
+   */
+  setMaintainingMessage(message) {
+    this._maintainingMessage = message;
+    this.emit("maintainingMessageChanged", {
+      message: this._maintainingMessage,
+      maintainingStatus: this._maintainingCommandStatus
+    });
+  }
+  /**
+   * This method is deprecated and should not be used.
+   * Use {@link #this.version.get()} instead.
+   * @deprecated
+   */
+  getVersion() {
+    return import_package.default.version;
+  }
+  // @ts-ignore
+  use(middleware, options) {
+    this.middlewareSourceMap.set(middleware, (0, import_utils.getCurrentStacks)());
+    this.middleware.add(middleware, options);
+    return this;
+  }
+  /**
+   * @internal
+   */
+  callback() {
+    const fn = (0, import_koa_compose.default)(this.middleware.nodes);
+    if (!this.listenerCount("error")) this.on("error", this.onerror);
+    return (req, res) => {
+      const ctx = this.createContext(req, res);
+      return this.handleRequest(ctx, fn);
+    };
+  }
+  /**
+   * This method is deprecated and should not be used.
+   * Use {@link #this.db.collection()} instead.
+   * @deprecated
+   */
+  collection(options) {
+    return this.db.collection(options);
+  }
+  /**
+   * This method is deprecated and should not be used.
+   * Use {@link #this.resourcer.define()} instead.
+   * @deprecated
+   */
+  resource(options) {
+    return this.resourcer.define(options);
+  }
+  /**
+   * This method is deprecated and should not be used.
+   * Use {@link #this.resourcer.registerActions()} instead.
+   * @deprecated
+   */
+  actions(handlers, options) {
+    return this.resourcer.registerActions(handlers);
+  }
+  command(name, desc, opts) {
+    return this.cli.command(name, desc, opts).allowUnknownOption();
+  }
+  findCommand(name) {
+    return this.cli._findCommand(name);
+  }
+  /**
+   * @internal
+   */
+  async reInit() {
+    if (!this._loaded) {
+      return;
+    }
+    this.logger.info("app reinitializing");
+    if (this.cacheManager) {
+      await this.cacheManager.close();
+    }
+    if (this.pubSubManager) {
+      await this.pubSubManager.close();
+    }
+    const oldDb = this.db;
+    this.init();
+    if (!oldDb.closed()) {
+      await oldDb.close();
+    }
+    this._loaded = false;
+  }
+  async load(options) {
+    if (this._loaded) {
+      return;
+    }
+    if (options == null ? void 0 : options.reload) {
+      this.setMaintainingMessage("app reload");
+      this.logger.info(`app.reload()`, { method: "load" });
+      if (this.cacheManager) {
+        await this.cacheManager.close();
+      }
+      const oldDb = this.db;
+      this.init();
+      if (!oldDb.closed()) {
+        await oldDb.close();
+      }
+    }
+    this._aesEncryptor = await import_aes_encryptor.default.create(this);
+    this._cacheManager = await (0, import_cache2.createCacheManager)(this, this.options.cacheManager);
+    this.setMaintainingMessage("init plugins");
+    await this.pm.initPlugins();
+    this.setMaintainingMessage("start load");
+    this.setMaintainingMessage("emit beforeLoad");
+    if ((options == null ? void 0 : options.hooks) !== false) {
+      await this.emitAsync("beforeLoad", this, options);
+    }
+    await this.pm.load(options);
+    if (options == null ? void 0 : options.sync) {
+      await this.db.sync();
+    }
+    this.setMaintainingMessage("emit afterLoad");
+    if ((options == null ? void 0 : options.hooks) !== false) {
+      await this.emitAsync("afterLoad", this, options);
+    }
+    this._loaded = true;
+  }
+  async reload(options) {
+    this.logger.debug(`start reload`, { method: "reload" });
+    this._loaded = false;
+    await this.emitAsync("beforeReload", this, options);
+    await this.load({
+      ...options,
+      reload: true
+    });
+    this.logger.debug("emit afterReload", { method: "reload" });
+    this.setMaintainingMessage("emit afterReload");
+    await this.emitAsync("afterReload", this, options);
+    this.logger.debug(`finish reload`, { method: "reload" });
+  }
+  /**
+   * This method is deprecated and should not be used.
+   * Use {@link this.pm.get()} instead.
+   * @deprecated
+   */
+  getPlugin(name) {
+    return this.pm.get(name);
+  }
+  /**
+   * This method is deprecated and should not be used.
+   * Use {@link this.runAsCLI()} instead.
+   * @deprecated
+   */
+  async parse(argv = process.argv) {
+    return this.runAsCLI(argv);
+  }
+  async authenticate() {
+    if (this._authenticated) {
+      return;
+    }
+    this._authenticated = true;
+    await this.db.auth();
+    await this.db.checkVersion();
+    await this.db.prepare();
+  }
+  async runCommand(command, ...args) {
+    return await this.runAsCLI([command, ...args], { from: "user" });
+  }
+  async runCommandThrowError(command, ...args) {
+    return await this.runAsCLI([command, ...args], { from: "user", throwError: true });
+  }
+  createCLI() {
+    const command = new import_app_command.AppCommand("tachybase").usage("[command] [options]").hook("preAction", async (_2, actionCommand) => {
+      this._actionCommand = actionCommand;
+      this.activatedCommand = {
+        name: (0, import_helper.getCommandFullName)(actionCommand)
+      };
+      this.setMaintaining({
+        status: "command_begin",
+        command: this.activatedCommand
+      });
+      this.setMaintaining({
+        status: "command_running",
+        command: this.activatedCommand
+      });
+      if (actionCommand["_authenticate"]) {
+        await this.authenticate();
+      }
+      if (actionCommand["_preload"]) {
+        await this.load();
+      }
+    }).hook("postAction", async (_2, actionCommand) => {
+      var _a;
+      if (((_a = this._maintainingStatusBeforeCommand) == null ? void 0 : _a.error) && this._started) {
+        await this.restart();
+      }
+    });
+    command.exitOverride((err) => {
+      if (err instanceof import_commander.CommanderError && err.code === "commander.helpDisplayed" || err.code === "commander.help") {
+        return;
+      }
+      throw err;
+    });
+    return command;
+  }
+  /**
+   * @internal
+   */
+  async loadMigrations(options) {
+    const { directory, context, namespace } = options;
+    const migrations = {
+      beforeLoad: [],
+      afterSync: [],
+      afterLoad: []
+    };
+    const extensions = ["js", "ts"];
+    const patten = `${directory}/*.{${extensions.join(",")}}`;
+    const files = (0, import_glob.globSync)(patten, {
+      ignore: ["**/*.d.ts"]
+    }).filter((f) => !f.endsWith(".d.ts"));
+    const appVersion = await this.version.get();
+    for (const file of files) {
+      let filename = (0, import_node_path.basename)(file);
+      filename = filename.substring(0, filename.lastIndexOf(".")) || filename;
+      const Migration = await (0, import_utils.importModule)(file);
+      const m = new Migration({ app: this, db: this.db, ...context });
+      if (!m.appVersion || import_semver.default.satisfies(appVersion, m.appVersion, { includePrerelease: true })) {
+        m.name = `${filename}/${namespace}`;
+        migrations[m.on || "afterLoad"].push(m);
+      }
+    }
+    return migrations;
+  }
+  /**
+   * @internal
+   */
+  async loadCoreMigrations() {
+    const migrations = await this.loadMigrations({
+      directory: (0, import_node_path.resolve)(__dirname, "migrations"),
+      namespace: "@tego/core"
+    });
+    return {
+      beforeLoad: {
+        up: /* @__PURE__ */ __name(async () => {
+          this.logger.debug("run core migrations(beforeLoad)");
+          const migrator = this.db.createMigrator({ migrations: migrations.beforeLoad });
+          await migrator.up();
+        }, "up")
+      },
+      afterSync: {
+        up: /* @__PURE__ */ __name(async () => {
+          this.logger.debug("run core migrations(afterSync)");
+          const migrator = this.db.createMigrator({ migrations: migrations.afterSync });
+          await migrator.up();
+        }, "up")
+      },
+      afterLoad: {
+        up: /* @__PURE__ */ __name(async () => {
+          this.logger.debug("run core migrations(afterLoad)");
+          const migrator = this.db.createMigrator({ migrations: migrations.afterLoad });
+          await migrator.up();
+        }, "up")
+      }
+    };
+  }
+  /**
+   * @internal
+   */
+  async loadPluginCommands() {
+    this.logger.debug("load plugin commands");
+    await this.pm.loadCommands();
+  }
+  /**
+   * @internal
+   */
+  async runAsCLI(argv = process.argv, options) {
+    if (this.activatedCommand) {
+      return;
+    }
+    if (options.reqId) {
+      this.context.reqId = options.reqId;
+      this._logger = this._logger.child({ reqId: this.context.reqId });
+    }
+    this._maintainingStatusBeforeCommand = this._maintainingCommandStatus;
+    try {
+      const commandName = (options == null ? void 0 : options.from) === "user" ? argv[0] : argv[2];
+      if (!this.cli.hasCommand(commandName)) {
+        await this.pm.loadCommands();
+      }
+      const command = await this.cli.parseAsync(argv, options);
+      this.setMaintaining({
+        status: "command_end",
+        command: this.activatedCommand
+      });
+      return command;
+    } catch (error) {
+      this.logger.error("run command error", error);
+      if (!this.activatedCommand) {
+        this.activatedCommand = {
+          name: "unknown"
+        };
+      }
+      this.setMaintaining({
+        status: "command_error",
+        command: this.activatedCommand,
+        error
+      });
+    } finally {
+      const _actionCommand = this._actionCommand;
+      if (_actionCommand) {
+        const options2 = _actionCommand["options"];
+        _actionCommand["_optionValues"] = {};
+        _actionCommand["_optionValueSources"] = {};
+        _actionCommand["options"] = [];
+        for (const option of options2) {
+          _actionCommand.addOption(option);
+        }
+      }
+      this._actionCommand = null;
+      this.activatedCommand = null;
+    }
+  }
+  async start(options = {}) {
+    if (this._started) {
+      return;
+    }
+    this._started = true;
+    if (options.checkInstall && !await this.isInstalled()) {
+      throw new import_application_not_install.ApplicationNotInstall(
+        `Application ${this.name} is not installed, Please run 'pnpm tachybase install' command first`
+      );
+    }
+    this.setMaintainingMessage("starting app...");
+    if (this.db.closed()) {
+      await this.db.reconnect();
+    }
+    this.setMaintainingMessage("emit beforeStart");
+    await this.emitAsync("beforeStart", this, options);
+    this.setMaintainingMessage("emit afterStart");
+    await this.emitAsync("afterStart", this, options);
+    this.setMaintainingMessage("app started success!");
+    await this.emitStartedEvent(options);
+    this.stopped = false;
+  }
+  /**
+   * @internal
+   */
+  async emitStartedEvent(options = {}) {
+    await this.emitAsync("__started", this, {
+      maintainingStatus: import_lodash.default.cloneDeep(this._maintainingCommandStatus),
+      options
+    });
+  }
+  async isStarted() {
+    return this._started;
+  }
+  /**
+   * @internal
+   */
+  async tryReloadOrRestart(options = {}) {
+    if (this._started) {
+      await this.restart(options);
+    } else {
+      await this.reload(options);
+    }
+  }
+  async restart(options = {}) {
+    if (!this._started) {
+      return;
+    }
+    this.logger.info("restarting...");
+    this._started = false;
+    await this.emitAsync("beforeStop");
+    await this.reload(options);
+    await this.start(options);
+    this.emit("__restarted", this, options);
+  }
+  async stop(options = {}) {
+    const log = options.logging === false ? {
+      debug() {
+      },
+      warn() {
+      },
+      info() {
+      },
+      error() {
+      }
+    } : this.logger;
+    log.debug("stop app...", { method: "stop" });
+    this.setMaintainingMessage("stopping app...");
+    if (this.stopped) {
+      log.warn(`app is stopped`, { method: "stop" });
+      return;
+    }
+    await this.emitAsync("beforeStop", this, options);
+    try {
+      if (!this.db.closed()) {
+        log.info(`close db`, { method: "stop" });
+        await this.db.close();
+      }
+    } catch (e) {
+      log.error(e.message, { method: "stop", err: e.stack });
+    }
+    if (this.cacheManager) {
+      await this.cacheManager.close();
+    }
+    await this.emitAsync("afterStop", this, options);
+    this.stopped = true;
+    log.info(`app has stopped`, { method: "stop" });
+    this._started = false;
+  }
+  async destroy(options = {}) {
+    this.logger.debug("start destroy app", { method: "destory" });
+    this.setMaintainingMessage("destroying app...");
+    await this.emitAsync("beforeDestroy", this, options);
+    await this.stop(options);
+    this.logger.debug("emit afterDestroy", { method: "destory" });
+    await this.emitAsync("afterDestroy", this, options);
+    this.logger.debug("finish destroy app", { method: "destory" });
+  }
+  async isInstalled() {
+    return await this.db.collectionExistsInDb("applicationVersion") || await this.db.collectionExistsInDb("collections");
+  }
+  async install(options = {}) {
+    var _a;
+    const reinstall = options.clean || options.force;
+    if (reinstall) {
+      await this.db.clean({ drop: true });
+    }
+    if (await this.isInstalled()) {
+      this.logger.warn("app is installed");
+      return;
+    }
+    await this.reInit();
+    await this.db.sync();
+    await this.load({ hooks: false });
+    this.logger.debug("emit beforeInstall", { method: "install" });
+    this.setMaintainingMessage("call beforeInstall hook...");
+    await this.emitAsync("beforeInstall", this, options);
+    await this.pm.install();
+    await this.version.update();
+    this.logger.debug("emit afterInstall", { method: "install" });
+    this.setMaintainingMessage("call afterInstall hook...");
+    await this.emitAsync("afterInstall", this, options);
+    if ((_a = this._maintainingStatusBeforeCommand) == null ? void 0 : _a.error) {
+      return;
+    }
+    if (this._started) {
+      await this.restart();
+    }
+  }
+  async upgrade(options = {}) {
+    this.logger.info("upgrading...");
+    await this.reInit();
+    const migrator1 = await this.loadCoreMigrations();
+    await migrator1.beforeLoad.up();
+    await this.db.sync();
+    await migrator1.afterSync.up();
+    await this.pm.initPresetPlugins();
+    const migrator2 = await this.pm.loadPresetMigrations();
+    await migrator2.beforeLoad.up();
+    await this.pm.load();
+    await this.db.sync();
+    await migrator2.afterSync.up();
+    await this.pm.upgrade();
+    await this.pm.initOtherPlugins();
+    const migrator3 = await this.pm.loadOtherMigrations();
+    await migrator3.beforeLoad.up();
+    await this.load({ sync: true });
+    await migrator3.afterSync.up();
+    await this.pm.upgrade();
+    await migrator1.afterLoad.up();
+    await migrator2.afterLoad.up();
+    await migrator3.afterLoad.up();
+    await this.pm.repository.updateVersions();
+    await this.version.update();
+    await this.emitAsync("afterUpgrade", this, options);
+    await this.restart();
+  }
+  toJSON() {
+    return {
+      appName: this.name,
+      name: this.name
+    };
+  }
+  /**
+   * @internal
+   */
+  reInitEvents() {
+    for (const eventName of this.eventNames()) {
+      for (const listener of this.listeners(eventName)) {
+        if (listener["_reinitializable"]) {
+          this.removeListener(eventName, listener);
+        }
+      }
+    }
+  }
+  createLogger(options) {
+    const { dirname } = options;
+    return (0, import_logger.createLogger)({
+      ...options,
+      dirname: (0, import_logger.getLoggerFilePath)(this.name || "main", dirname || "")
+    });
+  }
+  init() {
+    var _a;
+    const options = this.options;
+    this._logger = (0, import_logger.createSystemLogger)({
+      dirname: (0, import_logger.getLoggerFilePath)(this.name),
+      filename: "system",
+      seperateError: true,
+      ...(_a = options.logger) == null ? void 0 : _a.system
+    }).child({
+      reqId: this.context.reqId,
+      app: this.name,
+      module: "application"
+    });
+    this.reInitEvents();
+    this.middleware = new import_utils.Toposort();
+    this.plugins = /* @__PURE__ */ new Map();
+    if (this.db) {
+      this.db.removeAllListeners();
+    }
+    this.createMainDataSource(options);
+    this._env = new import_environment.Environment();
+    this._cronJobManager = new import_cron_job_manager.CronJobManager(this);
+    this._cli = this.createCLI();
+    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.context.db = this.db;
+    this.context.resourcer = this.resourcer;
+    this.context.cacheManager = this._cacheManager;
+    this.context.cache = this._cache;
+    const plugins = this._pm ? this._pm.options.plugins : options.plugins;
+    this._pm = new import_plugin_manager.PluginManager({
+      app: this,
+      plugins: plugins || []
+    });
+    this._authManager = new import_auth.AuthManager({
+      authKey: "X-Authenticator",
+      default: "basic",
+      ...this.options.authManager
+    });
+    this.resource({
+      name: "auth",
+      actions: import_auth.actions
+    });
+    this._dataSourceManager.use(this._authManager.middleware(), { tag: "auth" });
+    this.resourcer.use(this._authManager.middleware(), { tag: "auth" });
+    if (this.options.acl !== false) {
+      this.resourcer.use(this.acl.middleware(), { tag: "acl", after: ["auth"] });
+    }
+    this._dataSourceManager.use(import_middlewares.parseVariables, {
+      group: "parseVariables",
+      after: "acl"
+    });
+    this._dataSourceManager.use(import_data_template.dataTemplate, { group: "dataTemplate", after: "acl" });
+    this._locales = new import_locale.Locale((0, import_helper.createAppProxy)(this));
+    if (options.perfHooks) {
+      (0, import_helper.enablePerfHooks)(this);
+    }
+    (0, import_helper.registerMiddlewares)(this, options);
+    if (options.registerActions !== false) {
+      (0, import_actions.registerActions)(this);
+    }
+    (0, import_commands.registerCli)(this);
+    this._version = new import_application_version.ApplicationVersion(this);
+  }
+  createMainDataSource(options) {
+    const mainDataSourceInstance = new import_main_data_source.MainDataSource({
+      name: "main",
+      database: this.createDatabase(options),
+      acl: (0, import_acl.createACL)(),
+      resourceManager: (0, import_helper.createResourcer)(options)
+    });
+    this._dataSourceManager = new import_data_source.DataSourceManager();
+    this.dataSourceManager.dataSources.set("main", mainDataSourceInstance);
+  }
+  createDatabase(options) {
+    const sqlLogger = this.createLogger({
+      filename: "sql",
+      level: "debug"
+    });
+    const logging = /* @__PURE__ */ __name((msg) => {
+      if (typeof msg === "string") {
+        msg = msg.replace(/[\r\n]/gm, "").replace(/\s+/g, " ");
+      }
+      if (msg.includes("INSERT INTO")) {
+        msg = msg.substring(0, 2e3) + "...";
+      }
+      sqlLogger.debug({ message: msg, app: this.name, reqId: this.context.reqId });
+    }, "logging");
+    const dbOptions = options.database instanceof import_database.default ? options.database.options : options.database;
+    const db = new import_database.default({
+      ...dbOptions,
+      logging: dbOptions.logging ? logging : false,
+      migrator: {
+        context: { app: this }
+      },
+      logger: this._logger.child({ module: "database" })
+    });
+    return db;
+  }
+  /**
+   * 初始化 WebSocket 事件处理
+   * 注册应用级别的事件，用于与 WSServer 通信
+   */
+  initWSEventHandlers() {
+    this.on("ws:registerEventHandler", ({ eventType, handler }) => {
+      this.registerWSEventHandler(eventType, handler);
+    });
+    this.on("ws:removeEventHandler", ({ eventType, handler }) => {
+      this.removeWSEventHandler(eventType, handler);
+    });
+  }
+  /**
+   * 为 WebSocket 事件注册处理函数
+   * 这是一个适配器方法，将事件处理函数注册到 Gateway 的 WSServer
+   * @param eventType 事件类型
+   * @param handler 事件处理函数
+   */
+  registerWSEventHandler(eventType, handler) {
+    const gateway = import_gateway.Gateway.getInstance();
+    const wsServer = gateway["wsServer"];
+    if (wsServer) {
+      wsServer.registerAppEventHandler(this.name, eventType, handler);
+    }
+    return this;
+  }
+  /**
+   * 移除 WebSocket 事件处理函数
+   * @param eventType 事件类型
+   * @param handler 事件处理函数
+   */
+  removeWSEventHandler(eventType, handler) {
+    const gateway = import_gateway.Gateway.getInstance();
+    const wsServer = gateway["wsServer"];
+    if (wsServer) {
+      wsServer.removeAppEventHandler(this.name, eventType, handler);
+    }
+    return this;
+  }
+};
+__name(_Application, "Application");
+_Application.KEY_CORE_APP_PREFIX = "KEY_CORE_APP_";
+let Application = _Application;
+(0, import_utils.applyMixins)(Application, [import_utils.AsyncEmitter]);
+var application_default = Application;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Application,
+  Logger
+});