@eggjs/mock 6.1.0-beta.3 → 6.1.0-beta.4

package/dist/node_modules/.pnpm/workerpool@9.3.3/node_modules/workerpool/src/worker.js

@@ -0,0 +1,281 @@
+import { __commonJS, __require } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_Promise } from "./Promise.js";
+import { require_transfer } from "./transfer.js";
+
+//#region ../../node_modules/.pnpm/workerpool@9.3.3/node_modules/workerpool/src/worker.js
+var require_worker = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/workerpool@9.3.3/node_modules/workerpool/src/worker.js": ((exports) => {
+	/**
+	* worker must be started as a child process or a web worker.
+	* It listens for RPC messages from the parent process.
+	*/
+	var Transfer = require_transfer();
+	/**
+	* worker must handle async cleanup handlers. Use custom Promise implementation. 
+	*/
+	var Promise$1 = require_Promise().Promise;
+	/**
+	* Special message sent by parent which causes the worker to terminate itself.
+	* Not a "message object"; this string is the entire message.
+	*/
+	var TERMINATE_METHOD_ID = "__workerpool-terminate__";
+	/**
+	* Special message by parent which causes a child process worker to perform cleaup
+	* steps before determining if the child process worker should be terminated.
+	*/
+	var CLEANUP_METHOD_ID = "__workerpool-cleanup__";
+	var TIMEOUT_DEFAULT = 1e3;
+	var worker = { exit: function() {} };
+	var publicWorker = {
+		addAbortListener: function(listener) {
+			worker.abortListeners.push(listener);
+		},
+		emit: worker.emit
+	};
+	if (typeof self !== "undefined" && typeof postMessage === "function" && typeof addEventListener === "function") {
+		worker.on = function(event, callback) {
+			addEventListener(event, function(message) {
+				callback(message.data);
+			});
+		};
+		worker.send = function(message, transfer) {
+			transfer ? postMessage(message, transfer) : postMessage(message);
+		};
+	} else if (typeof process !== "undefined") {
+		var WorkerThreads;
+		try {
+			WorkerThreads = __require("worker_threads");
+		} catch (error) {
+			if (typeof error === "object" && error !== null && error.code === "MODULE_NOT_FOUND") {} else throw error;
+		}
+		if (WorkerThreads && WorkerThreads.parentPort !== null) {
+			var parentPort = WorkerThreads.parentPort;
+			worker.send = parentPort.postMessage.bind(parentPort);
+			worker.on = parentPort.on.bind(parentPort);
+			worker.exit = process.exit.bind(process);
+		} else {
+			worker.on = process.on.bind(process);
+			worker.send = function(message) {
+				process.send(message);
+			};
+			worker.on("disconnect", function() {
+				process.exit(1);
+			});
+			worker.exit = process.exit.bind(process);
+		}
+	} else throw new Error("Script must be executed as a worker");
+	function convertError(error) {
+		return Object.getOwnPropertyNames(error).reduce(function(product, name) {
+			return Object.defineProperty(product, name, {
+				value: error[name],
+				enumerable: true
+			});
+		}, {});
+	}
+	/**
+	* Test whether a value is a Promise via duck typing.
+	* @param {*} value
+	* @returns {boolean} Returns true when given value is an object
+	*                    having functions `then` and `catch`.
+	*/
+	function isPromise(value) {
+		return value && typeof value.then === "function" && typeof value.catch === "function";
+	}
+	worker.methods = {};
+	/**
+	* Execute a function with provided arguments
+	* @param {String} fn     Stringified function
+	* @param {Array} [args]  Function arguments
+	* @returns {*}
+	*/
+	worker.methods.run = function run(fn, args) {
+		var f = new Function("return (" + fn + ").apply(this, arguments);");
+		f.worker = publicWorker;
+		return f.apply(f, args);
+	};
+	/**
+	* Get a list with methods available on this worker
+	* @return {String[]} methods
+	*/
+	worker.methods.methods = function methods() {
+		return Object.keys(worker.methods);
+	};
+	/**
+	* Custom handler for when the worker is terminated.
+	*/
+	worker.terminationHandler = void 0;
+	worker.abortListenerTimeout = TIMEOUT_DEFAULT;
+	/**
+	* Abort handlers for resolving errors which may cause a timeout or cancellation
+	* to occur from a worker context
+	*/
+	worker.abortListeners = [];
+	/**
+	* Cleanup and exit the worker.
+	* @param {Number} code 
+	* @returns {Promise<void>}
+	*/
+	worker.terminateAndExit = function(code) {
+		var _exit = function() {
+			worker.exit(code);
+		};
+		if (!worker.terminationHandler) return _exit();
+		var result = worker.terminationHandler(code);
+		if (isPromise(result)) {
+			result.then(_exit, _exit);
+			return result;
+		} else {
+			_exit();
+			return new Promise$1(function(_resolve, reject) {
+				reject(/* @__PURE__ */ new Error("Worker terminating"));
+			});
+		}
+	};
+	/**
+	* Called within the worker message handler to run abort handlers if registered to perform cleanup operations.
+	* @param {Integer} [requestId] id of task which is currently executing in the worker
+	* @return {Promise<void>}
+	*/
+	worker.cleanup = function(requestId) {
+		if (!worker.abortListeners.length) {
+			worker.send({
+				id: requestId,
+				method: CLEANUP_METHOD_ID,
+				error: convertError(/* @__PURE__ */ new Error("Worker terminating"))
+			});
+			return new Promise$1(function(resolve) {
+				resolve();
+			});
+		}
+		var _exit = function() {
+			worker.exit();
+		};
+		var _abort = function() {
+			if (!worker.abortListeners.length) worker.abortListeners = [];
+		};
+		const promises = worker.abortListeners.map((listener) => listener());
+		let timerId;
+		const timeoutPromise = new Promise$1((_resolve, reject) => {
+			timerId = setTimeout(function() {
+				reject(/* @__PURE__ */ new Error("Timeout occured waiting for abort handler, killing worker"));
+			}, worker.abortListenerTimeout);
+		});
+		const settlePromise = Promise$1.all(promises).then(function() {
+			clearTimeout(timerId);
+			_abort();
+		}, function() {
+			clearTimeout(timerId);
+			_exit();
+		});
+		return new Promise$1(function(resolve, reject) {
+			settlePromise.then(resolve, reject);
+			timeoutPromise.then(resolve, reject);
+		}).then(function() {
+			worker.send({
+				id: requestId,
+				method: CLEANUP_METHOD_ID,
+				error: null
+			});
+		}, function(err) {
+			worker.send({
+				id: requestId,
+				method: CLEANUP_METHOD_ID,
+				error: err ? convertError(err) : null
+			});
+		});
+	};
+	var currentRequestId = null;
+	worker.on("message", function(request) {
+		if (request === TERMINATE_METHOD_ID) return worker.terminateAndExit(0);
+		if (request.method === CLEANUP_METHOD_ID) return worker.cleanup(request.id);
+		try {
+			var method = worker.methods[request.method];
+			if (method) {
+				currentRequestId = request.id;
+				var result = method.apply(method, request.params);
+				if (isPromise(result)) result.then(function(result$1) {
+					if (result$1 instanceof Transfer) worker.send({
+						id: request.id,
+						result: result$1.message,
+						error: null
+					}, result$1.transfer);
+					else worker.send({
+						id: request.id,
+						result: result$1,
+						error: null
+					});
+					currentRequestId = null;
+				}).catch(function(err) {
+					worker.send({
+						id: request.id,
+						result: null,
+						error: convertError(err)
+					});
+					currentRequestId = null;
+				});
+				else {
+					if (result instanceof Transfer) worker.send({
+						id: request.id,
+						result: result.message,
+						error: null
+					}, result.transfer);
+					else worker.send({
+						id: request.id,
+						result,
+						error: null
+					});
+					currentRequestId = null;
+				}
+			} else throw new Error("Unknown method \"" + request.method + "\"");
+		} catch (err) {
+			worker.send({
+				id: request.id,
+				result: null,
+				error: convertError(err)
+			});
+		}
+	});
+	/**
+	* Register methods to the worker
+	* @param {Object} [methods]
+	* @param {import('./types.js').WorkerRegisterOptions} [options]
+	*/
+	worker.register = function(methods, options) {
+		if (methods) {
+			for (var name in methods) if (methods.hasOwnProperty(name)) {
+				worker.methods[name] = methods[name];
+				worker.methods[name].worker = publicWorker;
+			}
+		}
+		if (options) {
+			worker.terminationHandler = options.onTerminate;
+			worker.abortListenerTimeout = options.abortListenerTimeout || TIMEOUT_DEFAULT;
+		}
+		worker.send("ready");
+	};
+	worker.emit = function(payload) {
+		if (currentRequestId) {
+			if (payload instanceof Transfer) {
+				worker.send({
+					id: currentRequestId,
+					isEvent: true,
+					payload: payload.message
+				}, payload.transfer);
+				return;
+			}
+			worker.send({
+				id: currentRequestId,
+				isEvent: true,
+				payload
+			});
+		}
+	};
+	if (typeof exports !== "undefined") {
+		exports.add = worker.register;
+		exports.emit = worker.emit;
+	}
+}) });
+
+//#endregion
+export default require_worker();
+
+export { require_worker };

package/dist/register.d.ts

@@ -1,5 +1,3 @@
-import "mocha";
-
 //#region src/register.d.ts
 declare function mochaGlobalSetup(): Promise<void>;
 declare function mochaGlobalTeardown(): Promise<void>;

package/dist/register.js

@@ -1,11 +1,8 @@
-import { __require } from "./_virtual/rolldown_runtime.js";
 import { closeAgent, setupAgent } from "./lib/agent_handler.js";
 import { getApp } from "./lib/app_handler.js";
 import { mm as proxyMock } from "./index.js";
-import { injectContext } from "./lib/inject_context.js";
-import { createRequire } from "node:module";
+import "./inject_mocha.js";
 import { debuglog } from "node:util";
-import "mocha";
 
 //#region src/register.ts
 const debug = debuglog("egg/mock/register");
@@ -38,28 +35,6 @@ const mochaHooks = {
 		if (app) await app.close();
 	}
 };
-/**
-* Find active node mocha instances.
-*/
-function findNodeJSMocha() {
-	let children;
-	if (typeof __require === "function") children = __require.cache || {};
-	else {
-		children = createRequire(process.cwd()).cache || {};
-		debug("createRequire on esm");
-	}
-	return Object.keys(children).filter(function(child) {
-		const val = children[child].exports;
-		return typeof val === "function" && val.name === "Mocha";
-	}).map(function(child) {
-		return children[child].exports;
-	});
-}
-const modules = findNodeJSMocha();
-for (const module of modules) {
-	if (!module) continue;
-	injectContext(module);
-}
 
 //#endregion
 export { mochaGlobalSetup, mochaGlobalTeardown, mochaHooks };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/mock",
-  "version": "6.1.0-beta.3",
+  "version": "6.1.0-beta.4",
   "publishConfig": {
     "access": "public"
   },
@@ -18,6 +18,7 @@
     "./app/extend/application": "./dist/app/extend/application.js",
     "./app/middleware/cluster_app_mock": "./dist/app/middleware/cluster_app_mock.js",
     "./bootstrap": "./dist/bootstrap.js",
+    "./inject_mocha": "./dist/inject_mocha.js",
     "./lib/agent_handler": "./dist/lib/agent_handler.js",
     "./lib/app": "./dist/lib/app.js",
     "./lib/app_handler": "./dist/lib/app_handler.js",
@@ -64,7 +65,6 @@
     "node": ">= 20.19.0"
   },
   "dependencies": {
-    "@eggjs/supertest": "",
     "coffee": "5",
     "detect-port": "^2.1.0",
     "egg-logger": "^3.5.0",
@@ -76,9 +76,10 @@
     "sdk-base": "^5.0.1",
     "urllib": "^4.6.11",
     "utility": "^2.5.0",
-    "@eggjs/core": "6.6.0-beta.3",
-    "@eggjs/utils": "4.5.0-beta.3",
-    "@eggjs/extend2": "4.1.0-beta.3"
+    "@eggjs/core": "6.6.0-beta.4",
+    "@eggjs/extend2": "4.1.0-beta.4",
+    "@eggjs/supertest": "8.3.0-beta.4",
+    "@eggjs/utils": "4.5.0-beta.4"
   },
   "devDependencies": {
     "@eggjs/tegg": "^3.2.2",
@@ -92,13 +93,14 @@
     "pedding": "^2.0.1",
     "tsd": "^0.33.0",
     "tsdown": "^0.15.0",
-    "typescript": "5",
-    "egg": "4.1.0-beta.3",
-    "@eggjs/tsconfig": "3.1.0-beta.3"
+    "typescript": "5.9.2",
+    "@eggjs/tsconfig": "3.1.0-beta.4",
+    "egg": "4.1.0-beta.4"
   },
   "scripts": {
     "build": "tsdown",
     "lint": "oxlint",
+    "typecheck": "tsc --noEmit",
     "test": "vitest run"
   }
 }