@eggjs/tegg-vitest 0.0.0 → 4.0.1-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-present Alibaba Group Holding Limited and other contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { EggMockApp, TeggVitestAdapterOptions } from "./shared.js";
+
+//#region src/index.d.ts
+
+/**
+* Configure the custom Vitest runner (used via globalThis.__teggVitestConfig).
+* Call this in a setupFile and set `runner` in vitest.config.ts to use the runner approach.
+*/
+declare function configureTeggRunner(options?: TeggVitestAdapterOptions): void;
+//#endregion
+export { type EggMockApp, type TeggVitestAdapterOptions, configureTeggRunner };

package/dist/index.js

@@ -0,0 +1,16 @@
+import { defaultGetApp } from "./shared.js";
+
+//#region src/index.ts
+/**
+* Configure the custom Vitest runner (used via globalThis.__teggVitestConfig).
+* Call this in a setupFile and set `runner` in vitest.config.ts to use the runner approach.
+*/
+function configureTeggRunner(options = {}) {
+	globalThis.__teggVitestConfig = {
+		restoreMocks: options.restoreMocks ?? true,
+		getApp: options.getApp ?? defaultGetApp
+	};
+}
+
+//#endregion
+export { configureTeggRunner };

package/dist/runner.d.ts

@@ -0,0 +1,21 @@
+import { VitestTestRunner } from "vitest/runners";
+import { RunnerTask, RunnerTestSuite } from "vitest";
+
+//#region src/runner.d.ts
+declare class TeggVitestRunner extends VitestTestRunner {
+  private fileScopeMap;
+  private taskScopeMap;
+  private fileAppMap;
+  private warned;
+  /**
+  * Override importFile to capture per-file config set by configureTeggRunner()
+  * and await app.ready() during collection phase.
+  */
+  importFile(filepath: string, source: Parameters<VitestTestRunner["importFile"]>[1]): Promise<unknown>;
+  onBeforeRunSuite(suite: RunnerTestSuite): Promise<void>;
+  onAfterRunSuite(suite: RunnerTestSuite): Promise<void>;
+  onBeforeTryTask(test: RunnerTask): Promise<void>;
+  onAfterRunTask(test: RunnerTask): Promise<void>;
+}
+//#endregion
+export { TeggVitestRunner as default };

package/dist/runner.js

@@ -0,0 +1,172 @@
+import { debugLog, defaultGetApp, restoreEggMocksIfNeeded } from "./shared.js";
+import { VitestTestRunner } from "vitest/runners";
+
+//#region src/runner.ts
+/**
+* Create a held beginModuleScope: starts the scope and waits until init() is
+* complete (the inner fn starts executing), then returns the held scope.
+* The scope stays alive until endScope() is called.
+*/
+async function createHeldScope(ctx) {
+	let endScope;
+	const gate = new Promise((resolve) => {
+		endScope = resolve;
+	});
+	let scopeReady;
+	const readyPromise = new Promise((resolve) => {
+		scopeReady = resolve;
+	});
+	const scopePromise = ctx.beginModuleScope(async () => {
+		scopeReady();
+		await gate;
+	});
+	await Promise.race([readyPromise, scopePromise]);
+	return {
+		scopePromise,
+		endScope
+	};
+}
+async function releaseHeldScope(scope) {
+	if (!scope) return;
+	scope.endScope();
+	await scope.scopePromise;
+}
+function isFileSuite(suite) {
+	return !suite.suite && !!suite.filepath;
+}
+function getTaskFilepath(task) {
+	return task.file?.filepath;
+}
+var TeggVitestRunner = class extends VitestTestRunner {
+	fileScopeMap = /* @__PURE__ */ new Map();
+	taskScopeMap = /* @__PURE__ */ new Map();
+	fileAppMap = /* @__PURE__ */ new Map();
+	warned = false;
+	/**
+	* Override importFile to capture per-file config set by configureTeggRunner()
+	* and await app.ready() during collection phase.
+	*/
+	async importFile(filepath, source) {
+		if (source === "collect") {
+			this.fileAppMap.delete(filepath);
+			this.warned = false;
+		}
+		delete globalThis.__teggVitestConfig;
+		const result = await super.importFile(filepath, source);
+		if (source === "collect") {
+			const rawConfig = globalThis.__teggVitestConfig;
+			if (rawConfig) {
+				delete globalThis.__teggVitestConfig;
+				const config = {
+					restoreMocks: rawConfig.restoreMocks ?? true,
+					getApp: rawConfig.getApp ?? defaultGetApp
+				};
+				debugLog(`captured config for ${filepath}`);
+				try {
+					const app = await config.getApp();
+					if (app) {
+						await app.ready();
+						this.fileAppMap.set(filepath, {
+							app,
+							config
+						});
+						debugLog(`app ready for ${filepath}`);
+					}
+				} catch (err) {
+					if (!this.warned) {
+						this.warned = true;
+						console.warn("[tegg-vitest] getApp failed, skip context injection.", err);
+					}
+				}
+			}
+		}
+		return result;
+	}
+	async onBeforeRunSuite(suite) {
+		if (isFileSuite(suite)) {
+			const filepath = suite.filepath;
+			debugLog(`onBeforeRunSuite (file): ${filepath}`);
+			const fileApp = this.fileAppMap.get(filepath);
+			if (fileApp) {
+				const { app, config } = fileApp;
+				if (typeof app.mockContext === "function" && app.ctxStorage) {
+					const suiteCtx = app.mockContext(void 0, {
+						mockCtxStorage: false,
+						reuseCtxStorage: false
+					});
+					app.ctxStorage.enterWith(suiteCtx);
+					let suiteScope = null;
+					if (typeof suiteCtx.beginModuleScope === "function") {
+						suiteScope = await createHeldScope(suiteCtx);
+						debugLog("suite held scope created");
+					}
+					this.fileScopeMap.set(filepath, {
+						app,
+						config,
+						suiteCtx,
+						suiteScope
+					});
+					debugLog("file suite scope created");
+				}
+			}
+		}
+		await super.onBeforeRunSuite(suite);
+	}
+	async onAfterRunSuite(suite) {
+		if (isFileSuite(suite)) {
+			const filepath = suite.filepath;
+			debugLog(`onAfterRunSuite (file): ${filepath}`);
+			const fileState = this.fileScopeMap.get(filepath);
+			if (fileState) {
+				await releaseHeldScope(fileState.suiteScope);
+				this.fileScopeMap.delete(filepath);
+			}
+			this.fileAppMap.delete(filepath);
+		}
+		await super.onAfterRunSuite(suite);
+	}
+	async onBeforeTryTask(test) {
+		const filepath = getTaskFilepath(test);
+		if (filepath) {
+			const fileState = this.fileScopeMap.get(filepath);
+			if (fileState) {
+				const existing = this.taskScopeMap.get(test.id);
+				if (existing) await releaseHeldScope(existing.testScope);
+				debugLog(`onBeforeTryTask: ${test.name}`);
+				const testCtx = fileState.app.mockContext(void 0, {
+					mockCtxStorage: false,
+					reuseCtxStorage: false
+				});
+				fileState.app.ctxStorage.enterWith(testCtx);
+				let testScope = null;
+				if (typeof testCtx.beginModuleScope === "function") {
+					testScope = await createHeldScope(testCtx);
+					debugLog("test held scope created");
+				}
+				this.taskScopeMap.set(test.id, {
+					testScope,
+					filepath
+				});
+			}
+		}
+		await super.onBeforeTryTask(test);
+	}
+	async onAfterRunTask(test) {
+		const taskState = this.taskScopeMap.get(test.id);
+		if (taskState) {
+			debugLog(`onAfterRunTask: ${test.name}`);
+			await releaseHeldScope(taskState.testScope);
+			this.taskScopeMap.delete(test.id);
+			const fileState = this.fileScopeMap.get(taskState.filepath);
+			if (fileState) {
+				await restoreEggMocksIfNeeded(fileState.config.restoreMocks);
+				fileState.app.ctxStorage.enterWith(fileState.suiteCtx);
+				debugLog("restored suite context");
+			}
+		}
+		await super.onAfterRunTask(test);
+	}
+};
+
+//#endregion
+export { TeggVitestRunner as default };

package/dist/shared.d.ts

@@ -0,0 +1,29 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Application } from "egg";
+
+//#region src/shared.d.ts
+type EggMockApp = Application & {
+  ctxStorage?: {
+    getStore?: () => any;
+    enterWith?: (store: any) => void;
+  } & AsyncLocalStorage<any>;
+  mockContext?: (data?: any, options?: any) => any;
+};
+interface TeggVitestAdapterOptions {
+  /**
+  * Resolve app instance.
+  * Default: import('@eggjs/mock/bootstrap').app
+  */
+  getApp?: () => Promise<EggMockApp | undefined> | EggMockApp | undefined;
+  /**
+  * Restore mocks after each test.
+  * Default: true (calls @eggjs/mock.restore())
+  */
+  restoreMocks?: boolean;
+}
+declare const DEBUG_ENABLED: boolean;
+declare function debugLog(message: string, extra?: unknown): void;
+declare function defaultGetApp(): Promise<EggMockApp | undefined>;
+declare function restoreEggMocksIfNeeded(restoreMocks: boolean): Promise<void>;
+//#endregion
+export { DEBUG_ENABLED, EggMockApp, TeggVitestAdapterOptions, debugLog, defaultGetApp, restoreEggMocksIfNeeded };

package/dist/shared.js

@@ -0,0 +1,22 @@
+//#region src/shared.ts
+const DEBUG_ENABLED = process.env.DEBUG_TEGG_VITEST === "1";
+function debugLog(message, extra) {
+	if (!DEBUG_ENABLED) return;
+	if (extra === void 0) {
+		console.log(`[tegg-vitest] ${message}`);
+		return;
+	}
+	console.log(`[tegg-vitest] ${message}`, extra);
+}
+async function defaultGetApp() {
+	return (await import("@eggjs/mock/bootstrap"))?.app;
+}
+async function restoreEggMocksIfNeeded(restoreMocks) {
+	if (!restoreMocks) return;
+	const eggMock = await import("@eggjs/mock");
+	const mm = eggMock?.default || eggMock;
+	if (mm?.restore) await mm.restore();
+}
+
+//#endregion
+export { DEBUG_ENABLED, debugLog, defaultGetApp, restoreEggMocksIfNeeded };

package/package.json

@@ -1,31 +1,59 @@
 {
   "name": "@eggjs/tegg-vitest",
-  "version": "0.0.0",
-  "description": "egg logger",
+  "version": "4.0.1-beta.0",
+  "description": "Vitest adapter for tegg context injection",
   "keywords": [
+    "adapter",
     "egg",
-    "logger"
+    "tegg",
+    "test",
+    "vitest"
   ],
-  "homepage": "https://github.com/eggjs/egg/tree/next/packages/logger",
+  "homepage": "https://github.com/eggjs/egg/tree/next/tegg/core/vitest",
   "bugs": {
     "url": "https://github.com/eggjs/egg/issues"
   },
   "license": "MIT",
-  "author": "fengmk2 <fengmk2@gmail.com> (https://github.com/fengmk2)",
+  "author": "killagu <killa123@126.com>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/eggjs/egg.git",
-    "directory": "packages/logger"
+    "directory": "tegg/core/vitest"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./runner": "./dist/runner.js",
+    "./shared": "./dist/shared.js",
+    "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
+    "@eggjs/mock": "7.0.1-beta.0"
   },
   "devDependencies": {
+    "@types/node": "^24.10.2",
+    "tsx": "4.20.6",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15",
+    "@eggjs/core-decorator": "4.0.1-beta.0",
+    "egg": "4.1.1-beta.0"
+  },
+  "peerDependencies": {
+    "vitest": "^4.0.15"
   },
   "engines": {
-    "node": ">= 22.18.0"
+    "node": ">=22.18.0"
+  },
+  "scripts": {
+    "typecheck": "tsgo --noEmit"
   }
-}
-
+}