rspack-plugin-mock 2.0.0 → 2.2.0

package/dist/index.d.ts

@@ -1,13 +1,15 @@
-import { _ as WebSocketSetupContext, a as LogType, c as MockMatchPriority, d as MockRequest, f as MockResponse, g as ServerBuildOption, h as ResponseBody, i as LogLevel, l as MockMatchSpecialPriority, m as MockWebsocketItem, n as ExtraRequest, o as Method, p as MockServerPluginOptions, r as FormidableFile, s as MockHttpItem, t as BodyParserOptions, u as MockOptions } from "./types-GT6M6WuI.js";
-import { HeaderStream, MockData, SSEMessage, createDefineMock, createSSEStream, defineMock, defineMockData } from "./helper.js";
-import { a as processMockData, c as Logger, i as baseMiddleware, l as createLogger, n as mockWebSocket, o as processRawData, r as BaseMiddlewareOptions, s as sortByValidator, t as MockSocketOptions, u as logLevels } from "./server-_doRwsZm.js";
-import { Compiler, RspackPluginInstance } from "@rspack/core";
-
-//#region src/rspack.d.ts
+import { A as ResponseBody, C as HandleFunction, D as MockResponse, E as MockRequest, M as CookiesOption, N as GetCookieOption, O as NextFunction, P as SetCookieOption, S as ExtraRequest, T as Method, _ as RecordedMeta, a as MockWebsocketItem, b as RecordedRes, c as MockHttpItem, d as LogType, f as MockMatchPriority, g as RecordOptions, h as ServerBuildOption, i as MockOptions, j as SimpleHandleFunction, k as NextHandleFunction, l as BodyParserOptions, m as MockServerPluginOptions, n as HttpProxyPlugin, o as WebSocketSetupContext, p as MockMatchSpecialPriority, r as PathFilter, s as MockErrorConfig, t as FormidableFile, u as LogLevel, v as RecordedReq, w as Headers, x as ResolvedRecordOptions, y as RecordedRequest } from "./index-BjZK24gW.js";
+import { DefineMockDataOptions, HeaderStream, MockData, SSEMessage, createDefineMock, createSSEStream, defineMock, defineMockData } from "./helper.js";
+import { a as processMockData, c as MockCompiler, d as createLogger, f as logLevels, i as createMockMiddleware, l as ResolvePluginOptions, n as mockWebSocket, o as processRawData, r as CreateMockMiddlewareOptions, s as sortByValidator, t as MockSocketOptions, u as Logger } from "./server-DurHqymI.js";
+import { Compiler, DevServer, RspackPluginInstance } from "@rspack/core";
+//#region src/core/rspack.d.ts
 declare class MockServerPlugin implements RspackPluginInstance {
   options: MockServerPluginOptions;
   constructor(options?: MockServerPluginOptions);
   apply(compiler: Compiler): void;
+  provideMiddleware(mockCompiler: MockCompiler, devServer: DevServer, options: ResolvePluginOptions): void;
+  provideProxyConfig(options: ResolvePluginOptions, devServer: DevServer): void;
+  resolvePluginOptions(compiler: Compiler, options?: MockServerPluginOptions): ResolvePluginOptions;
 }
 //#endregion
-export { BaseMiddlewareOptions, BodyParserOptions, ExtraRequest, type FormidableFile, HeaderStream, LogLevel, LogType, Logger, Method, MockData, type MockHttpItem, MockMatchPriority, MockMatchSpecialPriority, type MockOptions, type MockRequest, MockResponse, MockServerPlugin, type MockServerPluginOptions, MockSocketOptions, type MockWebsocketItem, ResponseBody, SSEMessage, ServerBuildOption, WebSocketSetupContext, baseMiddleware, createDefineMock, createLogger, createSSEStream, defineMock, defineMockData, logLevels, mockWebSocket, processMockData, processRawData, sortByValidator };
+export { type BodyParserOptions, type CookiesOption, CreateMockMiddlewareOptions, DefineMockDataOptions, type ExtraRequest, type FormidableFile, type GetCookieOption, type HandleFunction, HeaderStream, type Headers, type HttpProxyPlugin, type LogLevel, type LogType, Logger, type Method, MockData, type MockErrorConfig, type MockHttpItem, type MockMatchPriority, type MockMatchSpecialPriority, type MockOptions, type MockRequest, type MockResponse, MockServerPlugin, type MockServerPluginOptions, MockSocketOptions, type MockWebsocketItem, type NextFunction, type NextHandleFunction, type PathFilter, type RecordOptions, type RecordedMeta, type RecordedReq, type RecordedRequest, type RecordedRes, type ResolvedRecordOptions, type ResponseBody, SSEMessage, type ServerBuildOption, type SetCookieOption, type SimpleHandleFunction, type WebSocketSetupContext, createDefineMock, createLogger, createMockMiddleware, createSSEStream, defineMock, defineMockData, logLevels, mockWebSocket, processMockData, processRawData, sortByValidator };

package/dist/index.js

@@ -1,84 +1,94 @@
+import { a as rewriteRequest, c as processRawData, i as createMockMiddleware, l as sortByValidator, n as logLevels, o as Recorder, r as mockWebSocket, s as processMockData, t as createLogger } from "./logger-DTZcb53u.js";
+import { n as buildMockServer, r as createMockCompiler, t as resolvePluginOptions } from "./options-C3NAM6gv.js";
 import { createDefineMock, createSSEStream, defineMock, defineMockData } from "./helper.js";
-import { a as processRawData, d as logLevels, i as processMockData, n as baseMiddleware, o as sortByValidator, r as rewriteRequest, s as waitingFor, t as mockWebSocket, u as createLogger } from "./ws-BcLCWVaK.js";
-import { n as buildMockServer, r as createMockCompiler, t as resolvePluginOptions$1 } from "./options-Bd0PSZeT.js";
 import "./server.js";
-import { isFunction, isString, toArray, toTruthy } from "@pengzhanbo/utils";
 import path from "node:path";
 import process from "node:process";
+import { isFunction, isString, toArray, toTruthy } from "@pengzhanbo/utils";
 import rspack from "@rspack/core";
-//#region src/rspack.ts
+
+function waitingFor(onSuccess, maxRetry = 5) {
+	return function wait(getter, retry = 0) {
+		const value = getter();
+		if (value) onSuccess(value);
+		else if (retry < maxRetry) setTimeout(() => wait(getter, retry + 1), 100);
+	};
+}
+
+
 const PLUGIN_NAME = "rspack-plugin-mock";
 var MockServerPlugin = class {
+	options;
 	constructor(options = {}) {
 		this.options = options;
 	}
 	apply(compiler) {
+		if (this.options.enabled === false) return;
 		const compilerOptions = compiler.options;
-		const options = resolvePluginOptions(compiler, this.options);
-		if (process.env.NODE_ENV !== "production") {
-			if (compilerOptions.devServer === false) {
-				options.logger.warn(`${PLUGIN_NAME} is disabled, because devServer is disabled`);
-				return;
-			}
-			const mockCompiler = createMockCompiler(options);
-			const setupMiddlewares = compilerOptions.devServer?.setupMiddlewares;
-			const waitServerForMockWebSocket = waitingFor((server) => {
-				mockWebSocket(mockCompiler, server, options);
+		const options = this.resolvePluginOptions(compiler, this.options);
+		const isProd = process.env.NODE_ENV === "production";
+		if (isProd && options.build !== false) compiler.hooks.afterEmit.tap(PLUGIN_NAME, () => buildMockServer(options, compilerOptions.output.path || path.resolve(process.cwd(), "dist")));
+		if (isProd) return;
+		if (compilerOptions.devServer === false) {
+			options.logger.warn(`Not find devServer, ${PLUGIN_NAME} was disabled`);
+			return;
+		}
+		const devServer = compilerOptions.devServer ||= {};
+		const mockCompiler = createMockCompiler(options);
+		this.provideMiddleware(mockCompiler, devServer, options);
+		this.provideProxyConfig(options, devServer);
+		compiler.hooks.watchRun.tap(PLUGIN_NAME, () => mockCompiler.run());
+		compiler.hooks.watchClose.tap(PLUGIN_NAME, () => mockCompiler.close());
+	}
+	provideMiddleware(mockCompiler, devServer, options) {
+		const setupMiddlewares = devServer.setupMiddlewares;
+		const waitServerForMockWebSocket = waitingFor((server) => {
+			mockWebSocket(mockCompiler, server, options);
+		});
+		devServer.setupMiddlewares = function(middlewares, devServer) {
+			middlewares = setupMiddlewares?.(middlewares, devServer) || middlewares;
+			middlewares.unshift(createMockMiddleware(mockCompiler, options));
+			if (options.reload) mockCompiler.on("update", () => {
+				if (devServer.webSocketServer?.clients) devServer.sendMessage(devServer.webSocketServer.clients, "static-changed");
 			});
-			compilerOptions.devServer = {
-				...compilerOptions.devServer,
-				setupMiddlewares: (middlewares, devServer) => {
-					middlewares = setupMiddlewares?.(middlewares, devServer) || middlewares;
-					middlewares.unshift(baseMiddleware(mockCompiler, options));
-					if (options.reload) mockCompiler.on("update", () => {
-						if (devServer.webSocketServer?.clients) devServer.sendMessage(devServer.webSocketServer.clients, "static-changed");
-					});
-					/**
-					* 在 @rspack/dev-server 中, setupMiddlewares 优先于 createServer
-					* 执行，需要等待 server 启动后再注入 mock websocket
-					*/
-					waitServerForMockWebSocket(() => devServer.server);
-					return middlewares;
-				}
-			};
-			const wsPrefix = toArray(options.wsPrefix);
-			if (compilerOptions.devServer?.proxy?.length) {
-				const proxy = compilerOptions.devServer.proxy;
-				compilerOptions.devServer.proxy = proxy.filter((item) => {
-					if (!isFunction(item) && item.ws === true && wsPrefix.length) return !toArray(item.pathFilter || item.context).filter(isString).some((context) => wsPrefix.includes(context));
-					return true;
-				}).map((item) => {
-					if (!isFunction(item) && !item.ws) {
-						const on = item.on ??= {};
-						const onProxyReq = on.proxyReq;
-						on.proxyReq = (proxyReq, req, ...args) => {
-							onProxyReq?.(proxyReq, req, ...args);
-							rewriteRequest(proxyReq, req);
-						};
-					}
-					return item;
-				});
+			
+			waitServerForMockWebSocket(() => devServer.server);
+			return middlewares;
+		};
+	}
+	provideProxyConfig(options, devServer) {
+		if (!devServer.proxy?.length) return;
+		const wsPrefix = toArray(options.wsPrefix);
+		let recorder = null;
+		if (options.record.enabled) recorder = new Recorder(options.record);
+		devServer.proxy = devServer.proxy.filter((item) => {
+			if (!isFunction(item) && item.ws === true && wsPrefix.length) return !toArray(item.pathFilter || item.context).filter(isString).some((context) => wsPrefix.includes(context));
+			return true;
+		}).map((item) => {
+			if (!isFunction(item) && !item.ws) {
+				const plugins = item.plugins ??= [];
+				plugins.push((proxyServer) => proxyServer.on("proxyReq", rewriteRequest));
+				if (options.record.enabled && recorder) plugins.push(recorder.getPlugin());
 			}
-			compiler.hooks.watchRun.tap(PLUGIN_NAME, () => mockCompiler.run());
-			compiler.hooks.watchClose.tap(PLUGIN_NAME, () => mockCompiler.close());
-		} else if (options.build !== false) compiler.hooks.afterEmit.tap(PLUGIN_NAME, () => buildMockServer(options, compilerOptions.output.path || path.resolve(process.cwd(), "dist")));
+			return item;
+		});
+	}
+	resolvePluginOptions(compiler, options = {}) {
+		const compilerOptions = compiler.options;
+		const alias = compilerOptions.resolve?.alias || {};
+		const context = compilerOptions.context;
+		const definePluginInstance = compilerOptions.plugins?.find((plugin) => plugin instanceof rspack.DefinePlugin);
+		const proxies = ((compilerOptions.devServer || {}).proxy || []).flatMap((item) => {
+			if (!isFunction(item) && !item.ws) return item.pathFilter || item.context;
+			return [];
+		}).filter(toTruthy);
+		return resolvePluginOptions(options, {
+			alias,
+			context,
+			plugins: toArray(definePluginInstance),
+			proxies
+		});
 	}
 };
-function resolvePluginOptions(compiler, options = {}) {
-	const compilerOptions = compiler.options;
-	const alias = compilerOptions.resolve?.alias || {};
-	const context = compilerOptions.context;
-	const definePluginInstance = compilerOptions.plugins?.find((plugin) => plugin instanceof rspack.DefinePlugin);
-	const proxies = ((compilerOptions.devServer || {}).proxy || []).flatMap((item) => {
-		if (!isFunction(item) && !item.ws) return item.pathFilter || item.context;
-		return [];
-	}).filter(toTruthy);
-	return resolvePluginOptions$1(options, {
-		alias,
-		context,
-		plugins: toArray(definePluginInstance),
-		proxies
-	});
-}
-//#endregion
-export { MockServerPlugin, baseMiddleware, createDefineMock, createLogger, createSSEStream, defineMock, defineMockData, logLevels, mockWebSocket, processMockData, processRawData, sortByValidator };
+
+export { MockServerPlugin, createDefineMock, createLogger, createMockMiddleware, createSSEStream, defineMock, defineMockData, logLevels, mockWebSocket, processMockData, processRawData, sortByValidator };

package/dist/json5-loader.mjs

@@ -1,8 +1,8 @@
 import JSON5 from "json5";
 //#region src/json5-loader.ts
-function json5_loader_default(content) {
+function json5Loader(content) {
 	if (!content) return "export default {}";
 	return `export default ${JSON.stringify(JSON5.parse(content))}`;
 }
 //#endregion
-export { json5_loader_default as default };
+export { json5Loader as default };