rspack-plugin-mock 2.0.0 → 2.1.0

package/dist/{ws-BcLCWVaK.js → logger-CzeuHKAL.js}

@@ -1,5 +1,6 @@
-import { attemptAsync, isArray, isBoolean, isEmptyObject, isFunction, isPlainObject, isString, objectKeys, partition, random, sleep, sortBy, timestamp, toArray, uniq } from "@pengzhanbo/utils";
 import path from "node:path";
+import { attempt, attemptAsync, deepEqual, hasOwn, isArray, isBoolean, isEmptyObject, isFunction, isPlainObject, isString, kebabCase, objectKeys, partition, random, sleep, sortBy, timestamp, toArray, uniq } from "@pengzhanbo/utils";
+import fs, { promises } from "node:fs";
 import ansis from "ansis";
 import picomatch from "picomatch";
 import { loadPackageJSONSync } from "local-pkg";
@@ -15,6 +16,7 @@ import bodyParser from "co-body";
 import formidable from "formidable";
 import http from "node:http";
 import { Buffer } from "node:buffer";
+import zlib from "node:zlib";
 import HTTP_STATUS from "http-status";
 import * as mime from "mime-types";
 import { WebSocketServer } from "ws";
@@ -67,6 +69,19 @@ function isStream(stream) {
 function isReadableStream(stream) {
 	return isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
 }
+/**
+* 判断内容类型是否为文本类型
+*
+* @param contentType 内容类型
+* @returns 是否为文本类型
+*/
+function isTextContent(contentType) {
+	return [
+		"text",
+		"json",
+		"xml"
+	].some((type) => contentType.includes(type));
+}
 //#endregion
 //#region src/utils/isObjectSubset.ts
 /**
@@ -109,39 +124,13 @@ function isPathMatch(pattern, path) {
 	return regexp.test(path);
 }
 //#endregion
-//#region src/utils/logger.ts
-const logLevels = {
-	silent: 0,
-	error: 1,
-	warn: 2,
-	info: 3,
-	debug: 4
-};
-function createLogger(prefix, defaultLevel = "info") {
-	prefix = `[${prefix}]`;
-	function output(type, msg, level) {
-		level = isBoolean(level) ? level ? defaultLevel : "error" : level;
-		if (logLevels[level] >= logLevels[type]) {
-			const method = type === "info" || type === "debug" ? "log" : type;
-			const tag = type === "debug" ? ansis.magenta.bold(prefix) : type === "info" ? ansis.cyan.bold(prefix) : type === "warn" ? ansis.yellow.bold(prefix) : ansis.red.bold(prefix);
-			const format = `${ansis.dim((/* @__PURE__ */ new Date()).toLocaleTimeString())} ${tag} ${msg}`;
-			console[method](format);
-		}
-	}
-	return {
-		debug(msg, level = defaultLevel) {
-			output("debug", msg, level);
-		},
-		info(msg, level = defaultLevel) {
-			output("info", msg, level);
-		},
-		warn(msg, level = defaultLevel) {
-			output("warn", msg, level);
-		},
-		error(msg, level = defaultLevel) {
-			output("error", msg, level);
-		}
-	};
+//#region src/utils/matchScene.ts
+function matchScene(activeScene, mockScene) {
+	if (!mockScene) return true;
+	const scenes = toArray(mockScene);
+	if (activeScene.length === 0 && scenes.length > 0) return false;
+	if (scenes.length === 0) return true;
+	return scenes.some((s) => activeScene.includes(s));
 }
 getDirname(import.meta.url);
 const vfs = createFsFromVolume(new Volume());
@@ -258,7 +247,7 @@ function keysCount(obj) {
 	return objectKeys(obj).length;
 }
 //#endregion
-//#region src/core/cors.ts
+//#region src/mockHttp/cors.ts
 /**
 * Create CORS middleware
 *
@@ -274,11 +263,19 @@ function createCors(corsOptions) {
 	})) : void 0;
 }
 //#endregion
-//#region src/core/request.ts
+//#region src/mockHttp/request.ts
 /**
+* Parse request body
+*
 * 解析请求体 request.body
+*
+* @param req - Incoming message object / 入站消息对象
+* @param logger - Logger instance / 日志实例
+* @param formidableOptions - Formidable options for multipart form data / 用于 multipart 表单数据的 Formidable 配置项
+* @param bodyParserOptions - Body parser options / 请求体解析配置项
+* @returns Parsed request body / 解析后的请求体
 */
-async function parseRequestBody(req, formidableOptions, bodyParserOptions = {}) {
+async function parseRequestBody(req, logger, formidableOptions, bodyParserOptions = {}) {
 	const method = req.method.toUpperCase();
 	if (["HEAD", "OPTIONS"].includes(method)) return void 0;
 	const type = req.headers["content-type"]?.toLocaleLowerCase() || "";
@@ -298,9 +295,14 @@ async function parseRequestBody(req, formidableOptions, bodyParserOptions = {})
 		});
 		if (type.startsWith("multipart/form-data")) return await parseRequestBodyWithMultipart(req, formidableOptions);
 	} catch (e) {
-		console.error(e);
+		logger.error(e);
 	}
 }
+/**
+* Default formidable options
+*
+* 默认的 formidable 配置项
+*/
 const DEFAULT_FORMIDABLE_OPTIONS = {
 	keepExtensions: true,
 	filename(name, ext, part) {
@@ -308,7 +310,13 @@ const DEFAULT_FORMIDABLE_OPTIONS = {
 	}
 };
 /**
+* Parse request body with multipart form data
+*
 * 解析 request form multipart body
+*
+* @param req - Incoming message object / 入站消息对象
+* @param options - Formidable options / Formidable 配置项
+* @returns Parsed request body / 解析后的请求体
 */
 async function parseRequestBodyWithMultipart(req, options) {
 	const form = formidable({
@@ -328,9 +336,20 @@ async function parseRequestBodyWithMultipart(req, options) {
 		});
 	});
 }
+/**
+* Cache for path-to-regexp match functions
+*
+* path-to-regexp 匹配函数缓存
+*/
 const matcherCache = /* @__PURE__ */ new Map();
 /**
+* Parse request URL dynamic parameters
+*
 * 解析请求 url 中的动态参数 params
+*
+* @param pattern - URL pattern / URL 模式
+* @param url - Request URL / 请求 URL
+* @returns Parsed parameters / 解析后的参数
 */
 function parseRequestParams(pattern, url) {
 	let matcher = matcherCache.get(pattern);
@@ -342,15 +361,40 @@ function parseRequestParams(pattern, url) {
 	return matched ? matched.params : {};
 }
 /**
+* Validate request against validator
+*
 * 验证请求是否符合 validator
+*
+* @param request - Request object / 请求对象
+* @param validator - Validator object / 验证器对象
+* @returns Whether the request is valid / 请求是否有效
 */
 function requestValidate(request, validator) {
 	return isObjectSubset(request.headers, validator.headers) && isObjectSubset(request.body, validator.body) && isObjectSubset(request.params, validator.params) && isObjectSubset(request.query, validator.query) && isObjectSubset(request.refererQuery, validator.refererQuery);
 }
+/**
+* Format log data
+*
+* 格式化日志数据
+*
+* @param prefix - Log prefix / 日志前缀
+* @param data - Data to format / 要格式化的数据
+* @returns Formatted log string / 格式化后的日志字符串
+*/
 function formatLog(prefix, data) {
 	return !data || isEmptyObject(data) ? "" : `  ${ansis.gray(`${prefix}:`)}${JSON.stringify(data)}`;
 }
-function requestLog(request, filepath) {
+/**
+* Generate request log
+*
+* 生成请求日志
+*
+* @param request - Request object / 请求对象
+* @param filepath - Mock file path / Mock 文件路径
+* @param shouldSimulateError - Whether to simulate error / 是否模拟错误
+* @returns Formatted log string / 格式化后的日志字符串
+*/
+function requestLog(request, filepath, shouldSimulateError) {
 	const { url, method, query, params, body } = request;
 	let { pathname } = new URL(url, "http://example.com");
 	pathname = ansis.green(decodeURIComponent(pathname));
@@ -358,18 +402,31 @@ function requestLog(request, filepath) {
 	const qs = formatLog("query", query);
 	const ps = formatLog("params", params);
 	const bs = formatLog("body", body);
+	const es = shouldSimulateError ? ` 🎲 ${ansis.bgYellow("ERR")}` : "";
 	const file = `  ${ansis.dim.underline(`(${filepath})`)}`;
-	return `${ms} ${pathname}${qs}${ps}${bs}${file}`;
+	return `${ms}${es} ${pathname}${qs}${ps}${bs}${file}`;
 }
 //#endregion
-//#region src/core/findMockData.ts
+//#region src/mockHttp/matcher.ts
 /**
+* Find matching mock data
+*
 * 查找匹配的 mock data
+*
+* @param mockList - Mock options list / Mock 配置列表
+* @param logger - Logger instance / 日志实例
+* @param options - Find options / 查找选项
+* @param options.pathname - Request pathname / 请求路径
+* @param options.method - HTTP method / HTTP 方法
+* @param options.request - Request object / 请求对象
+* @param options.activeScene - Active scene / 当前场景
+* @returns Matched mock HTTP item or undefined / 匹配的 Mock HTTP 项或未定义
 */
-function findMockData(mockList, logger, { pathname, method, request }) {
+function findMockData(mockList, logger, { pathname, method, request, activeScene }) {
 	return mockList.find((mock) => {
 		if (!pathname || !mock || !mock.url || mock.ws) return false;
 		if (!(mock.method ? isArray(mock.method) ? mock.method : [mock.method] : ["GET", "POST"]).includes(method)) return false;
+		if (!matchScene(activeScene, mock.scene)) return false;
 		const hasMock = isPathMatch(mock.url, pathname);
 		if (hasMock && mock.validator) {
 			const params = parseRequestParams(mock.url, pathname);
@@ -377,15 +434,17 @@ function findMockData(mockList, logger, { pathname, method, request }) {
 				params,
 				...request
 			});
-			else try {
-				return requestValidate({
+			else {
+				const [error, validated] = attempt(requestValidate, {
 					params,
 					...request
 				}, mock.validator);
-			} catch (e) {
-				const file = mock.__filepath__;
-				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n${e}\n  at validator (${ansis.underline(file)})`, mock.log);
-				return false;
+				if (error) {
+					const file = mock.__filepath__;
+					logger.error(`${ansis.red(`mock error at ${pathname}`)}\n${error}\n  at validator (${ansis.underline(file)})`, mock.log);
+					return false;
+				}
+				return validated;
 			}
 		}
 		return hasMock;
@@ -596,7 +655,412 @@ function pushCookie(headers, cookie) {
 	headers.push(cookie.toHeader());
 }
 //#endregion
-//#region src/core/matchingWeight.ts
+//#region src/recorder/constants.ts
+const FILTERED_RESPONSE_HEADERS = [
+	"date",
+	"expires",
+	"last-modified",
+	"server",
+	"x-powered-by",
+	"x-aspnet-version",
+	"x-nginx-version",
+	"via",
+	"cache-control",
+	"etag",
+	"age",
+	"connection",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"proxy-connection",
+	"trailer",
+	"access-control-allow-origin",
+	"access-control-allow-credentials",
+	"access-control-allow-methods",
+	"access-control-allow-headers",
+	"access-control-expose-headers",
+	"access-control-max-age",
+	"origin",
+	"p3p",
+	"pragma",
+	"x-request-id",
+	"x-correlation-id",
+	"x-trace-id",
+	"x-varnish",
+	"x-cache",
+	"x-cache-hits",
+	"x-cache-status",
+	"cf-cache-status",
+	"cf-ray",
+	"cf-request-id",
+	"server-timing",
+	"x-dns-prefetch-control"
+];
+//#endregion
+//#region src/recorder/decompress.ts
+/**
+* Decode response body according to encoding
+*
+* 根据编码解码响应体
+*
+* @param rawBody 原始响应体
+* @param encoding 编码
+* @returns 解码后的响应体
+*/
+async function decompressBody(rawBody, encoding) {
+	try {
+		switch (encoding.toLowerCase()) {
+			case "gzip":
+			case "x-gzip": return {
+				body: await gunzip(rawBody),
+				encoding: "identity"
+			};
+			case "deflate":
+			case "x-deflate": return {
+				body: await deflate(rawBody),
+				encoding: "identity"
+			};
+			case "br": return {
+				body: await brotli(rawBody),
+				encoding: "identity"
+			};
+			case "zstd": return {
+				body: await zstd(rawBody),
+				encoding: "identity"
+			};
+		}
+	} catch {}
+	return {
+		body: rawBody,
+		encoding
+	};
+}
+let zstdStreaming = null;
+/**
+* Decompress zstd compressed data
+*
+* 解压缩 zstd 压缩数据
+*
+* zlib.zstdDecompress 从 v22.15.0 开始支持，对于旧版本 Node.js 可以使用 zstd-codec 库
+*
+* @param rawBody 压缩数据
+* @returns 解压缩后的数据
+*/
+async function zstd(rawBody) {
+	if (zlib.zstdDecompress) return new Promise((resolve, reject) => {
+		zlib.zstdDecompress(rawBody, (err, data) => {
+			err ? reject(err) : resolve(data);
+		});
+	});
+	if (!zstdStreaming) {
+		const { ZstdCodec } = await import("zstd-codec");
+		zstdStreaming = await new Promise((resolve) => {
+			ZstdCodec.run((binding) => {
+				resolve(new binding.Streaming());
+			});
+		});
+	}
+	return zstdStreaming.decompress(rawBody, rawBody.length);
+}
+/**
+* Decompress brotli compressed data
+*
+* 解压缩 brotli 压缩数据
+*
+* @param rawBody 压缩数据
+* @returns 解压缩后的数据
+*/
+async function brotli(rawBody) {
+	return new Promise((resolve, reject) => {
+		zlib.brotliDecompress(rawBody, (err, data) => {
+			err ? reject(err) : resolve(data);
+		});
+	});
+}
+async function gunzip(rawBody) {
+	return new Promise((resolve, reject) => {
+		zlib.gunzip(rawBody, (err, data) => {
+			err ? reject(err) : resolve(data);
+		});
+	});
+}
+async function deflate(rawBody) {
+	return new Promise((resolve, reject) => {
+		zlib.inflate(rawBody, (err, data) => {
+			err ? reject(err) : resolve(data);
+		});
+	});
+}
+//#endregion
+//#region src/recorder/helper.ts
+const timeFormatter = new Intl.DateTimeFormat("en-US", {
+	year: "numeric",
+	month: "numeric",
+	day: "numeric",
+	hour: "numeric",
+	minute: "numeric",
+	second: "numeric",
+	hour12: false
+});
+/**
+* 处理记录的请求
+*
+* @param req 原始请求对象
+* @param pathname 请求路径
+* @param body 请求体
+* @returns 处理后的请求记录
+*/
+function processRecordReq(req, pathname, body) {
+	const { query } = urlParse(req.url);
+	const method = req.method.toUpperCase();
+	let bodyType = (req.headers["content-type"] || "").split(";")[0].trim();
+	if (bodyType.startsWith("multipart/form-data") && isPlainObject(body)) {
+		body = { ...body };
+		objectKeys(body).forEach((key) => {
+			const value = body[key];
+			if (isPlainObject(value) && hasOwn(value, "filepath") && hasOwn(value, "mimetype")) delete body[key];
+		});
+	}
+	if (Buffer.isBuffer(body)) {
+		body = body.toString();
+		bodyType = "buffer";
+	}
+	return {
+		method,
+		pathname,
+		query,
+		bodyType,
+		body
+	};
+}
+/**
+* 处理记录的响应
+*
+* @param res 原始响应对象
+* @param body 响应体
+* @returns 处理后的响应记录
+*/
+async function processRecordRes(res, body) {
+	const status = res.statusCode || 200;
+	const statusText = res.statusMessage || "OK";
+	const headers = {};
+	for (const [key, value] of Object.entries(res.headers)) {
+		const lowerKey = key.toLowerCase();
+		if (value !== void 0 && !FILTERED_RESPONSE_HEADERS.includes(lowerKey)) headers[key] = String(value);
+	}
+	const isText = isTextContent(headers["content-type"] || "");
+	if (isText) {
+		const { body: decodedBody, encoding } = await decompressBody(body, headers["content-encoding"] || "");
+		body = Buffer.from(decodedBody);
+		headers["content-encoding"] = encoding;
+	}
+	return {
+		status,
+		statusText,
+		headers,
+		body: body.toString(isText ? "utf-8" : "base64")
+	};
+}
+/**
+* 判断两个请求是否是同一个请求
+*
+* @param prev 上一个请求
+* @param current 当前请求
+* @returns 是否是同一个请求
+*/
+function isSameRecord(prev, current) {
+	if (prev.pathname !== current.pathname || prev.method !== current.method) return false;
+	if (prev.bodyType !== current.bodyType) return false;
+	if (!deepEqual(prev.query, current.query)) return false;
+	if (current.bodyType === "buffer" && prev.bodyType === "buffer") {
+		const currentBody = Buffer.from(current.body);
+		const prevBody = Buffer.from(prev.body);
+		if (currentBody.length !== prevBody.length || !currentBody.equals(prevBody)) return false;
+	}
+	if (!deepEqual(prev.body, current.body)) return false;
+	return true;
+}
+/**
+* 创建请求记录过滤器
+*
+* @param filter 记录过滤选项
+* @returns 请求匹配函数
+*/
+function createRecordMatcher(filter) {
+	if (isFunction(filter)) return filter;
+	const { mode = "glob" } = filter;
+	const include = toArray(filter.include);
+	const exclude = toArray(filter.exclude);
+	if (mode === "glob") {
+		const { isMatch } = createMatcher(include, exclude);
+		return (req) => isMatch(req.pathname);
+	}
+	return (req) => {
+		return include.some((pattern) => isPathMatch(pattern, req.pathname)) && exclude.every((pattern) => !isPathMatch(pattern, req.pathname));
+	};
+}
+/**
+* 生成记录文件路径
+*
+* @param pathname 请求路径
+* @param dir 记录目录
+* @returns 记录文件路径
+*/
+function getFilepath(pathname, dir) {
+	return path.join(dir, `${kebabCase(pathname)}.json`);
+}
+//#endregion
+//#region src/recorder/storage.ts
+const storage = /* @__PURE__ */ new Map();
+/**
+* 读取记录文件
+*
+* @param filepath 记录文件路径
+* @returns 记录的请求数组
+*/
+async function readRecordStorage(filepath) {
+	if (storage.has(filepath)) return storage.get(filepath);
+	try {
+		if (!fs.existsSync(filepath)) return [];
+		const content = await fs.promises.readFile(filepath, "utf-8") || "[]";
+		const data = JSON.parse(content);
+		storage.set(filepath, data);
+		return data;
+	} catch (error) {
+		console.error(`Error reading record file ${filepath}:`, error);
+		return [];
+	}
+}
+/**
+* 写入记录文件
+*
+* @param filepath 记录文件路径
+* @param records 记录的请求数组
+*/
+async function writeRecordStorage(filepath, records) {
+	try {
+		storage.set(filepath, records);
+		await fs.promises.mkdir(path.dirname(filepath), { recursive: true });
+		await fs.promises.writeFile(filepath, JSON.stringify(records, null, 2), "utf-8");
+	} catch (error) {
+		console.error(`Error writing record file ${filepath}:`, error);
+	}
+}
+const originalReqCache = /* @__PURE__ */ new WeakMap();
+/**
+* Record a request with the raw request object.
+*
+* 记录原始请求对象的请求
+*
+* @param req The original request object / 原始请求对象
+* @param pathname The request pathname / 请求路径名
+* @param body The request body / 请求体
+*/
+function recordRequestWithRawReq(req, pathname, body) {
+	originalReqCache.set(req, {
+		body,
+		pathname,
+		timestamp: Date.now()
+	});
+}
+//#endregion
+//#region src/recorder/Recorder.ts
+/**
+* 请求记录器
+*/
+var Recorder = class {
+	options;
+	filter;
+	constructor(options) {
+		this.options = options;
+		this.filter = createRecordMatcher(options.filter);
+		this.addGitignore();
+	}
+	getPlugin() {
+		return (proxyServer) => {
+			proxyServer.on("proxyRes", (proxyRes, req) => {
+				let chunks = [];
+				proxyRes.on("data", (chunk) => chunk && chunks.push(chunk));
+				proxyRes.on("end", () => {
+					this.record(req, proxyRes, Buffer.concat(chunks));
+					chunks = null;
+				});
+			});
+		};
+	}
+	async record(req, res, resBody) {
+		if (!originalReqCache.has(req)) return;
+		const { body, pathname, timestamp } = originalReqCache.get(req);
+		originalReqCache.delete(req);
+		if (!pathname) return;
+		const recordReq = processRecordReq(req, pathname, body);
+		if (!this.filter(recordReq)) return;
+		const { cwd, dir, status, expires, overwrite } = this.options;
+		if (status.length !== 0 && !status.includes(res.statusCode || 200)) return;
+		const record = {
+			meta: {
+				timestamp,
+				filepath: "",
+				createAt: timeFormatter.format(timestamp),
+				referer: req.headers.referer || "unknown"
+			},
+			req: recordReq,
+			res: await processRecordRes(res, resBody)
+		};
+		const filepath = getFilepath(pathname, dir);
+		record.meta.filepath = filepath;
+		const absoluteFilepath = path.join(cwd, filepath);
+		const records = (await readRecordStorage(absoluteFilepath)).filter((item) => timestamp - item.meta.timestamp <= expires);
+		const index = records.findIndex((item) => isSameRecord(item.req, record.req) && item.res.status === record.res.status);
+		if (index === -1) records.push(record);
+		else if (overwrite || timestamp - records[index].meta.timestamp > expires) records[index] = record;
+		await writeRecordStorage(absoluteFilepath, records);
+	}
+	async addGitignore() {
+		const options = this.options;
+		if (!options.gitignore) return;
+		const dirname = path.join(options.cwd, options.dir);
+		await promises.mkdir(dirname, { recursive: true });
+		if (!fs.existsSync(path.join(dirname, ".gitignore"))) await promises.writeFile(path.join(dirname, ".gitignore"), "*\n", "utf-8");
+	}
+};
+//#endregion
+//#region src/recorder/replay.ts
+/**
+* Replay a recorded request.
+*
+* 重放已记录的请求
+*
+* @param rawReq The original request object / 原始请求对象
+* @param pathname The request pathname / 请求路径名
+* @param body The request body / 请求体
+* @param options Record options / 录制配置项
+* @returns The recorded request object if found, otherwise undefined / 如果找到记录的请求对象，则返回该对象，否则返回 undefined
+*/
+async function replayRecordedRequest(rawReq, pathname, body, options) {
+	const req = processRecordReq(rawReq, pathname, body);
+	const filepath = path.join(options.cwd, getFilepath(req.pathname, options.dir));
+	const timestamp = Date.now();
+	const records = await readRecordStorage(filepath);
+	const matchedList = records.filter((item) => timestamp - item.meta.timestamp < options.expires && isSameRecord(item.req, req));
+	let matched;
+	if (options.status.length === 0) matched = matchedList.find((item) => item.res.status === 200) || records[0];
+	else matched = matchedList.find((item) => options.status.includes(item.res.status));
+	if (matched) {
+		const isText = isTextContent(matched.res.headers["content-type"] || "");
+		return {
+			url: matched.req.pathname,
+			status: matched.res.status,
+			statusText: matched.res.statusText,
+			headers: matched.res.headers,
+			body: Buffer.from(matched.res.body, isText ? "utf-8" : "base64"),
+			type: "buffer",
+			__filepath__: matched.meta.filepath
+		};
+	}
+}
+//#endregion
+//#region src/mockHttp/matchingWeight.ts
 const tokensCache = {};
 function getTokens(rule) {
 	if (tokensCache[rule]) return tokensCache[rule];
@@ -683,7 +1147,7 @@ function matchingWeight(rules, url, priority) {
 	return matched;
 }
 //#endregion
-//#region src/core/requestRecovery.ts
+//#region src/mockHttp/requestRecovery.ts
 /**
 * 请求复原
 *
@@ -694,10 +1158,10 @@ function matchingWeight(rules, url, priority) {
 const requestCollectCache = /* @__PURE__ */ new WeakMap();
 function collectRequest(req) {
 	const chunks = [];
-	req.addListener("data", (chunk) => {
+	req.on("data", (chunk) => {
 		chunks.push(Buffer.from(chunk));
 	});
-	req.addListener("end", () => {
+	req.on("end", () => {
 		if (chunks.length) requestCollectCache.set(req, Buffer.concat(chunks));
 	});
 }
@@ -710,22 +1174,40 @@ function rewriteRequest(proxyReq, req) {
 	}
 }
 //#endregion
-//#region src/core/response.ts
+//#region src/mockHttp/response.ts
 /**
+* Get HTTP status text by status code
+*
 * 根据状态码获取状态文本
+*
+* @param status - HTTP status code / HTTP 状态码
+* @returns HTTP status text / HTTP 状态文本
 */
 function getHTTPStatusText(status) {
 	return HTTP_STATUS[status] || "Unknown";
 }
 /**
+* Set response status
+*
 * 设置响应状态
+*
+* @param response - Response object / 响应对象
+* @param status - HTTP status code / HTTP 状态码
+* @param statusText - HTTP status text / HTTP 状态文本
 */
 function provideResponseStatus(response, status = 200, statusText) {
 	response.statusCode = status;
 	response.statusMessage = statusText || getHTTPStatusText(status);
 }
 /**
+* Set response headers
+*
 * 设置响应头
+*
+* @param req - Request object / 请求对象
+* @param res - Response object / 响应对象
+* @param mock - Mock HTTP item / Mock HTTP 配置项
+* @param logger - Logger instance / 日志实例
 */
 async function provideResponseHeaders(req, res, mock, logger) {
 	const { headers, type = "json" } = mock;
@@ -736,37 +1218,46 @@ async function provideResponseHeaders(req, res, mock, logger) {
 	res.setHeader("X-Mock-Power-By", "vite-plugin-mock-dev-server");
 	if (filepath) res.setHeader("X-File-Path", filepath);
 	if (!headers) return;
-	try {
-		const raw = isFunction(headers) ? await headers(req) : headers;
-		Object.keys(raw).forEach((key) => {
-			res.setHeader(key, raw[key]);
-		});
-	} catch (e) {
-		logger.error(`${ansis.red(`mock error at ${req.url.split("?")[0]}`)}\n${e}\n  at headers (${ansis.underline(filepath)})`, mock.log);
+	const [error, data] = await attemptAsync(async () => isFunction(headers) ? await headers(req) : headers);
+	if (error) {
+		logger.error(`${ansis.red(`mock error at ${req.url.split("?")[0]}`)}\n${error}\n  at headers (${ansis.underline(filepath)})`, mock.log);
+		return;
 	}
+	objectKeys(data).forEach((key) => res.setHeader(key, data[key]));
 }
 /**
+* Set response cookies
+*
 * 设置响应cookie
+*
+* @param req - Request object / 请求对象
+* @param res - Response object / 响应对象
+* @param mock - Mock HTTP item / Mock HTTP 配置项
+* @param logger - Logger instance / 日志实例
 */
 async function provideResponseCookies(req, res, mock, logger) {
 	const { cookies } = mock;
-	const filepath = mock.__filepath__;
 	if (!cookies) return;
-	try {
-		const raw = isFunction(cookies) ? await cookies(req) : cookies;
-		Object.keys(raw).forEach((key) => {
-			const cookie = raw[key];
-			if (isArray(cookie)) {
-				const [value, options] = cookie;
-				res.setCookie(key, value, options);
-			} else res.setCookie(key, cookie);
-		});
-	} catch (e) {
-		logger.error(`${ansis.red(`mock error at ${req.url.split("?")[0]}`)}\n${e}\n  at cookies (${ansis.underline(filepath)})`, mock.log);
+	const [error, data] = await attemptAsync(async () => isFunction(cookies) ? await cookies(req) : cookies);
+	if (error) {
+		const filepath = mock.__filepath__;
+		logger.error(`${ansis.red(`mock error at ${req.url.split("?")[0]}`)}\n${error}\n  at cookies (${ansis.underline(filepath)})`, mock.log);
+		return;
 	}
+	objectKeys(data).forEach((key) => {
+		const cookie = data[key];
+		const [value, options] = isArray(cookie) ? cookie : [cookie];
+		res.setCookie(key, value, options);
+	});
 }
 /**
+* Send response data
+*
 * 设置响应数据
+*
+* @param res - Response object / 响应对象
+* @param raw - Response body data / 响应体数据
+* @param type - Response data type / 响应数据类型
 */
 function sendResponseData(res, raw, type) {
 	if (isReadableStream(raw)) raw.pipe(res);
@@ -777,7 +1268,12 @@ function sendResponseData(res, raw, type) {
 	}
 }
 /**
+* Apply real response delay
+*
 * 实际响应延迟
+*
+* @param startTime - Request start time / 请求开始时间
+* @param delay - Delay configuration / 延迟配置
 */
 async function responseRealDelay(startTime, delay) {
 	if (!delay || typeof delay === "number" && delay <= 0 || isArray(delay) && delay.length !== 2) return;
@@ -789,8 +1285,28 @@ async function responseRealDelay(startTime, delay) {
 	if (realDelay > 0) await sleep(realDelay);
 }
 //#endregion
-//#region src/core/mockMiddleware.ts
-function baseMiddleware(compiler, { formidableOptions = {}, bodyParserOptions = {}, proxies, cookiesOptions, logger, priority = {}, cors: corsOptions }) {
+//#region src/mockHttp/middleware.ts
+/**
+* Create mock middleware
+*
+* 创建 Mock 中间件
+*
+* @param compiler - Compiler instance / 编译器实例
+* @param options - Middleware options / 中间件配置项
+* @param options.formidableOptions - Formidable options / Formidable 配置项
+* @param options.bodyParserOptions - Body parser options / 请求体解析配置项
+* @param options.proxies - Proxy paths / 代理路径
+* @param options.cookiesOptions - Cookies options / Cookies 配置项
+* @param options.logger - Logger instance / 日志实例
+* @param options.priority - Path matching priority / 路径匹配优先级
+* @param options.cors - CORS options / CORS 配置项
+* @param options.record - Record options / 录制配置项
+* @param options.replay - Replay options / 回放配置项
+* @param options.activeScene - Active scene / 活动场景
+*
+* @returns Connect middleware function / Connect 中间件函数
+*/
+function createMockMiddleware(compiler, { formidableOptions = {}, bodyParserOptions = {}, proxies, cookiesOptions, logger, priority = {}, cors: corsOptions, record, replay, activeScene }) {
 	const cors = createCors(corsOptions);
 	const [globFilter, contextFilter] = partition(proxies, (item) => isString(item) && item.includes("*"));
 	const { isMatch: isGlobProxiesMatch } = createMatcher(globFilter, [], false);
@@ -802,35 +1318,38 @@ function baseMiddleware(compiler, { formidableOptions = {}, bodyParserOptions =
 		if (globFilter.length && !isGlobProxiesMatch(pathname)) return next();
 		const mockData = compiler.mockData;
 		const mockUrls = matchingWeight(Object.keys(mockData), pathname, priority);
-		if (mockUrls.length === 0) return next();
+		if (mockUrls.length === 0 && !record.enabled) return next();
 		collectRequest(req);
-		const { query: refererQuery } = urlParse(req.headers.referer || "");
-		const reqBody = await parseRequestBody(req, formidableOptions, bodyParserOptions);
 		const cookies = new Cookies(req, res, cookiesOptions);
-		const getCookie = cookies.get.bind(cookies);
-		const method = req.method.toUpperCase();
 		let mock;
 		let _mockUrl;
+		const method = req.method.toUpperCase();
+		const extraReq = {
+			query,
+			refererQuery: urlParse(req.headers.referer || "").query,
+			body: await parseRequestBody(req, logger, formidableOptions, bodyParserOptions),
+			headers: req.headers,
+			getCookie: cookies.get.bind(cookies)
+		};
+		const headerScene = req.headers["x-mock-scene"];
+		const effectiveScene = headerScene ? toArray(headerScene).map((item) => item.split(",").map((s) => s.trim())).flat().filter(Boolean) : activeScene;
 		for (const mockUrl of mockUrls) {
 			mock = findMockData(mockData[mockUrl], logger, {
 				pathname,
 				method,
-				request: {
-					query,
-					refererQuery,
-					body: reqBody,
-					headers: req.headers,
-					getCookie
-				}
+				request: extraReq,
+				activeScene: effectiveScene
 			});
 			if (mock) {
 				_mockUrl = mockUrl;
 				break;
 			}
 		}
+		if (replay && !mock) mock = await replayRecordedRequest(req, pathname, extraReq.body, record);
 		if (!mock) {
+			record.enabled && recordRequestWithRawReq(req, pathname, extraReq.body);
 			const matched = mockUrls.map((m) => m === _mockUrl ? ansis.underline.bold(m) : ansis.dim(m)).join(", ");
-			logger.warn(`${ansis.green(pathname)} matches  ${matched} , but mock data is not found.`);
+			matched.length && logger.warn(`${ansis.green(pathname)} matches ${matched}, but mock data is not found.`);
 			return next();
 		}
 		if (cors) {
@@ -842,36 +1361,42 @@ function baseMiddleware(compiler, { formidableOptions = {}, bodyParserOptions =
 		}
 		const request = req;
 		const response = res;
-		request.body = reqBody;
-		request.query = query;
-		request.refererQuery = refererQuery;
+		Object.assign(request, extraReq);
 		request.params = parseRequestParams(mock.url, pathname);
-		request.getCookie = getCookie;
 		response.setCookie = cookies.set.bind(cookies);
-		const { body, delay, type = "json", response: responseFn, status = 200, statusText, log: logLevel, __filepath__: filepath } = mock;
+		const { delay, type = "json", response: responseFn, log: logLevel, error: errorConfig, __filepath__: filepath } = mock;
+		let { body, status = 200, statusText } = mock;
+		const shouldSimulateError = errorConfig && (errorConfig.probability ?? .5) > Math.random();
+		if (shouldSimulateError) {
+			status = errorConfig.status ?? 500;
+			statusText = errorConfig.statusText;
+			body = errorConfig.body;
+		}
 		provideResponseStatus(response, status, statusText);
 		await provideResponseHeaders(request, response, mock, logger);
 		await provideResponseCookies(request, response, mock, logger);
-		logger.info(requestLog(request, filepath), logLevel);
-		logger.debug(`${ansis.magenta("DEBUG")} ${ansis.underline(pathname)}  matches: [ ${mockUrls.map((m) => m === _mockUrl ? ansis.underline.bold(m) : ansis.dim(m)).join(", ")} ]\n`);
+		logger.info(requestLog(request, filepath, shouldSimulateError), logLevel);
+		logger.debug(`${ansis.magenta("DEBUG")} ${ansis.underline(pathname)} matches: [ ${mockUrls.map((m) => m === _mockUrl ? ansis.underline.bold(m) : ansis.dim(m)).join(", ")} ]\n`);
 		if (body) {
-			try {
+			const [error] = await attemptAsync(async () => {
 				const content = isFunction(body) ? await body(request) : body;
 				await responseRealDelay(startTime, delay);
 				sendResponseData(response, content, type);
-			} catch (e) {
-				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n${e}\n  at body (${ansis.underline(filepath)})`, logLevel);
+			});
+			if (error) {
+				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n  ${error}\n  at body (${ansis.underline.gray(filepath)})`, logLevel);
 				provideResponseStatus(response, 500);
 				res.end("");
 			}
 			return;
 		}
 		if (responseFn) {
-			try {
+			const [error] = await attemptAsync(async () => {
 				await responseRealDelay(startTime, delay);
 				await responseFn(request, response, next);
-			} catch (e) {
-				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n${e}\n  at response (${ansis.underline(filepath)})`, logLevel);
+			});
+			if (error) {
+				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n  ${error}\n  at response (${ansis.underline.gray(filepath)})`, logLevel);
 				provideResponseStatus(response, 500);
 				res.end("");
 			}
@@ -881,7 +1406,7 @@ function baseMiddleware(compiler, { formidableOptions = {}, bodyParserOptions =
 	};
 }
 //#endregion
-//#region src/core/ws.ts
+//#region src/mockWebsocket/server.ts
 function mockWebSocket(compiler, httpServer, { wsProxies: proxies, cookiesOptions, logger }) {
 	const hmrMap = /* @__PURE__ */ new Map();
 	const poolMap = /* @__PURE__ */ new Map();
@@ -1000,4 +1525,39 @@ function cleanupRunner(cleanupList) {
 	while (cleanup = cleanupList.shift()) cleanup?.();
 }
 //#endregion
-export { processRawData as a, normalizePath as c, logLevels as d, getPackageDepList as f, processMockData as i, vfs as l, createMatcher as m, baseMiddleware as n, sortByValidator as o, getPackageDeps as p, rewriteRequest as r, waitingFor as s, mockWebSocket as t, createLogger as u };
+//#region src/core/logger.ts
+const logLevels = {
+	silent: 0,
+	error: 1,
+	warn: 2,
+	info: 3,
+	debug: 4
+};
+function createLogger(prefix, defaultLevel = "info") {
+	prefix = `[${prefix}]`;
+	function output(type, msg, level) {
+		level = isBoolean(level) ? level ? defaultLevel : "error" : level;
+		if (logLevels[level] >= logLevels[type]) {
+			const method = type === "info" || type === "debug" ? "log" : type;
+			const tag = type === "debug" ? ansis.magenta.bold(prefix) : type === "info" ? ansis.cyan.bold(prefix) : type === "warn" ? ansis.yellow.bold(prefix) : ansis.red.bold(prefix);
+			const format = `${ansis.dim((/* @__PURE__ */ new Date()).toLocaleTimeString())} ${tag} ${msg}`;
+			console[method](format);
+		}
+	}
+	return {
+		debug(msg, level = defaultLevel) {
+			output("debug", msg, level);
+		},
+		info(msg, level = defaultLevel) {
+			output("info", msg, level);
+		},
+		warn(msg, level = defaultLevel) {
+			output("warn", msg, level);
+		},
+		error(msg, level = defaultLevel) {
+			output("error", msg, level);
+		}
+	};
+}
+//#endregion
+export { rewriteRequest as a, processRawData as c, normalizePath as d, vfs as f, createMatcher as h, createMockMiddleware as i, sortByValidator as l, getPackageDeps as m, logLevels as n, Recorder as o, getPackageDepList as p, mockWebSocket as r, processMockData as s, createLogger as t, waitingFor as u };