@tachybase/test 1.6.12 → 1.6.13-alpha.3

package/es/index.mjs

@@ -1,5 +1,4 @@
-import TachybaseGlobal from "@tachybase/globals";
-import { describe } from "vitest";
+import TachybaseGlobalModule from "@tachybase/globals";
 import ws from "ws";
 import { mockDatabase } from "@tachybase/database";
 import { mockDatabase as mockDatabase2 } from "@tachybase/database";
@@ -8,6 +7,11 @@ import { default as default2 } from "supertest";
 import { Application, Gateway, AppSupervisor, PluginManager } from "@tego/core";
 import jwt from "jsonwebtoken";
 import qs from "qs";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
 class MockServer extends Application {
   async loadAndInstall(options = {}) {
     await this.load({ method: "install" });
@@ -46,10 +50,11 @@ class MockServer extends Application {
       get(target, method, receiver) {
         if (["login", "loginUsingId"].includes(method)) {
           return (userOrId) => {
+            var _a;
             return proxy.auth(
               jwt.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,
                 {
@@ -160,10 +165,459 @@ 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;
 }
-const pgOnly = () => TachybaseGlobal.settings.database.dialect === "postgres" ? describe : describe.skip;
-const isPg = () => TachybaseGlobal.settings.database.dialect === "postgres";
+const runtimeRequire = createRequire(path.resolve(process.cwd(), "package.json"));
+const selfRequire = createRequire(require.resolve("@tachybase/test/package.json"));
+const workspacePluginNameAliases = {
+  map: "block-map"
+};
+const ImportedTachybaseGlobal = TachybaseGlobalModule.getInstance ? TachybaseGlobalModule : TachybaseGlobalModule.default;
+const testUnsafeBuiltinPlugins = /* @__PURE__ */ new Set(["event-source", "worker-thread"]);
+function createRuntimeRequire(workspaceRoot) {
+  const hostPackageJson = path.resolve(workspaceRoot, "package.json");
+  if (fs.existsSync(hostPackageJson)) {
+    return createRequire(hostPackageJson);
+  }
+  return runtimeRequire;
+}
+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;
+  }
+}
+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(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)];
+}
+function createTestDbStorage() {
+  const testDbName = `test-${Date.now()}-${Math.random().toString(36).slice(2)}.sqlite`;
+  const testDbDir = path.join(os.tmpdir(), "tego-test");
+  fs.mkdirSync(testDbDir, { recursive: true });
+  return path.join(testDbDir, testDbName);
+}
+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 = path.resolve(workspaceRoot, "packages", packageDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = runtimeRequire(packageJsonPath);
+      return packageJson.name;
+    }
+  }
+  return null;
+}
+function workspacePackageDirByPackageName(workspaceRoot, packageName, map = {}) {
+  if (!packageName) {
+    return null;
+  }
+  const mappedPackageDir = Object.values(map).find((packageDir2) => {
+    const packageJsonPath2 = path.resolve(workspaceRoot, "packages", packageDir2, "package.json");
+    return fs.existsSync(packageJsonPath2) && runtimeRequire(packageJsonPath2).name === packageName;
+  });
+  if (mappedPackageDir) {
+    return mappedPackageDir;
+  }
+  const packageDir = packageName.replace("@tachybase/", "");
+  const packageJsonPath = path.resolve(workspaceRoot, "packages", packageDir, "package.json");
+  return fs.existsSync(packageJsonPath) ? packageDir : null;
+}
+function workspaceServerEntry(workspaceRoot, packageDir) {
+  const libEntry = path.resolve(workspaceRoot, "packages", packageDir, "lib/server/index.js");
+  if (fs.existsSync(libEntry)) {
+    return libEntry;
+  }
+  const distEntry = path.resolve(workspaceRoot, "packages", packageDir, "dist/server/index.js");
+  if (fs.existsSync(distEntry)) {
+    return distEntry;
+  }
+  const sourceEntry = path.resolve(workspaceRoot, "packages", packageDir, "src/server/index.ts");
+  if (fs.existsSync(sourceEntry)) {
+    return sourceEntry;
+  }
+  return null;
+}
+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;
+}
+function getServerTestEnvironmentOptions(core) {
+  return core.Plugin.__serverTestEnvironmentOptions;
+}
+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 = 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 = path.resolve(currentWorkspaceRoot, "packages", packageDir, "src/server/collections");
+    const compiledDirectory = path.resolve(currentWorkspaceRoot, "packages", packageDir, "dist/server/collections");
+    const directory = fs.existsSync(compiledDirectory) ? compiledDirectory : sourceDirectory;
+    if (!fs.existsSync(directory)) {
+      return;
+    }
+    await this.db.import({
+      directory,
+      from: this.options.packageName
+    });
+  };
+  core.Plugin.prototype.__serverTestEnvironmentPatched = true;
+}
+function getPluginManagerOptions(PluginManager2) {
+  return PluginManager2.__serverTestEnvironmentOptions;
+}
+function patchPluginManager(core, options) {
+  const PluginManager2 = core.PluginManager;
+  PluginManager2.__serverTestEnvironmentOptions = options;
+  if (PluginManager2.__serverTestEnvironmentPatchVersion === 2) {
+    return;
+  }
+  const resolvePlugin = (PluginManager2.__serverTestEnvironmentOriginalResolvePlugin || PluginManager2.resolvePlugin).bind(PluginManager2);
+  const originalGetPackageName = (PluginManager2.__serverTestEnvironmentOriginalGetPackageName || PluginManager2.getPackageName).bind(PluginManager2);
+  const originalAdd = PluginManager2.__serverTestEnvironmentOriginalAdd || PluginManager2.prototype.add;
+  const originalEnable = PluginManager2.__serverTestEnvironmentOriginalEnable || PluginManager2.prototype.enable;
+  const originalInitRuntimePlugins = PluginManager2.__serverTestEnvironmentOriginalInitRuntimePlugins || PluginManager2.prototype.initRuntimePlugins;
+  const originalInitOtherPlugins = PluginManager2.__serverTestEnvironmentOriginalInitOtherPlugins || PluginManager2.prototype.initOtherPlugins;
+  PluginManager2.__serverTestEnvironmentOriginalResolvePlugin = resolvePlugin;
+  PluginManager2.__serverTestEnvironmentOriginalGetPackageName = originalGetPackageName;
+  PluginManager2.__serverTestEnvironmentOriginalAdd = originalAdd;
+  PluginManager2.__serverTestEnvironmentOriginalEnable = originalEnable;
+  PluginManager2.__serverTestEnvironmentOriginalInitRuntimePlugins = originalInitRuntimePlugins;
+  PluginManager2.__serverTestEnvironmentOriginalInitOtherPlugins = originalInitOtherPlugins;
+  const workspaceSourcePackages = /* @__PURE__ */ new Set();
+  PluginManager2.getPackageName = async (name) => {
+    const currentOptions = getPluginManagerOptions(PluginManager2);
+    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);
+  };
+  PluginManager2.getPackageJson = async (packageName) => {
+    const currentOptions = getPluginManagerOptions(PluginManager2);
+    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(path.resolve(currentWorkspaceRoot, "packages", packageDir, "package.json"));
+    }
+    return runtimeRequire(runtimeRequire.resolve(path.join(packageName, "package.json")));
+  };
+  PluginManager2.resolvePlugin = async (pluginName, isUpgrade = false, isPkg = false) => {
+    if (typeof pluginName !== "string") {
+      return pluginName;
+    }
+    const packageName = isPkg ? pluginName : await PluginManager2.getPackageName(pluginName);
+    if (workspaceSourcePackages.has(packageName)) {
+      const currentOptions = getPluginManagerOptions(PluginManager2);
+      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(pathToFileURL(entry).href);
+        return getModuleDefault(mod);
+      }
+      return resolvePlugin(packageName, isUpgrade, true);
+    }
+    return resolvePlugin(pluginName, isUpgrade, isPkg);
+  };
+  PluginManager2.prototype.initRuntimePlugins = async function initTestRuntimePlugins() {
+    const currentOptions = getPluginManagerOptions(PluginManager2);
+    if (currentOptions == null ? void 0 : currentOptions.disableRuntimePlugins) {
+      this["_initRuntimePlugins"] = true;
+      return;
+    }
+    return originalInitRuntimePlugins.call(this);
+  };
+  PluginManager2.prototype.initOtherPlugins = async function initTestOtherPlugins() {
+    const currentOptions = getPluginManagerOptions(PluginManager2);
+    if (currentOptions == null ? void 0 : currentOptions.disableOtherPlugins) {
+      this["_initOtherPlugins"] = true;
+      return;
+    }
+    return originalInitOtherPlugins.call(this);
+  };
+  PluginManager2.prototype.add = 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(PluginManager2);
+      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(pathToFileURL(entry).href);
+        return originalAdd.call(this, getModuleDefault(mod), pluginOptions, insert, isUpgrade);
+      }
+    }
+    return originalAdd.call(this, plugin, pluginOptions, insert, isUpgrade);
+  };
+  PluginManager2.prototype.enable = async function enableWorkspacePlugin(name) {
+    const normalize = (pluginName) => workspacePluginNameAliases[pluginName] || pluginName;
+    const normalizedName = Array.isArray(name) ? name.map(normalize) : normalize(name);
+    return originalEnable.call(this, normalizedName);
+  };
+  PluginManager2.prototype.initPresetPlugins = async function initWorkspacePresetPlugins() {
+    var _a, _b;
+    if (this["_initPresetPlugins"]) {
+      return;
+    }
+    const addWorkspacePlugin = async (pluginName, pluginOptions = {}) => {
+      const normalizedPluginName = typeof pluginName === "string" ? workspacePluginNameAliases[pluginName] || pluginName : pluginName;
+      const currentOptions = getPluginManagerOptions(PluginManager2);
+      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(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 });
+      }
+    };
+    const addTachybasePresetPlugin = async (pluginName, pluginOptions = {}) => {
+      if (testUnsafeBuiltinPlugins.has(pluginName)) {
+        return;
+      }
+      await addWorkspacePlugin(pluginName, { enabled: true, ...pluginOptions });
+    };
+    const addTachybaseExternalPlugin = 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 });
+    };
+    for (const plugin of this.options.plugins || []) {
+      const [pluginName, pluginOptions = {}] = Array.isArray(plugin) ? plugin : [plugin];
+      if (pluginName === "tachybase") {
+        const currentOptions = getPluginManagerOptions(PluginManager2);
+        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;
+  };
+  PluginManager2.__serverTestEnvironmentPatchVersion = 2;
+  PluginManager2.__serverTestEnvironmentPatchOptions = options;
+  PluginManager2.findPackagePatched = true;
+}
+function patchAppSupervisor(core, options) {
+  const AppSupervisor2 = core.AppSupervisor;
+  if (!(AppSupervisor2 == null ? void 0 : AppSupervisor2.getInstance)) {
+    return;
+  }
+  AppSupervisor2.__serverTestEnvironmentOptions = options;
+  if (AppSupervisor2.__serverTestEnvironmentPatchVersion === 1) {
+    return;
+  }
+  const supervisor = AppSupervisor2.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
+        },
+        AppSupervisor2.__serverTestEnvironmentOptions
+      );
+    }
+    return originalAddApp(app);
+  };
+  AppSupervisor2.__serverTestEnvironmentPatchVersion = 1;
+}
+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 = path.join(os.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
+    });
+  }
+}
+const 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;
+}
+const pgOnly = () => {
+  var _a, _b;
+  const isPostgres = ((_b = (_a = TachybaseGlobalModule.settings) == null ? void 0 : _a.database) == null ? void 0 : _b.dialect) === "postgres";
+  const desc = getDescribe();
+  if (isPostgres) {
+    return desc;
+  }
+  return desc.skip || noopDescribe;
+};
+const isPg = () => {
+  var _a, _b;
+  return ((_b = (_a = TachybaseGlobalModule.settings) == null ? void 0 : _a.database) == null ? void 0 : _b.dialect) === "postgres";
+};
 function randomStr() {
   return Math.random().toString(36).substring(2);
 }
@@ -217,6 +671,7 @@ export {
   mockServer,
   pgOnly,
   randomStr,
+  setupServerTestEnvironment,
   startMockServer,
   startServerWithRandomPort,
   default2 as supertest,

package/es/server/index.d.ts

@@ -1,6 +1,7 @@
 export { mockDatabase } from '@tachybase/database';
 export { default as supertest } from 'supertest';
 export * from './mockServer';
+export * from './setupTestEnvironment';
 export declare const pgOnly: () => any;
 export declare const isPg: () => boolean;
 export declare function randomStr(): string;

package/es/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/es/setup-server.d.ts

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

package/es/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;

package/es/vitest.mjs

@@ -0,0 +1,137 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path, { resolve } from "node:path";
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vitest/config";
+const runtimeRequire = createRequire(path.resolve(process.cwd(), "package.json"));
+const packageRoot = fs.existsSync(path.resolve(process.cwd(), "packages/test/package.json")) ? path.resolve(process.cwd(), "packages/test") : path.dirname(runtimeRequire.resolve("@tachybase/test/package.json"));
+const relativePathToAbsolute = (relativePath) => {
+  return path.resolve(process.cwd(), relativePath);
+};
+function tsConfigPathsToAlias() {
+  var _a;
+  const alias = [
+    {
+      find: "@tachybase/utils/plugin-symlink",
+      replacement: "node_modules/@tachybase/utils/plugin-symlink.js"
+    },
+    {
+      find: "@opentelemetry/resources",
+      replacement: "node_modules/@opentelemetry/resources/build/src/index.js"
+    }
+  ];
+  try {
+    const json = JSON.parse(
+      fs.readFileSync(path.resolve(process.cwd(), "./tsconfig.paths.json"), { encoding: "utf8" })
+    );
+    const paths = ((_a = json.compilerOptions) == null ? void 0 : _a.paths) || {};
+    alias.push(
+      ...Object.keys(paths).reduce((acc, key) => {
+        var _a2;
+        if (key !== "@@/*") {
+          const value = (_a2 = paths[key]) == null ? void 0 : _a2[0];
+          if (value) {
+            acc.push({
+              find: key,
+              replacement: value
+            });
+          }
+        }
+        return acc;
+      }, [])
+    );
+  } catch {
+  }
+  return [
+    { find: /^~antd\/(.*)/, replacement: "antd/$1" },
+    ...alias.map((item) => {
+      return {
+        ...item,
+        replacement: relativePathToAbsolute(item.replacement)
+      };
+    })
+  ];
+}
+function defineTegoVitestConfig(options = {}) {
+  var _a, _b;
+  const serverSetupFile = ((_a = options.server) == null ? void 0 : _a.setupFile) || resolve(packageRoot, "./setup/server.ts");
+  const clientSetupFiles = [resolve(packageRoot, "./setup/client.ts"), (_b = options.client) == null ? void 0 : _b.setupFile].filter(Boolean);
+  return defineConfig({
+    test: {
+      testTimeout: 6e4,
+      hookTimeout: 6e4,
+      coverage: {
+        provider: "v8",
+        reporter: ["text", "json-summary", "json"],
+        reportOnFailure: true,
+        thresholds: {
+          lines: 60,
+          branches: 60,
+          functions: 80,
+          statements: 80
+        }
+      },
+      silent: !!process.env.GITHUB_ACTIONS,
+      globals: true,
+      alias: tsConfigPathsToAlias(),
+      projects: [
+        {
+          root: process.cwd(),
+          resolve: {
+            mainFields: ["module"]
+          },
+          extends: true,
+          test: {
+            name: "server",
+            setupFiles: serverSetupFile,
+            include: ["packages/**/__tests__/**/*.test.ts", "apps/**/__tests__/**/*.test.ts"],
+            exclude: [
+              "**/node_modules/**",
+              "**/dist/**",
+              "**/lib/**",
+              "**/es/**",
+              "**/e2e/**",
+              "**/__e2e__/**",
+              "**/{vitest,commitlint}.config.*",
+              "packages/**/{sdk,client,schema,components}/**/__tests__/**/*.{test,spec}.{ts,tsx}"
+            ]
+          }
+        },
+        {
+          // @ts-ignore
+          plugins: [react()],
+          resolve: {
+            mainFields: ["module"]
+          },
+          define: {
+            "process.env.__TEST__": true,
+            "process.env.__E2E__": false
+          },
+          test: {
+            name: "client",
+            globals: true,
+            setupFiles: clientSetupFiles,
+            environment: "jsdom",
+            css: false,
+            alias: tsConfigPathsToAlias(),
+            include: ["packages/**/{sdk,client,schema,components}/**/__tests__/**/*.{test,spec}.{ts,tsx}"],
+            exclude: [
+              "**/node_modules/**",
+              "**/dist/**",
+              "**/lib/**",
+              "**/es/**",
+              "**/e2e/**",
+              "**/__e2e__/**",
+              "**/{vitest,commitlint}.config.*"
+            ]
+          }
+        }
+      ]
+    }
+  });
+}
+const vitest = defineTegoVitestConfig();
+export {
+  vitest as default,
+  defineTegoVitestConfig
+};

package/lib/server/index.d.ts

@@ -1,6 +1,7 @@
 export { mockDatabase } from '@tachybase/database';
 export { default as supertest } from 'supertest';
 export * from './mockServer';
+export * from './setupTestEnvironment';
 export declare const pgOnly: () => any;
 export declare const isPg: () => boolean;
 export declare function randomStr(): string;