@tego/core 1.3.44

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

@@ -0,0 +1,1032 @@
+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 plugin_manager_exports = {};
+__export(plugin_manager_exports, {
+  AddPresetError: () => AddPresetError,
+  PluginManager: () => PluginManager,
+  default: () => plugin_manager_default,
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(plugin_manager_exports);
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_path = require("node:path");
+var import_di = require("@tachybase/di");
+var import_globals = __toESM(require("@tachybase/globals"));
+var import_utils = require("@tachybase/utils");
+var import_execa = __toESM(require("execa"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_lodash = __toESM(require("lodash"));
+var import_helper = require("../helper");
+var import_constants = require("./constants");
+var import_middleware = require("./middleware");
+var import_collection = __toESM(require("./options/collection"));
+var import_resource = __toESM(require("./options/resource"));
+var import_plugin_manager_repository = require("./plugin-manager-repository");
+var import_utils2 = require("./utils");
+var import_web_service = require("./web-service");
+const sleep = /* @__PURE__ */ __name(async (timeout = 0) => {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, timeout);
+  });
+}, "sleep");
+const _AddPresetError = class _AddPresetError extends Error {
+};
+__name(_AddPresetError, "AddPresetError");
+let AddPresetError = _AddPresetError;
+const _PluginManager = class _PluginManager {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    this.options = options;
+    /**
+     * @internal
+     */
+    this.pluginInstances = /* @__PURE__ */ new Map();
+    /**
+     * @internal
+     */
+    this.pluginAliases = /* @__PURE__ */ new Map();
+    this.app = options.app;
+    this.app.db.registerRepositories({
+      PluginManagerRepository: import_plugin_manager_repository.PluginManagerRepository
+    });
+    this.collection = this.app.db.collection(import_collection.default);
+    this._repository = this.collection.repository;
+    this._repository.setPluginManager(this);
+    this.app.resourcer.define(import_resource.default);
+    this.app.acl.allow("pm", "listEnabled", "public");
+    this.app.acl.registerSnippet({
+      name: "pm",
+      actions: ["pm:*"]
+    });
+    this.app.db.addMigrations({
+      namespace: "core/pm",
+      directory: (0, import_node_path.resolve)(__dirname, "../migrations")
+    });
+    this.app.resourcer.use(import_middleware.uploadMiddleware, { tag: "pmFileUpload" });
+  }
+  get repository() {
+    return this.app.db.getRepository("applicationPlugins");
+  }
+  /**
+   * @internal
+   */
+  static async getPackageJson(packageName) {
+    const pluginPaths = import_globals.default.getInstance().get("PLUGIN_PATHS");
+    for (const basePath of pluginPaths) {
+      const pkgPath = (0, import_node_path.resolve)(basePath, packageName, "package.json");
+      try {
+        const realPath = await import_promises.default.realpath(pkgPath);
+        const data = await import_promises.default.readFile(realPath, { encoding: "utf-8" });
+        return JSON.parse(data);
+      } catch (err) {
+      }
+    }
+    throw new Error(`package.json for ${packageName} not found in any PLUGIN_PATHS`);
+  }
+  /**
+   * @internal
+   */
+  static async getPackageName(name) {
+    const pluginPaths = import_globals.default.getInstance().get("PLUGIN_PATHS");
+    const prefixes = this.getPluginPkgPrefix();
+    for (const prefix of prefixes) {
+      for (const basePath of pluginPaths) {
+        const pkg = (0, import_node_path.resolve)(basePath, `${prefix}${name}`, "package.json");
+        const exists = await (0, import_utils.fsExists)(pkg);
+        if (exists) {
+          return `${prefix}${name}`;
+        }
+      }
+    }
+    throw new Error(`${name} plugin does not exist`);
+  }
+  /**
+   * @internal
+   */
+  static getPluginPkgPrefix() {
+    return import_constants.pluginPrefix;
+  }
+  /**
+   * @internal
+   */
+  static async findPackage(name) {
+    try {
+      const packageName = this.getPackageName(name);
+      return packageName;
+    } catch (error) {
+      console.log(`\`${name}\` plugin not found locally`);
+      const prefixes = this.getPluginPkgPrefix();
+      for (const prefix of prefixes) {
+        try {
+          const packageName = `${prefix}${name}`;
+          console.log(`Try to find ${packageName}`);
+          await (0, import_execa.default)("npm", ["v", packageName, "versions"]);
+          console.log(`${packageName} downloading`);
+          await (0, import_execa.default)("pnpm", ["add", packageName, "-W"]);
+          console.log(`${packageName} downloaded`);
+          return packageName;
+        } catch (error2) {
+          continue;
+        }
+      }
+    }
+    throw new Error(`No available packages found, ${name} plugin does not exist`);
+  }
+  /**
+   * @internal
+   */
+  static clearCache(packageName) {
+    return;
+    const packageNamePath = packageName.replace("/", import_node_path.sep);
+    Object.keys(require.cache).forEach((key) => {
+      if (key.includes(packageNamePath)) {
+        delete require.cache[key];
+      }
+    });
+  }
+  /**
+   * @internal
+   */
+  static async resolvePlugin(pluginName, isUpgrade = false, isPkg = false) {
+    if (typeof pluginName === "string") {
+      const packageName = isPkg ? pluginName : await this.getPackageName(pluginName);
+      this.clearCache(packageName);
+      return await (0, import_utils.importModule)(packageName);
+    } else {
+      return pluginName;
+    }
+  }
+  addPreset(plugin, options = {}) {
+    if (this.app.loaded) {
+      throw new AddPresetError("must be added before executing app.load()");
+    }
+    if (!this.options.plugins) {
+      this.options.plugins = [];
+    }
+    this.options.plugins.push([plugin, options]);
+  }
+  getPlugins() {
+    return this.app.pm.pluginInstances;
+  }
+  getAliases() {
+    return this.app.pm.pluginAliases.keys();
+  }
+  get(name) {
+    if (typeof name === "string") {
+      return this.app.pm.pluginAliases.get(name);
+    }
+    return this.app.pm.pluginInstances.get(name);
+  }
+  has(name) {
+    if (typeof name === "string") {
+      return this.app.pm.pluginAliases.has(name);
+    }
+    return this.app.pm.pluginInstances.has(name);
+  }
+  del(name) {
+    const instance = this.get(name);
+    if (instance) {
+      this.app.pm.pluginAliases.delete(instance.name);
+      this.app.pm.pluginInstances.delete(instance.constructor);
+    }
+  }
+  async create(pluginName, options) {
+    const createPlugin = /* @__PURE__ */ __name(async (name) => {
+      const pluginDir = (0, import_node_path.resolve)(process.cwd(), "packages", name);
+      if (options == null ? void 0 : options.forceRecreate) {
+        await import_promises.default.rm(pluginDir, { recursive: true, force: true });
+      }
+      await (0, import_execa.default)("pnpm", ["run", "tb", "create-plugin", name]);
+    }, "createPlugin");
+    await createPlugin(pluginName);
+    try {
+      await this.app.db.auth({ retry: 1 });
+      const installed = await this.app.isInstalled();
+      if (!installed) {
+        console.log(`pnpm pm add ${pluginName}`);
+        return;
+      }
+    } catch (error) {
+      return;
+    }
+    this.app.logger.info("attempt to add the plugin to the app");
+    await (0, import_utils.createDevPluginsSymlink)();
+    let packageName;
+    try {
+      packageName = await _PluginManager.getPackageName(pluginName);
+    } catch (error) {
+      packageName = pluginName;
+    }
+    const json = await _PluginManager.getPackageJson(packageName);
+    this.app.logger.info(`add plugin [${packageName}]`, {
+      name: pluginName,
+      packageName,
+      version: json.version
+    });
+    await this.repository.updateOrCreate({
+      values: {
+        name: pluginName,
+        packageName,
+        version: json.version
+      },
+      filterKeys: ["name"]
+    });
+    await sleep(1e3);
+    await (0, import_helper.tsxRerunning)();
+  }
+  async add(plugin, options = {}, insert = false, isUpgrade = false) {
+    if (!isUpgrade && this.has(plugin)) {
+      const name = typeof plugin === "string" ? plugin : plugin.name;
+      this.app.logger.warn(`plugin [${name}] added`);
+      return;
+    }
+    if (!options.name && typeof plugin === "string") {
+      options.name = plugin;
+    }
+    try {
+      if (typeof plugin === "string" && options.name && !options.packageName && !options.isPreset) {
+        const packageName = await _PluginManager.getPackageName(options.name);
+        options["packageName"] = packageName;
+      }
+      if (options.packageName) {
+        const packageJson = await _PluginManager.getPackageJson(options.packageName);
+        options["packageJson"] = packageJson;
+        options["version"] = packageJson.version;
+      }
+    } catch (error) {
+      this.app.logger.error(error);
+    }
+    this.app.logger.debug(`add plugin [${options.name}]`, {
+      method: "add",
+      submodule: "plugin-manager",
+      name: options.name
+    });
+    let P;
+    try {
+      if (options.isPreset) {
+        P = import_globals.default.getInstance().get("PRESETS")[options.name];
+      } else {
+        P = await _PluginManager.resolvePlugin(options.packageName || plugin, isUpgrade, !!options.packageName);
+      }
+    } catch (error) {
+      if (process.env.APP_ENV === "development") {
+        throw error;
+      }
+      this.app.logger.warn("plugin not found", error);
+      return;
+    }
+    const instance = new P((0, import_helper.createAppProxy)(this.app), options);
+    this.pluginInstances.set(P, instance);
+    if (options.name) {
+      if (this.app.name === "main" || options.subView) {
+        this.pluginAliases.set(options.name, instance);
+      }
+    }
+    if (insert && options.name) {
+      await this.repository.updateOrCreate({
+        values: {
+          ...options
+        },
+        filterKeys: ["name"]
+      });
+    }
+    await instance.afterAdd();
+  }
+  /**
+   * @internal
+   */
+  async initPlugins() {
+    await this.initRuntimePlugins();
+    await this.initPresetPlugins();
+    await this.initOtherPlugins();
+  }
+  /**
+   * @internal
+   */
+  async loadCommands() {
+    this.app.logger.debug("load commands");
+    const items = await this.repository.find({
+      filter: {
+        enabled: true
+      }
+    });
+    const packageNames = items.map((item) => item.packageName);
+    const source = [];
+    const pluginPaths = import_globals.default.getInstance().get("PLUGIN_PATHS");
+    for (const packageName of packageNames) {
+      const file = require.resolve(packageName, { paths: [process.cwd(), ...pluginPaths] });
+      const sourceDir = (0, import_node_path.basename)((0, import_node_path.dirname)(file)) === "src" ? "src" : "dist";
+      const directory = (0, import_node_path.join)(
+        packageName,
+        sourceDir,
+        "server/commands/*." + ((0, import_node_path.basename)((0, import_node_path.dirname)(file)) === "src" ? "ts" : "js")
+      );
+      source.push(directory.replaceAll(import_node_path.sep, "/"));
+    }
+    for (const plugin of this.options.plugins || []) {
+      if (typeof plugin === "string") {
+        if (plugin in import_globals.default.getInstance().get("PRESETS")) {
+          continue;
+        }
+        const packageName = await _PluginManager.getPackageName(plugin);
+        const file = require.resolve(packageName, { paths: [process.cwd(), ...pluginPaths] });
+        const sourceDir = (0, import_node_path.basename)((0, import_node_path.dirname)(file)) === "src" ? "src" : "lib";
+        const directory = (0, import_node_path.join)(packageName, sourceDir, "server/commands/*." + (sourceDir === "src" ? "ts" : "js"));
+        source.push(directory.replaceAll(import_node_path.sep, "/"));
+      }
+    }
+    for (const basePath of pluginPaths) {
+      const files = await (0, import_fast_glob.default)(source, {
+        ignore: ["**/*.d.ts"],
+        cwd: basePath
+      });
+      for (const file of files) {
+        const callback = await (0, import_utils.importModule)(file);
+        callback(this.app);
+      }
+    }
+  }
+  async load(options = {}) {
+    import_di.Container.reset();
+    import_di.Container.set({ id: "db", value: this.app.db });
+    import_di.Container.set({ id: "app", value: (0, import_helper.createAppProxy)(this.app) });
+    import_di.Container.set({ id: "logger", value: this.app.logger });
+    await import_di.Container.get(import_web_service.WebControllerService).load();
+    this.app.setMaintainingMessage("loading plugins...");
+    const total = this.pluginInstances.size;
+    let current = 0;
+    for (const [P, plugin] of this.getPlugins()) {
+      if (plugin.state.loaded) {
+        continue;
+      }
+      const name = plugin.name || P.name;
+      current += 1;
+      this.app.setMaintainingMessage(`before load plugin [${name}], ${current}/${total}`);
+      if (!plugin.enabled) {
+        continue;
+      }
+      this.app.logger.debug(`before load plugin [${name}]`, { submodule: "plugin-manager", method: "load", name });
+      await plugin.beforeLoad();
+      for (const feature of plugin.featureInstances) {
+        await feature.beforeLoad();
+      }
+    }
+    current = 0;
+    for (const [P, plugin] of this.getPlugins()) {
+      if (plugin.state.loaded) {
+        continue;
+      }
+      const name = plugin.name || P.name;
+      current += 1;
+      this.app.setMaintainingMessage(`${this.app.i18n.t("load plugin")} [${name}], ${current}/${total}`);
+      if (!plugin.enabled) {
+        continue;
+      }
+      await this.app.emitAsync("beforeLoadPlugin", plugin, options);
+      this.app.logger.debug(`load plugin [${name}] `, { submodule: "plugin-manager", method: "load", name });
+      await plugin.loadCollections();
+      await plugin.load();
+      plugin.state.loaded = true;
+      await this.app.emitAsync("afterLoadPlugin", plugin, options);
+      for (const feature of plugin.featureInstances) {
+        await feature.load();
+      }
+    }
+    this.app.setMaintainingMessage("loaded plugins");
+  }
+  async install(options = {}) {
+    this.app.setMaintainingMessage("install plugins...");
+    const total = this.pluginInstances.size;
+    let current = 0;
+    this.app.logger.debug("call db.sync()");
+    await this.app.db.sync();
+    const toBeUpdated = [];
+    for (const [P, plugin] of this.getPlugins()) {
+      if (plugin.state.installing || plugin.state.installed) {
+        continue;
+      }
+      const name = plugin.name || P.name;
+      current += 1;
+      if (!plugin.enabled) {
+        continue;
+      }
+      plugin.state.installing = true;
+      this.app.setMaintainingMessage(`before install plugin [${name}], ${current}/${total}`);
+      await this.app.emitAsync("beforeInstallPlugin", plugin, options);
+      this.app.logger.debug(`install plugin [${name}]...`);
+      await plugin.install(options);
+      toBeUpdated.push(name);
+      plugin.state.installing = false;
+      plugin.state.installed = true;
+      plugin.installed = true;
+      this.app.setMaintainingMessage(`after install plugin [${name}], ${current}/${total}`);
+      await this.app.emitAsync("afterInstallPlugin", plugin, options);
+      for (const feature of plugin.featureInstances) {
+        await feature.install(options);
+      }
+    }
+    await this.repository.update({
+      filter: {
+        name: toBeUpdated
+      },
+      values: {
+        installed: true
+      }
+    });
+  }
+  async enable(name) {
+    const pluginNames = import_lodash.default.castArray(name);
+    this.app.logger.debug(`enabling plugin ${pluginNames.join(",")}`);
+    this.app.setMaintainingMessage(`enabling plugin ${pluginNames.join(",")}`);
+    const toBeUpdated = [];
+    for (const pluginName of pluginNames) {
+      const plugin = this.get(pluginName);
+      if (!plugin) {
+        throw new Error(`${pluginName} plugin does not exist`);
+      }
+      if (plugin.enabled) {
+        continue;
+      }
+      await this.app.emitAsync("beforeEnablePlugin", pluginName);
+      await plugin.beforeEnable();
+      plugin.enabled = true;
+      toBeUpdated.push(pluginName);
+    }
+    if (toBeUpdated.length === 0) {
+      return;
+    }
+    await this.repository.update({
+      filter: {
+        name: toBeUpdated
+      },
+      values: {
+        enabled: true
+      }
+    });
+    try {
+      await this.app.reload();
+      this.app.logger.debug(`syncing database in enable plugin ${pluginNames.join(",")}...`);
+      this.app.setMaintainingMessage(`syncing database in enable plugin ${pluginNames.join(",")}...`);
+      await this.app.db.sync();
+      for (const pluginName of pluginNames) {
+        const plugin = this.get(pluginName);
+        if (!plugin.installed) {
+          this.app.logger.debug(`installing plugin ${pluginName}...`);
+          this.app.setMaintainingMessage(`installing plugin ${pluginName}...`);
+          await plugin.install();
+          plugin.installed = true;
+        }
+      }
+      await this.repository.update({
+        filter: {
+          name: toBeUpdated
+        },
+        values: {
+          installed: true
+        }
+      });
+      for (const pluginName of pluginNames) {
+        const plugin = this.get(pluginName);
+        this.app.logger.debug(`emit afterEnablePlugin event...`);
+        await plugin.afterEnable();
+        await this.app.emitAsync("afterEnablePlugin", pluginName);
+        this.app.logger.debug(`afterEnablePlugin event emitted`);
+      }
+      await this.app.tryReloadOrRestart();
+    } catch (error) {
+      await this.repository.update({
+        filter: {
+          name: toBeUpdated
+        },
+        values: {
+          enabled: false,
+          installed: false
+        }
+      });
+      await this.app.tryReloadOrRestart({
+        recover: true
+      });
+      throw error;
+    }
+  }
+  async disable(name) {
+    const pluginNames = import_lodash.default.castArray(name);
+    this.app.logger.debug(`disabling plugin ${pluginNames.join(",")}`);
+    this.app.setMaintainingMessage(`disabling plugin ${pluginNames.join(",")}`);
+    const toBeUpdated = [];
+    for (const pluginName of pluginNames) {
+      const plugin = this.get(pluginName);
+      if (!plugin) {
+        throw new Error(`${pluginName} plugin does not exist`);
+      }
+      if (!plugin.enabled) {
+        continue;
+      }
+      await this.app.emitAsync("beforeDisablePlugin", pluginName);
+      await plugin.beforeDisable();
+      plugin.enabled = false;
+      toBeUpdated.push(pluginName);
+    }
+    if (toBeUpdated.length === 0) {
+      return;
+    }
+    await this.repository.update({
+      filter: {
+        name: toBeUpdated
+      },
+      values: {
+        enabled: false
+      }
+    });
+    try {
+      await this.app.tryReloadOrRestart();
+      for (const pluginName of pluginNames) {
+        const plugin = this.get(pluginName);
+        this.app.logger.debug(`emit afterDisablePlugin event...`);
+        await plugin.afterDisable();
+        await this.app.emitAsync("afterDisablePlugin", pluginName);
+        this.app.logger.debug(`afterDisablePlugin event emitted`);
+      }
+    } catch (error) {
+      await this.repository.update({
+        filter: {
+          name: toBeUpdated
+        },
+        values: {
+          enabled: true
+        }
+      });
+      await this.app.tryReloadOrRestart({
+        recover: true
+      });
+      throw error;
+    }
+  }
+  async remove(name, options) {
+    const pluginNames = import_lodash.default.castArray(name);
+    const records = pluginNames.map((name2) => {
+      return {
+        name: name2,
+        packageName: name2
+      };
+    });
+    const removeDir = /* @__PURE__ */ __name(async () => {
+      await Promise.all(
+        records.map(async (plugin) => {
+          const pluginPaths = import_globals.default.getInstance().get("PLUGIN_PATHS");
+          for (const basePath of pluginPaths) {
+            const dir = (0, import_node_path.resolve)(basePath, plugin.packageName);
+            try {
+              const realDir = await import_promises.default.realpath(dir);
+              this.app.logger.debug(`rm -rf ${realDir}`);
+              await import_promises.default.rm(realDir, { force: true, recursive: true });
+              return true;
+            } catch (error) {
+            }
+            return false;
+          }
+        })
+      );
+      await (0, import_execa.default)("pnpm", ["tachybase", "postinstall"]);
+    }, "removeDir");
+    if (options == null ? void 0 : options.force) {
+      await this.repository.destroy({
+        filter: {
+          name: pluginNames
+        }
+      });
+    } else {
+      await this.app.load();
+      for (const pluginName of pluginNames) {
+        const plugin = this.get(pluginName);
+        if (!plugin) {
+          continue;
+        }
+        if (plugin.enabled) {
+          throw new Error(`plugin is enabled [${pluginName}]`);
+        }
+        await plugin.beforeRemove();
+      }
+      await this.repository.destroy({
+        filter: {
+          name: pluginNames
+        }
+      });
+      const plugins = [];
+      for (const pluginName of pluginNames) {
+        const plugin = this.get(pluginName);
+        if (!plugin) {
+          continue;
+        }
+        plugins.push(plugin);
+        this.del(pluginName);
+        await plugin.afterRemove();
+      }
+      if (await this.app.isStarted()) {
+        await this.app.tryReloadOrRestart();
+      }
+    }
+    if (options == null ? void 0 : options.removeDir) {
+      await removeDir();
+    }
+    await (0, import_execa.default)("pnpm", ["tachybase", "refresh"]);
+  }
+  /**
+   * @deprecated
+   */
+  async loadOne(plugin) {
+    this.app.setMaintainingMessage(`loading plugin ${plugin.name}...`);
+    if (plugin.state.loaded || !plugin.enabled) {
+      return;
+    }
+    const name = plugin.getName();
+    await plugin.beforeLoad();
+    await this.app.emitAsync("beforeLoadPlugin", plugin, {});
+    this.app.logger.debug(`loading plugin...`, { submodule: "plugin-manager", method: "loadOne", name });
+    await plugin.load();
+    plugin.state.loaded = true;
+    await this.app.emitAsync("afterLoadPlugin", plugin, {});
+    this.app.logger.debug(`after load plugin...`, { submodule: "plugin-manager", method: "loadOne", name });
+    this.app.setMaintainingMessage(`loaded plugin ${plugin.name}`);
+  }
+  /**
+   * @internal
+   */
+  async addViaCLI(urlOrName, options) {
+    if ((0, import_utils.isURL)(urlOrName)) {
+      await this.addByCompressedFileUrl({
+        ...options,
+        compressedFileUrl: urlOrName
+      });
+    } else if (await (0, import_utils.fsExists)(urlOrName)) {
+      await this.addByCompressedFileUrl({
+        ...options,
+        compressedFileUrl: urlOrName
+      });
+    } else if (options == null ? void 0 : options.registry) {
+      if (!options.name) {
+        const model = await this.repository.findOne({ filter: { packageName: urlOrName } });
+        if (model) {
+          options["name"] = model == null ? void 0 : model.name;
+        }
+        if (!options.name) {
+          options["name"] = urlOrName.replace("@tachybase/plugin-", "");
+        }
+      }
+      await this.addByNpm({
+        ...options,
+        packageName: urlOrName
+      });
+    } else {
+      const opts = {
+        ...options
+      };
+      const model = await this.repository.findOne({ filter: { packageName: urlOrName } });
+      if (model) {
+        opts["name"] = model.name;
+      }
+      if (!opts["packageName"]) {
+        opts["packageName"] = urlOrName;
+      }
+      await this.add(opts["name"] || urlOrName, opts, true);
+    }
+    await this.app.emitStartedEvent();
+    await (0, import_execa.default)("pnpm", ["tachybase", "postinstall"]);
+  }
+  /**
+   * @internal
+   */
+  async addByNpm(options) {
+    let { name = "", registry, packageName, authToken } = options;
+    name = name.trim();
+    registry = registry.trim();
+    packageName = packageName.trim();
+    authToken = authToken == null ? void 0 : authToken.trim();
+    const { compressedFileUrl } = await (0, import_utils2.getPluginInfoByNpm)({
+      packageName,
+      registry,
+      authToken
+    });
+    return this.addByCompressedFileUrl({ name, compressedFileUrl, registry, authToken, type: "npm" });
+  }
+  /**
+   * @internal
+   */
+  async addByFile(options) {
+    const { file, authToken } = options;
+    const { packageName, tempFile, tempPackageContentDir } = await (0, import_utils2.downloadAndUnzipToTempDir)(file, authToken);
+    const name = options.name || packageName;
+    if (this.has(name)) {
+      await (0, import_utils2.removeTmpDir)(tempFile, tempPackageContentDir);
+      throw new Error(`plugin name [${name}] already exists`);
+    }
+    await (0, import_utils2.copyTempPackageToStorageAndLinkToNodeModules)(tempFile, tempPackageContentDir, packageName);
+    return this.add(name, { packageName }, true);
+  }
+  /**
+   * @internal
+   */
+  async addByCompressedFileUrl(options) {
+    const { compressedFileUrl, authToken } = options;
+    const { packageName, tempFile, tempPackageContentDir } = await (0, import_utils2.downloadAndUnzipToTempDir)(
+      compressedFileUrl,
+      authToken
+    );
+    const name = options.name || packageName;
+    if (this.has(name)) {
+      await (0, import_utils2.removeTmpDir)(tempFile, tempPackageContentDir);
+      throw new Error(`plugin name [${name}] already exists`);
+    }
+    await (0, import_utils2.copyTempPackageToStorageAndLinkToNodeModules)(tempFile, tempPackageContentDir, packageName);
+    return this.add(name, { packageName }, true);
+  }
+  async update(options) {
+    if (options["url"]) {
+      options.compressedFileUrl = options["url"];
+    }
+    if (!options.name) {
+      const model = await this.repository.findOne({ filter: { packageName: options.packageName } });
+      options["name"] = model.name;
+    }
+    if (options.compressedFileUrl) {
+      await this.upgradeByCompressedFileUrl(options);
+    } else {
+      await this.upgradeByNpm(options);
+    }
+    const file = (0, import_node_path.resolve)(process.cwd(), "storage/app-upgrading");
+    await import_promises.default.writeFile(file, "", "utf-8");
+    await this.app.upgrade();
+  }
+  /**
+   * @internal
+   */
+  async upgradeByNpm(values) {
+    var _a, _b, _c;
+    const name = values.name;
+    const plugin = this.get(name);
+    if (!this.has(name)) {
+      throw new Error(`plugin name [${name}] not exists`);
+    }
+    if (!plugin.options.packageName || !values.registry) {
+      throw new Error(`plugin name [${name}] not installed by npm`);
+    }
+    const version = (_a = values.version) == null ? void 0 : _a.trim();
+    const registry = ((_b = values.registry) == null ? void 0 : _b.trim()) || plugin.options.registry;
+    const authToken = ((_c = values.authToken) == null ? void 0 : _c.trim()) || plugin.options.authToken;
+    const { compressedFileUrl } = await (0, import_utils2.getPluginInfoByNpm)({
+      packageName: plugin.options.packageName,
+      registry,
+      authToken,
+      version
+    });
+    return this.upgradeByCompressedFileUrl({ compressedFileUrl, name, version, registry, authToken });
+  }
+  /**
+   * @internal
+   */
+  async upgradeByCompressedFileUrl(options) {
+    const { name, compressedFileUrl, authToken } = options;
+    const data = await this.repository.findOne({ filter: { name } });
+    const { version } = await (0, import_utils2.updatePluginByCompressedFileUrl)({
+      compressedFileUrl,
+      packageName: data.packageName,
+      authToken
+    });
+    await this.add(name, { version, packageName: data.packageName }, true, true);
+  }
+  /**
+   * @internal
+   */
+  getNameByPackageName(packageName) {
+    const prefixes = _PluginManager.getPluginPkgPrefix();
+    const prefix = prefixes.find((prefix2) => packageName.startsWith(prefix2));
+    if (!prefix) {
+      throw new Error(
+        `package name [${packageName}] invalid, just support ${prefixes.join(
+          ", "
+        )}. You can modify process.env.PLUGIN_PACKAGE_PREFIX add more prefix.`
+      );
+    }
+    return packageName.replace(prefix, "");
+  }
+  async list(options = {}) {
+    const { locale = "en-US", isPreset = false } = options;
+    return Promise.all(
+      [...this.getAliases()].map((name) => {
+        const plugin = this.get(name);
+        if (!isPreset && plugin.options.isPreset) {
+          return;
+        }
+        return plugin.toJSON({ locale });
+      }).filter(Boolean)
+    );
+  }
+  /**
+   * @internal
+   */
+  async getNpmVersionList(name) {
+    const plugin = this.get(name);
+    const npmInfo = await (0, import_utils2.getNpmInfo)(plugin.options.packageName, plugin.options.registry, plugin.options.authToken);
+    return Object.keys(npmInfo.versions);
+  }
+  /**
+   * @internal
+   */
+  async loadPresetMigrations() {
+    const migrations = {
+      beforeLoad: [],
+      afterSync: [],
+      afterLoad: []
+    };
+    for (const [P, plugin] of this.getPlugins()) {
+      if (!plugin.isPreset) {
+        continue;
+      }
+      const { beforeLoad, afterSync, afterLoad } = await plugin.loadMigrations();
+      migrations.beforeLoad.push(...beforeLoad);
+      migrations.afterSync.push(...afterSync);
+      migrations.afterLoad.push(...afterLoad);
+    }
+    return {
+      beforeLoad: {
+        up: /* @__PURE__ */ __name(async () => {
+          this.app.logger.debug("run preset migrations(beforeLoad)");
+          const migrator = this.app.db.createMigrator({ migrations: migrations.beforeLoad });
+          await migrator.up();
+        }, "up")
+      },
+      afterSync: {
+        up: /* @__PURE__ */ __name(async () => {
+          this.app.logger.debug("run preset migrations(afterSync)");
+          const migrator = this.app.db.createMigrator({ migrations: migrations.afterSync });
+          await migrator.up();
+        }, "up")
+      },
+      afterLoad: {
+        up: /* @__PURE__ */ __name(async () => {
+          this.app.logger.debug("run preset migrations(afterLoad)");
+          const migrator = this.app.db.createMigrator({ migrations: migrations.afterLoad });
+          await migrator.up();
+        }, "up")
+      }
+    };
+  }
+  /**
+   * @internal
+   */
+  async loadOtherMigrations() {
+    const migrations = {
+      beforeLoad: [],
+      afterSync: [],
+      afterLoad: []
+    };
+    for (const [P, plugin] of this.getPlugins()) {
+      if (plugin.isPreset) {
+        continue;
+      }
+      if (!plugin.enabled) {
+        continue;
+      }
+      const { beforeLoad, afterSync, afterLoad } = await plugin.loadMigrations();
+      migrations.beforeLoad.push(...beforeLoad);
+      migrations.afterSync.push(...afterSync);
+      migrations.afterLoad.push(...afterLoad);
+    }
+    return {
+      beforeLoad: {
+        up: /* @__PURE__ */ __name(async () => {
+          this.app.logger.debug("run others migrations(beforeLoad)");
+          const migrator = this.app.db.createMigrator({ migrations: migrations.beforeLoad });
+          await migrator.up();
+        }, "up")
+      },
+      afterSync: {
+        up: /* @__PURE__ */ __name(async () => {
+          this.app.logger.debug("run others migrations(afterSync)");
+          const migrator = this.app.db.createMigrator({ migrations: migrations.afterSync });
+          await migrator.up();
+        }, "up")
+      },
+      afterLoad: {
+        up: /* @__PURE__ */ __name(async () => {
+          this.app.logger.debug("run others migrations(afterLoad)");
+          const migrator = this.app.db.createMigrator({ migrations: migrations.afterLoad });
+          await migrator.up();
+        }, "up")
+      }
+    };
+  }
+  /**
+   * @internal
+   */
+  async loadPresetPlugins() {
+    await this.initPresetPlugins();
+    await this.load();
+  }
+  async upgrade() {
+    this.app.logger.info("run upgrade");
+    const toBeUpdated = [];
+    for (const [P, plugin] of this.getPlugins()) {
+      if (plugin.state.upgraded) {
+        continue;
+      }
+      if (!plugin.enabled) {
+        continue;
+      }
+      if (!plugin.isPreset && !plugin.installed) {
+        this.app.logger.info(`install built-in plugin [${plugin.name}]`);
+        await plugin.install();
+        toBeUpdated.push(plugin.name);
+      }
+      this.app.logger.debug(`upgrade plugin [${plugin.name}]`);
+      await plugin.upgrade();
+      for (const feature of plugin.featureInstances) {
+        await feature.upgrade();
+      }
+      plugin.state.upgraded = true;
+    }
+    await this.repository.update({
+      filter: {
+        name: toBeUpdated
+      },
+      values: {
+        installed: true
+      }
+    });
+  }
+  /**
+   * @internal
+   */
+  async initOtherPlugins() {
+    if (this["_initOtherPlugins"]) {
+      return;
+    }
+    await this.repository.init();
+    this["_initOtherPlugins"] = true;
+  }
+  /**
+   * @internal
+   */
+  async initPresetPlugins() {
+    if (this["_initPresetPlugins"]) {
+      return;
+    }
+    for (const plugin of this.options.plugins) {
+      const [p, opts = {}] = Array.isArray(plugin) ? plugin : [plugin];
+      await this.add(p, { enabled: true, isPreset: true, ...opts });
+    }
+    this["_initPresetPlugins"] = true;
+  }
+  /**
+   * @internal
+   */
+  async initRuntimePlugins() {
+    if (this["_initRuntimePlugins"]) {
+      return;
+    }
+    if (process.env.RUNTIME_PLUGINS) {
+      const runtimePlugins = process.env.RUNTIME_PLUGINS.split(",");
+      for (const plugin of runtimePlugins) {
+        await this.add(plugin, { enabled: true });
+      }
+    }
+    this["_initRuntimePlugins"] = true;
+  }
+};
+__name(_PluginManager, "PluginManager");
+let PluginManager = _PluginManager;
+var plugin_manager_default = PluginManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddPresetError,
+  PluginManager,
+  sleep
+});