@tachybase/test 1.6.12 → 1.6.13-alpha.3

package/lib/server/index.js

@@ -40,13 +40,36 @@ __export(server_exports, {
 });
 module.exports = __toCommonJS(server_exports);
 var import_globals = __toESM(require("@tachybase/globals"));
-var import_vitest = require("vitest");
 var import_ws = __toESM(require("ws"));
 var import_database = require("@tachybase/database");
 var import_supertest = __toESM(require("supertest"));
 __reExport(server_exports, require("./mockServer"), module.exports);
-const pgOnly = /* @__PURE__ */ __name(() => import_globals.default.settings.database.dialect === "postgres" ? import_vitest.describe : import_vitest.describe.skip, "pgOnly");
-const isPg = /* @__PURE__ */ __name(() => import_globals.default.settings.database.dialect === "postgres", "isPg");
+__reExport(server_exports, require("./setupTestEnvironment"), module.exports);
+const noopDescribe = /* @__PURE__ */ __name(() => {
+}, "noopDescribe");
+function getDescribe() {
+  const desc = globalThis.describe;
+  if (!desc) {
+    throw new Error(
+      "globalThis.describe is not available. Ensure your test runner (vitest/jest) provides it globally or configure globals: true."
+    );
+  }
+  return desc;
+}
+__name(getDescribe, "getDescribe");
+const pgOnly = /* @__PURE__ */ __name(() => {
+  var _a, _b;
+  const isPostgres = ((_b = (_a = import_globals.default.settings) == null ? void 0 : _a.database) == null ? void 0 : _b.dialect) === "postgres";
+  const desc = getDescribe();
+  if (isPostgres) {
+    return desc;
+  }
+  return desc.skip || noopDescribe;
+}, "pgOnly");
+const isPg = /* @__PURE__ */ __name(() => {
+  var _a, _b;
+  return ((_b = (_a = import_globals.default.settings) == null ? void 0 : _a.database) == null ? void 0 : _b.dialect) === "postgres";
+}, "isPg");
 function randomStr() {
   return Math.random().toString(36).substring(2);
 }
@@ -102,5 +125,6 @@ const createWsClient = /* @__PURE__ */ __name(async ({ serverPort, options = {}
   startServerWithRandomPort,
   supertest,
   waitSecond,
-  ...require("./mockServer")
+  ...require("./mockServer"),
+  ...require("./setupTestEnvironment")
 });

package/lib/server/mockServer.js

@@ -78,10 +78,11 @@ const _MockServer = class _MockServer extends import_core.Application {
       get(target, method, receiver) {
         if (["login", "loginUsingId"].includes(method)) {
           return (userOrId) => {
+            var _a;
             return proxy.auth(
               import_jsonwebtoken.default.sign(
                 {
-                  userId: typeof userOrId === "number" ? userOrId : userOrId == null ? void 0 : userOrId.id
+                  userId: typeof userOrId === "number" ? userOrId : (userOrId == null ? void 0 : userOrId.id) ?? ((_a = userOrId == null ? void 0 : userOrId.get) == null ? void 0 : _a.call(userOrId, "id"))
                 },
                 process.env.APP_KEY,
                 {
@@ -196,6 +197,47 @@ async function createMockServer(options = {}) {
   if (!skipStart) {
     await app.runCommandThrowError("start");
   }
+  if (!app.authManager.tokenController) {
+    app.authManager.setTokenControlService({
+      async getConfig() {
+        return {
+          tokenExpirationTime: 24 * 60 * 60 * 1e3,
+          sessionExpirationTime: 7 * 24 * 60 * 60 * 1e3,
+          expiredTokenRenewLimit: 24 * 60 * 60 * 1e3
+        };
+      },
+      async setConfig() {
+      },
+      async renew() {
+        return {
+          jti: `test-jti-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+          issuedTime: Date.now()
+        };
+      },
+      async add({ userId }) {
+        return {
+          jti: `test-jti-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+          userId,
+          issuedTime: Date.now(),
+          signInTime: Date.now(),
+          renewed: false
+        };
+      },
+      async removeSessionExpiredTokens() {
+      }
+    });
+  }
+  if (!app.authManager.userStatusService) {
+    app.authManager.setUserStatusService({
+      async checkUserStatus() {
+        return {
+          allowed: true,
+          status: "active",
+          isExpired: false
+        };
+      }
+    });
+  }
   return app;
 }
 __name(createMockServer, "createMockServer");

package/lib/server/setupTestEnvironment.d.ts

@@ -0,0 +1,8 @@
+export interface ServerTestEnvironmentOptions {
+    workspaceRoot?: string;
+    pluginPaths?: string[];
+    packageDirByPluginName?: Record<string, string>;
+    disableRuntimePlugins?: boolean;
+    disableOtherPlugins?: boolean;
+}
+export declare function setupServerTestEnvironment(options?: ServerTestEnvironmentOptions): void;

package/lib/server/setupTestEnvironment.js

@@ -0,0 +1,443 @@
+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 setupTestEnvironment_exports = {};
+__export(setupTestEnvironment_exports, {
+  setupServerTestEnvironment: () => setupServerTestEnvironment
+});
+module.exports = __toCommonJS(setupTestEnvironment_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_module = require("node:module");
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_url = require("node:url");
+var import_globals = __toESM(require("@tachybase/globals"));
+const runtimeRequire = (0, import_node_module.createRequire)(import_node_path.default.resolve(process.cwd(), "package.json"));
+const selfRequire = (0, import_node_module.createRequire)(require.resolve("@tachybase/test/package.json"));
+const workspacePluginNameAliases = {
+  map: "block-map"
+};
+const ImportedTachybaseGlobal = import_globals.default.getInstance ? import_globals.default : import_globals.default.default;
+const testUnsafeBuiltinPlugins = /* @__PURE__ */ new Set(["event-source", "worker-thread"]);
+function createRuntimeRequire(workspaceRoot) {
+  const hostPackageJson = import_node_path.default.resolve(workspaceRoot, "package.json");
+  if (import_node_fs.default.existsSync(hostPackageJson)) {
+    return (0, import_node_module.createRequire)(hostPackageJson);
+  }
+  return runtimeRequire;
+}
+__name(createRuntimeRequire, "createRuntimeRequire");
+function getTachybaseGlobal(runtimeRequire2) {
+  try {
+    const tachybaseGlobalModule = runtimeRequire2("@tachybase/globals");
+    return tachybaseGlobalModule.getInstance ? tachybaseGlobalModule : tachybaseGlobalModule.default;
+  } catch (error) {
+    if (error.code === "MODULE_NOT_FOUND") {
+      return ImportedTachybaseGlobal;
+    }
+    throw error;
+  }
+}
+__name(getTachybaseGlobal, "getTachybaseGlobal");
+function getCoreModules() {
+  const cores = [];
+  try {
+    cores.push(selfRequire("@tego/core"));
+  } catch (e) {
+    if ((e == null ? void 0 : e.code) !== "MODULE_NOT_FOUND") throw e;
+  }
+  try {
+    cores.push(selfRequire("@tego/server"));
+    cores.push((0, import_node_module.createRequire)(selfRequire.resolve("@tego/server/package.json"))("@tego/core"));
+  } catch (e) {
+    if ((e == null ? void 0 : e.code) !== "MODULE_NOT_FOUND") throw e;
+  }
+  return [...new Set(cores)];
+}
+__name(getCoreModules, "getCoreModules");
+function createTestDbStorage() {
+  const testDbName = `test-${Date.now()}-${Math.random().toString(36).slice(2)}.sqlite`;
+  const testDbDir = import_node_path.default.join(import_node_os.default.tmpdir(), "tego-test");
+  import_node_fs.default.mkdirSync(testDbDir, { recursive: true });
+  return import_node_path.default.join(testDbDir, testDbName);
+}
+__name(createTestDbStorage, "createTestDbStorage");
+function workspacePackageNameByShortName(workspaceRoot, name, map) {
+  const normalizedName = workspacePluginNameAliases[name] || name;
+  const candidates = [map[name], map[normalizedName], `module-${normalizedName}`, `plugin-${normalizedName}`].filter(
+    Boolean
+  );
+  for (const packageDir of candidates) {
+    const packageJsonPath = import_node_path.default.resolve(workspaceRoot, "packages", packageDir, "package.json");
+    if (import_node_fs.default.existsSync(packageJsonPath)) {
+      const packageJson = runtimeRequire(packageJsonPath);
+      return packageJson.name;
+    }
+  }
+  return null;
+}
+__name(workspacePackageNameByShortName, "workspacePackageNameByShortName");
+function workspacePackageDirByPackageName(workspaceRoot, packageName, map = {}) {
+  if (!packageName) {
+    return null;
+  }
+  const mappedPackageDir = Object.values(map).find((packageDir2) => {
+    const packageJsonPath2 = import_node_path.default.resolve(workspaceRoot, "packages", packageDir2, "package.json");
+    return import_node_fs.default.existsSync(packageJsonPath2) && runtimeRequire(packageJsonPath2).name === packageName;
+  });
+  if (mappedPackageDir) {
+    return mappedPackageDir;
+  }
+  const packageDir = packageName.replace("@tachybase/", "");
+  const packageJsonPath = import_node_path.default.resolve(workspaceRoot, "packages", packageDir, "package.json");
+  return import_node_fs.default.existsSync(packageJsonPath) ? packageDir : null;
+}
+__name(workspacePackageDirByPackageName, "workspacePackageDirByPackageName");
+function workspaceServerEntry(workspaceRoot, packageDir) {
+  const libEntry = import_node_path.default.resolve(workspaceRoot, "packages", packageDir, "lib/server/index.js");
+  if (import_node_fs.default.existsSync(libEntry)) {
+    return libEntry;
+  }
+  const distEntry = import_node_path.default.resolve(workspaceRoot, "packages", packageDir, "dist/server/index.js");
+  if (import_node_fs.default.existsSync(distEntry)) {
+    return distEntry;
+  }
+  const sourceEntry = import_node_path.default.resolve(workspaceRoot, "packages", packageDir, "src/server/index.ts");
+  if (import_node_fs.default.existsSync(sourceEntry)) {
+    return sourceEntry;
+  }
+  return null;
+}
+__name(workspaceServerEntry, "workspaceServerEntry");
+function getModuleDefault(mod) {
+  var _a;
+  return ((_a = mod == null ? void 0 : mod.default) == null ? void 0 : _a.default) || (mod == null ? void 0 : mod.default) || mod;
+}
+__name(getModuleDefault, "getModuleDefault");
+function getServerTestEnvironmentOptions(core) {
+  return core.Plugin.__serverTestEnvironmentOptions;
+}
+__name(getServerTestEnvironmentOptions, "getServerTestEnvironmentOptions");
+function patchPluginRuntime(core, workspaceRoot, packageDirByPluginName) {
+  core.Plugin.__serverTestEnvironmentOptions = { workspaceRoot, packageDirByPluginName };
+  if (core.Plugin.prototype.__serverTestEnvironmentPatched) {
+    return;
+  }
+  const originalLoadCollections = core.Plugin.prototype.loadCollections;
+  core.Plugin.prototype.loadCollections = /* @__PURE__ */ __name(async function loadWorkspaceCollections() {
+    var _a, _b;
+    const currentOptions = getServerTestEnvironmentOptions(core);
+    const currentWorkspaceRoot = (currentOptions == null ? void 0 : currentOptions.workspaceRoot) || workspaceRoot;
+    const currentPackageDirByPluginName = (currentOptions == null ? void 0 : currentOptions.packageDirByPluginName) || packageDirByPluginName;
+    const packageDir = ((_a = this.options) == null ? void 0 : _a.workspaceSource) ? workspacePackageDirByPackageName(currentWorkspaceRoot, (_b = this.options) == null ? void 0 : _b.packageName, currentPackageDirByPluginName) : null;
+    if (!packageDir) {
+      return originalLoadCollections.call(this);
+    }
+    const sourceDirectory = import_node_path.default.resolve(currentWorkspaceRoot, "packages", packageDir, "src/server/collections");
+    const compiledDirectory = import_node_path.default.resolve(currentWorkspaceRoot, "packages", packageDir, "dist/server/collections");
+    const directory = import_node_fs.default.existsSync(compiledDirectory) ? compiledDirectory : sourceDirectory;
+    if (!import_node_fs.default.existsSync(directory)) {
+      return;
+    }
+    await this.db.import({
+      directory,
+      from: this.options.packageName
+    });
+  }, "loadWorkspaceCollections");
+  core.Plugin.prototype.__serverTestEnvironmentPatched = true;
+}
+__name(patchPluginRuntime, "patchPluginRuntime");
+function getPluginManagerOptions(PluginManager) {
+  return PluginManager.__serverTestEnvironmentOptions;
+}
+__name(getPluginManagerOptions, "getPluginManagerOptions");
+function patchPluginManager(core, options) {
+  const PluginManager = core.PluginManager;
+  PluginManager.__serverTestEnvironmentOptions = options;
+  if (PluginManager.__serverTestEnvironmentPatchVersion === 2) {
+    return;
+  }
+  const resolvePlugin = (PluginManager.__serverTestEnvironmentOriginalResolvePlugin || PluginManager.resolvePlugin).bind(PluginManager);
+  const originalGetPackageName = (PluginManager.__serverTestEnvironmentOriginalGetPackageName || PluginManager.getPackageName).bind(PluginManager);
+  const originalAdd = PluginManager.__serverTestEnvironmentOriginalAdd || PluginManager.prototype.add;
+  const originalEnable = PluginManager.__serverTestEnvironmentOriginalEnable || PluginManager.prototype.enable;
+  const originalInitRuntimePlugins = PluginManager.__serverTestEnvironmentOriginalInitRuntimePlugins || PluginManager.prototype.initRuntimePlugins;
+  const originalInitOtherPlugins = PluginManager.__serverTestEnvironmentOriginalInitOtherPlugins || PluginManager.prototype.initOtherPlugins;
+  PluginManager.__serverTestEnvironmentOriginalResolvePlugin = resolvePlugin;
+  PluginManager.__serverTestEnvironmentOriginalGetPackageName = originalGetPackageName;
+  PluginManager.__serverTestEnvironmentOriginalAdd = originalAdd;
+  PluginManager.__serverTestEnvironmentOriginalEnable = originalEnable;
+  PluginManager.__serverTestEnvironmentOriginalInitRuntimePlugins = originalInitRuntimePlugins;
+  PluginManager.__serverTestEnvironmentOriginalInitOtherPlugins = originalInitOtherPlugins;
+  const workspaceSourcePackages = /* @__PURE__ */ new Set();
+  PluginManager.getPackageName = async (name) => {
+    const currentOptions = getPluginManagerOptions(PluginManager);
+    const currentWorkspaceRoot = (currentOptions == null ? void 0 : currentOptions.workspaceRoot) || process.cwd();
+    const currentPackageDirByPluginName = (currentOptions == null ? void 0 : currentOptions.packageDirByPluginName) || {};
+    const workspacePackageName = workspacePackageNameByShortName(
+      currentWorkspaceRoot,
+      name,
+      currentPackageDirByPluginName
+    );
+    return workspacePackageName || originalGetPackageName(name);
+  };
+  PluginManager.getPackageJson = async (packageName) => {
+    const currentOptions = getPluginManagerOptions(PluginManager);
+    const currentWorkspaceRoot = (currentOptions == null ? void 0 : currentOptions.workspaceRoot) || process.cwd();
+    const currentPackageDirByPluginName = (currentOptions == null ? void 0 : currentOptions.packageDirByPluginName) || {};
+    const packageDir = workspacePackageDirByPackageName(
+      currentWorkspaceRoot,
+      packageName,
+      currentPackageDirByPluginName
+    );
+    if (packageDir) {
+      return runtimeRequire(import_node_path.default.resolve(currentWorkspaceRoot, "packages", packageDir, "package.json"));
+    }
+    return runtimeRequire(runtimeRequire.resolve(import_node_path.default.join(packageName, "package.json")));
+  };
+  PluginManager.resolvePlugin = async (pluginName, isUpgrade = false, isPkg = false) => {
+    if (typeof pluginName !== "string") {
+      return pluginName;
+    }
+    const packageName = isPkg ? pluginName : await PluginManager.getPackageName(pluginName);
+    if (workspaceSourcePackages.has(packageName)) {
+      const currentOptions = getPluginManagerOptions(PluginManager);
+      const currentWorkspaceRoot = (currentOptions == null ? void 0 : currentOptions.workspaceRoot) || process.cwd();
+      const currentPackageDirByPluginName = (currentOptions == null ? void 0 : currentOptions.packageDirByPluginName) || {};
+      const packageDir = workspacePackageDirByPackageName(
+        currentWorkspaceRoot,
+        packageName,
+        currentPackageDirByPluginName
+      );
+      const entry = packageDir ? workspaceServerEntry(currentWorkspaceRoot, packageDir) : null;
+      if (entry) {
+        const mod = await import((0, import_node_url.pathToFileURL)(entry).href);
+        return getModuleDefault(mod);
+      }
+      return resolvePlugin(packageName, isUpgrade, true);
+    }
+    return resolvePlugin(pluginName, isUpgrade, isPkg);
+  };
+  PluginManager.prototype.initRuntimePlugins = /* @__PURE__ */ __name(async function initTestRuntimePlugins() {
+    const currentOptions = getPluginManagerOptions(PluginManager);
+    if (currentOptions == null ? void 0 : currentOptions.disableRuntimePlugins) {
+      this["_initRuntimePlugins"] = true;
+      return;
+    }
+    return originalInitRuntimePlugins.call(this);
+  }, "initTestRuntimePlugins");
+  PluginManager.prototype.initOtherPlugins = /* @__PURE__ */ __name(async function initTestOtherPlugins() {
+    const currentOptions = getPluginManagerOptions(PluginManager);
+    if (currentOptions == null ? void 0 : currentOptions.disableOtherPlugins) {
+      this["_initOtherPlugins"] = true;
+      return;
+    }
+    return originalInitOtherPlugins.call(this);
+  }, "initTestOtherPlugins");
+  PluginManager.prototype.add = /* @__PURE__ */ __name(async function addWorkspaceSourcePlugin(plugin, pluginOptions = {}, insert = false, isUpgrade = false) {
+    if (typeof plugin === "string" && (pluginOptions == null ? void 0 : pluginOptions.workspaceSource) && (pluginOptions == null ? void 0 : pluginOptions.packageName)) {
+      const currentOptions = getPluginManagerOptions(PluginManager);
+      const currentWorkspaceRoot = (currentOptions == null ? void 0 : currentOptions.workspaceRoot) || process.cwd();
+      const currentPackageDirByPluginName = (currentOptions == null ? void 0 : currentOptions.packageDirByPluginName) || {};
+      const packageDir = workspacePackageDirByPackageName(
+        currentWorkspaceRoot,
+        pluginOptions.packageName,
+        currentPackageDirByPluginName
+      );
+      const entry = packageDir ? workspaceServerEntry(currentWorkspaceRoot, packageDir) : null;
+      if (entry) {
+        const mod = await import((0, import_node_url.pathToFileURL)(entry).href);
+        return originalAdd.call(this, getModuleDefault(mod), pluginOptions, insert, isUpgrade);
+      }
+    }
+    return originalAdd.call(this, plugin, pluginOptions, insert, isUpgrade);
+  }, "addWorkspaceSourcePlugin");
+  PluginManager.prototype.enable = /* @__PURE__ */ __name(async function enableWorkspacePlugin(name) {
+    const normalize = /* @__PURE__ */ __name((pluginName) => workspacePluginNameAliases[pluginName] || pluginName, "normalize");
+    const normalizedName = Array.isArray(name) ? name.map(normalize) : normalize(name);
+    return originalEnable.call(this, normalizedName);
+  }, "enableWorkspacePlugin");
+  PluginManager.prototype.initPresetPlugins = /* @__PURE__ */ __name(async function initWorkspacePresetPlugins() {
+    var _a, _b;
+    if (this["_initPresetPlugins"]) {
+      return;
+    }
+    const addWorkspacePlugin = /* @__PURE__ */ __name(async (pluginName, pluginOptions = {}) => {
+      const normalizedPluginName = typeof pluginName === "string" ? workspacePluginNameAliases[pluginName] || pluginName : pluginName;
+      const currentOptions = getPluginManagerOptions(PluginManager);
+      const currentWorkspaceRoot = (currentOptions == null ? void 0 : currentOptions.workspaceRoot) || process.cwd();
+      const currentPackageDirByPluginName = (currentOptions == null ? void 0 : currentOptions.packageDirByPluginName) || {};
+      const packageName = typeof pluginName === "string" ? workspacePackageNameByShortName(currentWorkspaceRoot, pluginName, currentPackageDirByPluginName) : null;
+      if (packageName) {
+        workspaceSourcePackages.add(packageName);
+        const packageDir = workspacePackageDirByPackageName(
+          currentWorkspaceRoot,
+          packageName,
+          currentPackageDirByPluginName
+        );
+        const entry = packageDir ? workspaceServerEntry(currentWorkspaceRoot, packageDir) : null;
+        if (entry) {
+          const mod = await import((0, import_node_url.pathToFileURL)(entry).href);
+          const P = getModuleDefault(mod);
+          await this.add(P, {
+            name: pluginName,
+            ...pluginOptions,
+            packageName,
+            workspaceSource: true
+          });
+        } else {
+          await this.add(normalizedPluginName, {
+            name: pluginName,
+            ...pluginOptions,
+            packageName,
+            workspaceSource: true
+          });
+        }
+      } else if (typeof pluginName === "function") {
+        await this.add(pluginName, pluginOptions);
+      } else {
+        await this.add(normalizedPluginName, { name: pluginName, isPreset: true, ...pluginOptions });
+      }
+    }, "addWorkspacePlugin");
+    const addTachybasePresetPlugin = /* @__PURE__ */ __name(async (pluginName, pluginOptions = {}) => {
+      if (testUnsafeBuiltinPlugins.has(pluginName)) {
+        return;
+      }
+      await addWorkspacePlugin(pluginName, { enabled: true, ...pluginOptions });
+    }, "addTachybasePresetPlugin");
+    const addTachybaseExternalPlugin = /* @__PURE__ */ __name(async (plugin, pluginOptions = {}) => {
+      const pluginName = typeof plugin === "string" ? plugin : plugin == null ? void 0 : plugin.name;
+      if (!pluginName || testUnsafeBuiltinPlugins.has(pluginName)) {
+        return;
+      }
+      await addWorkspacePlugin(pluginName, { enabled: !!(plugin == null ? void 0 : plugin.enabledByDefault), ...pluginOptions });
+    }, "addTachybaseExternalPlugin");
+    for (const plugin of this.options.plugins || []) {
+      const [pluginName, pluginOptions = {}] = Array.isArray(plugin) ? plugin : [plugin];
+      if (pluginName === "tachybase") {
+        const currentOptions = getPluginManagerOptions(PluginManager);
+        const currentSettings = (currentOptions == null ? void 0 : currentOptions.settings) || options.settings;
+        for (const builtinPlugin of ((_a = currentSettings == null ? void 0 : currentSettings.presets) == null ? void 0 : _a.builtinPlugins) || []) {
+          await addTachybasePresetPlugin(builtinPlugin, pluginOptions);
+        }
+        for (const externalPlugin of ((_b = currentSettings == null ? void 0 : currentSettings.presets) == null ? void 0 : _b.externalPlugins) || []) {
+          await addTachybaseExternalPlugin(externalPlugin, pluginOptions);
+        }
+        continue;
+      }
+      await addWorkspacePlugin(pluginName, { enabled: true, ...pluginOptions });
+    }
+    this["_initPresetPlugins"] = true;
+  }, "initWorkspacePresetPlugins");
+  PluginManager.__serverTestEnvironmentPatchVersion = 2;
+  PluginManager.__serverTestEnvironmentPatchOptions = options;
+  PluginManager.findPackagePatched = true;
+}
+__name(patchPluginManager, "patchPluginManager");
+function patchAppSupervisor(core, options) {
+  const AppSupervisor = core.AppSupervisor;
+  if (!(AppSupervisor == null ? void 0 : AppSupervisor.getInstance)) {
+    return;
+  }
+  AppSupervisor.__serverTestEnvironmentOptions = options;
+  if (AppSupervisor.__serverTestEnvironmentPatchVersion === 1) {
+    return;
+  }
+  const supervisor = AppSupervisor.getInstance();
+  const originalAddApp = supervisor.addApp.bind(supervisor);
+  supervisor.addApp = (app) => {
+    var _a;
+    if ((_a = app == null ? void 0 : app.pm) == null ? void 0 : _a.constructor) {
+      patchPluginManager(
+        {
+          PluginManager: app.pm.constructor
+        },
+        AppSupervisor.__serverTestEnvironmentOptions
+      );
+    }
+    return originalAddApp(app);
+  };
+  AppSupervisor.__serverTestEnvironmentPatchVersion = 1;
+}
+__name(patchAppSupervisor, "patchAppSupervisor");
+function setupServerTestEnvironment(options = {}) {
+  var _a;
+  const workspaceRoot = options.workspaceRoot || process.cwd();
+  const pluginPaths = options.pluginPaths || [];
+  const packageDirByPluginName = options.packageDirByPluginName || {};
+  const runtimeRequire2 = createRuntimeRequire(workspaceRoot);
+  const TachybaseGlobal = getTachybaseGlobal(runtimeRequire2);
+  const settings = runtimeRequire2("tego/presets/settings");
+  const testSettings = {
+    ...settings,
+    env: {
+      ...settings.env,
+      APP_ENV: "test"
+    },
+    logger: {
+      ...settings.logger,
+      level: "error"
+    },
+    database: {
+      dialect: ((_a = settings.database) == null ? void 0 : _a.dialect) || "sqlite",
+      ...settings.database,
+      storage: createTestDbStorage()
+    },
+    presets: {
+      ...settings.presets,
+      runtimePlugins: options.disableRuntimePlugins ? [] : settings.presets.runtimePlugins
+    }
+  };
+  ImportedTachybaseGlobal.settings = testSettings;
+  TachybaseGlobal.settings = testSettings;
+  ImportedTachybaseGlobal.getInstance().set("PLUGIN_PATHS", pluginPaths);
+  TachybaseGlobal.getInstance().set("PLUGIN_PATHS", pluginPaths);
+  process.env.TEGO_RUNTIME_HOME = import_node_path.default.join(import_node_os.default.tmpdir(), "test-sqlite");
+  process.env.APP_ENV_PATH = process.env.APP_ENV_PATH || ".env.test";
+  const coreModules = getCoreModules();
+  for (const core of coreModules) {
+    patchPluginRuntime(core, workspaceRoot, packageDirByPluginName);
+    patchPluginManager(core, {
+      ...options,
+      workspaceRoot,
+      packageDirByPluginName,
+      settings: testSettings
+    });
+    patchAppSupervisor(core, {
+      ...options,
+      workspaceRoot,
+      packageDirByPluginName,
+      settings: testSettings
+    });
+  }
+}
+__name(setupServerTestEnvironment, "setupServerTestEnvironment");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupServerTestEnvironment
+});

package/lib/setup-server.d.ts

@@ -0,0 +1 @@
+export * from './server/setupTestEnvironment';

package/lib/setup-server.js

@@ -0,0 +1,21 @@
+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 setup_server_exports = {};
+module.exports = __toCommonJS(setup_server_exports);
+__reExport(setup_server_exports, require("./server/setupTestEnvironment"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./server/setupTestEnvironment")
+});

package/lib/vitest.d.ts

@@ -0,0 +1,11 @@
+export interface TegoVitestConfigOptions {
+    server?: {
+        setupFile?: string;
+    };
+    client?: {
+        setupFile?: string;
+    };
+}
+export declare function defineTegoVitestConfig(options?: TegoVitestConfigOptions): import("vite").UserConfig & Promise<import("vite").UserConfig> & (import("vitest/config.js").UserConfigFnObject & import("vitest/config.js").UserConfigExport);
+declare const _default: import("vite").UserConfig & Promise<import("vite").UserConfig> & (import("vitest/config.js").UserConfigFnObject & import("vitest/config.js").UserConfigExport);
+export default _default;