@mswjs/interceptors 0.42.4 → 0.42.5

package/lib/node/{source-BFZ6wg4P.js → source-DHVO1vzq.js}

@@ -1,8 +1,8 @@
 import { n as createLogger, r as formatRequest, t as Interceptor } from "./interceptor-C8qRPjxG.js";
-import { a as isResponseError, c as isObject, d as RequestController, f as InterceptorError, l as getRawFetchHeaders, n as FetchResponse, o as isResponseLike, r as createServerErrorResponse, s as kErrorResponse, t as FetchRequest, u as recordRawFetchHeaders } from "./fetch-utils-Tm5LbwBe.js";
+import { a as isResponseError, c as isObject, d as recordRawFetchHeaders, f as RequestController, l as copyRawHeaders, n as FetchResponse, o as isResponseLike, p as InterceptorError, r as createServerErrorResponse, s as kErrorResponse, t as FetchRequest, u as getRawFetchHeaders } from "./fetch-utils-D-_xeRlK.js";
 import { t as createRequestId } from "./create-request-id-DHo-fRTV.js";
 import { r as toBuffer } from "./buffer-utils-B4FUq-l2.js";
-import { i as unwrapPendingData, n as SocketController, r as kRawSocket, t as SocketInterceptor } from "./net-DkiHxhQF.js";
+import { i as unwrapPendingData, n as SocketController, r as kRawSocket, t as SocketInterceptor } from "./net-Bh16MP4u.js";
 import { TypedEvent } from "rettime";
 import { invariant } from "outvariant";
 import { IncomingMessage, METHODS, STATUS_CODES, ServerResponse } from "node:http";
@@ -1573,6 +1573,56 @@ async function handleRequest(options) {
 	return options.controller.handled;
 }
 //#endregion
+//#region src/utils/clone-response.ts
+/** Clone for observers without letting their unread body block caller cancellation. */
+function cloneResponse(response) {
+	const clone = FetchResponse.clone(response);
+	if (!response.body || !clone.body) return [response, clone];
+	const observer = wrapResponse(clone);
+	return [wrapResponse(response, observer.cancel).response, observer.response];
+}
+function wrapResponse(response, onCancel) {
+	const body = response.body;
+	const reader = body.getReader();
+	const cancel = (reason) => {
+		return body.locked ? reader.cancel(reason) : body.cancel(reason);
+	};
+	const wrappedResponse = new FetchResponse(new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await reader.read();
+				if (done) {
+					controller.close();
+					reader.releaseLock();
+					return;
+				}
+				controller.enqueue(value);
+			} catch (error) {
+				controller.error(error);
+				reader.releaseLock();
+			}
+		},
+		async cancel(reason) {
+			try {
+				const cancellation = cancel(reason);
+				if (onCancel) await Promise.all([cancellation, onCancel(reason)]);
+				else cancellation.catch(() => {});
+			} finally {
+				reader.releaseLock();
+			}
+		}
+	}, { highWaterMark: 0 }), response);
+	copyRawHeaders(response.headers, wrappedResponse.headers);
+	Object.defineProperties(wrappedResponse, {
+		type: { value: response.type },
+		redirected: { value: response.redirected }
+	});
+	return {
+		response: wrappedResponse,
+		cancel
+	};
+}
+//#endregion
 //#region src/interceptors/http/source.ts
 const httpLogger = createLogger("http-request");
 /**
@@ -1636,258 +1686,265 @@ var NodeHttpRequestSource = class extends Interceptor {
 				abortPendingRequest?.();
 				realSocketDestroy(error, callback);
 			};
-			/**
-			* @note Only inspect the first sent packet to determine the protocol.
-			* A single socket cannot be used for different protocols.
-			*/
-			socket.on("data", (chunk) => {
-				if (isHttpConnection === false) {
-					socketController.decline();
-					return;
-				}
+			const addRequestDataListener = () => {
+				const executeRequestParser = (parser, chunk) => {
+					if (parser.execute(chunk) !== null) {
+						socket.removeListener("data", onRequestData);
+						parser.free();
+						requestParser = void 0;
+					}
+				};
 				/**
-				* @note A mocked "CONNECT" request has established a tunnel.
-				* The data that follows belongs to a new exchange addressed to
-				* the tunnel target. The parser stopped at the tunnel boundary
-				* (HTTP upgrade semantics), so tear it down and detect the
-				* tunneled protocol anew, like on a fresh connection.
+				* @note Inspect the first sent packet to determine the protocol,
+				* including when entering a mocked "CONNECT" tunnel.
 				*/
-				if (tunnelUrl && requestParser) {
-					requestParser.free();
-					requestParser = void 0;
-					isHttpConnection = void 0;
-					/**
-					* @note Retarget the connection to the tunnel authority.
-					* The exchanges that follow belong to the tunnel target,
-					* so an unclaimed exchange (HTTP or not) must pass through
-					* to that target — not to the proxy, which never actually
-					* established this tunnel — like a real established tunnel
-					* relays its traffic.
-					*/
-					socketController.reset({
-						host: tunnelUrl.hostname,
-						port: Number(tunnelUrl.port) || 80,
-						path: null
-					});
-				}
-				if (requestParser) {
-					requestParser.execute(toBuffer(chunk));
-					return;
-				}
-				const httpMessage = chunk.toString();
-				const httpMethod = httpMessage.split(" ")[0] || "";
-				if (!METHODS.includes(httpMethod.toUpperCase())) {
-					isHttpConnection = false;
-					socketController.decline();
-					return;
-				}
-				isHttpConnection = true;
-				const baseUrl = tunnelUrl ?? connectionOptionsToUrl(connectionOptions, socket);
-				httpLogger.verbose("handling http message %o", {
-					httpMessage,
-					httpMethod,
-					baseUrl
-				});
-				const requestContextValue = requestContext.getStore() ?? connectionRequestContext;
-				const initiator = requestContextValue?.initiator || socket;
-				requestParser = new HttpRequestParser({
-					onError: stopParsingRequests,
-					connectionOptions: {
-						method: httpMethod,
-						url: baseUrl
-					},
+				const onRequestData = (chunk) => {
+					if (isHttpConnection === false) {
+						socketController.decline();
+						return;
+					}
 					/**
-					* @note The message boundary ends the current exchange.
-					* Schedule the controller reset so the next write on this
-					* (kept-alive) socket opens a new exchange and buffers for
-					* its own verdict instead of following the settled one
-					* (e.g. leaking a mocked request to the server of a
-					* previously passed-through exchange).
+					* @note A mocked "CONNECT" request has established a tunnel.
+					* The data that follows belongs to a new exchange addressed to
+					* the tunnel target. The previous parser was freed at the upgrade
+					* boundary, so detect the tunneled protocol anew.
 					*/
-					onMessageComplete: () => {
-						socketController.scheduleReset();
-					},
-					onRequest: async (parsedRequest, requestAbortController) => {
-						const request = requestContextValue?.transformRequest?.(parsedRequest) ?? parsedRequest;
+					if (tunnelUrl && !requestParser) {
+						isHttpConnection = void 0;
 						/**
-						* @note A subsequent request arriving on a kept-alive socket
-						* that has already been handled (passed through or mocked).
-						* Clients like Undici reuse sockets without emitting the
-						* "free" event, so reset the controller here, at the HTTP
-						* message boundary, to handle the new request from the
-						* pending state again.
+						* @note Retarget the connection to the tunnel authority.
+						* The exchanges that follow belong to the tunnel target,
+						* so an unclaimed exchange (HTTP or not) must pass through
+						* to that target — not to the proxy, which never actually
+						* established this tunnel — like a real established tunnel
+						* relays its traffic.
 						*/
-						if (socketController["readyState"] !== SocketController.PENDING) socketController.reset();
-						const requestId = createRequestId();
-						const requestLogger = requestContextValue?.logger ?? httpLogger;
-						httpLogger.verbose("received a parsed HTTP request %o", {
-							method: request.method,
-							url: request.url
+						socketController.reset({
+							host: tunnelUrl.hostname,
+							port: Number(tunnelUrl.port) || 80,
+							path: null
 						});
-						const requestController = new RequestController(request, {
-							respondWith: async (rawResponse) => {
-								httpLogger.verbose("respondWith() %o", {
-									status: rawResponse.status,
-									statusText: rawResponse.statusText,
-									hasBody: rawResponse.body != null
-								});
-								/**
-								* @note The client may destroy the socket (e.g. on request
-								* abort) moments before a response arrives. A destroyed
-								* socket cannot be claimed and has no one reading it.
-								*/
-								if (socket.destroyed) return;
-								socketController.claim();
-								const response = FetchResponse.from(rawResponse, { url: request.url });
-								/**
-								* @note A successful mocked response to a "CONNECT"
-								* request establishes a tunnel to the requested authority
-								* (e.g. "127.0.0.1:80"). The exchange that follows on this
-								* socket is addressed to that authority, not to the proxy.
-								*/
-								if (request.method === "CONNECT" && response.ok) tunnelUrl = new URL(`http://${request.url}`);
-								/**
-								* @note Clone the response before "respondWith" because it will
-								* consume its body. This way, we can have a readable response copy
-								* for the "response" event below.
-								*/
-								const responseClone = isResponseError(response) ? null : response.clone();
-								const respond = () => {
-									return this.respondWith({
-										socket: socketController[kRawSocket],
-										request: context.request,
-										response
+					}
+					if (requestParser) {
+						executeRequestParser(requestParser, toBuffer(chunk));
+						return;
+					}
+					const httpMessage = chunk.toString();
+					const httpMethod = httpMessage.split(" ")[0] || "";
+					if (!METHODS.includes(httpMethod.toUpperCase())) {
+						isHttpConnection = false;
+						socketController.decline();
+						return;
+					}
+					isHttpConnection = true;
+					const baseUrl = tunnelUrl ?? connectionOptionsToUrl(connectionOptions, socket);
+					httpLogger.verbose("handling http message %o", {
+						httpMessage,
+						httpMethod,
+						baseUrl
+					});
+					const requestContextValue = requestContext.getStore() ?? connectionRequestContext;
+					const initiator = requestContextValue?.initiator || socket;
+					requestParser = new HttpRequestParser({
+						onError: stopParsingRequests,
+						connectionOptions: {
+							method: httpMethod,
+							url: baseUrl
+						},
+						/**
+						* @note The message boundary ends the current exchange.
+						* Schedule the controller reset so the next write on this
+						* (kept-alive) socket opens a new exchange and buffers for
+						* its own verdict instead of following the settled one
+						* (e.g. leaking a mocked request to the server of a
+						* previously passed-through exchange).
+						*/
+						onMessageComplete: () => {
+							socketController.scheduleReset();
+						},
+						onRequest: async (parsedRequest, requestAbortController) => {
+							const request = requestContextValue?.transformRequest?.(parsedRequest) ?? parsedRequest;
+							/**
+							* @note A subsequent request arriving on a kept-alive socket
+							* that has already been handled (passed through or mocked).
+							* Clients like Undici reuse sockets without emitting the
+							* "free" event, so reset the controller here, at the HTTP
+							* message boundary, to handle the new request from the
+							* pending state again.
+							*/
+							if (socketController["readyState"] !== SocketController.PENDING) socketController.reset();
+							const requestId = createRequestId();
+							const requestLogger = requestContextValue?.logger ?? httpLogger;
+							httpLogger.verbose("received a parsed HTTP request %o", {
+								method: request.method,
+								url: request.url
+							});
+							const requestController = new RequestController(request, {
+								respondWith: async (rawResponse) => {
+									httpLogger.verbose("respondWith() %o", {
+										status: rawResponse.status,
+										statusText: rawResponse.statusText,
+										hasBody: rawResponse.body != null
 									});
-								};
-								if (responseClone) await this.emitter.emitAsPromise(new HttpResponseEvent({
-									initiator,
-									requestId,
-									request: context.request,
-									response: responseClone,
-									responseType: "mock"
-								}));
-								if (socket.connecting) socket.once("connect", respond);
-								else
- /**
-								* @note Reused sockets stay connected between requests and will not
-								* emit "connect" anymore. If that's the case, respond immediately.
-								*/
-								await respond();
-							},
-							errorWith: (reason) => {
-								if (reason instanceof Error) socket.destroy(reason);
-							},
-							passthrough: () => {
-								const realSocket = socketController.passthrough(isHttpConnection === false ? void 0 : this.#modifyHttpHeaders(context.request));
-								if (isHttpConnection === false) return;
-								if (this.emitter.listenerCount("response") > 0) {
-									httpLogger.verbose("found \"response\" listener, corking socket reads");
 									/**
-									* Suspend the delivery of the original response to the client
-									* until the "response" event listeners settle. This guarantees
-									* that the request promise (e.g. `await fetch()`) does not
-									* resolve before the listeners are done. The real socket keeps
-									* emitting data for the response parser meanwhile.
+									* @note The client may destroy the socket (e.g. on request
+									* abort) moments before a response arrives. A destroyed
+									* socket cannot be claimed and has no one reading it.
 									*/
-									socketController.corkReads();
-									let responseParserDisposed = false;
-									let responseComplete = false;
-									let hasFinalResponse = false;
-									const responseParser = new HttpResponseParser({
-										onError: (error) => {
-											disposeResponseParser(error);
-											socketController.uncorkReads();
-										},
-										onMessageComplete: (status) => {
-											responseComplete = status >= 200 || status === 101;
-										},
-										onResponse: async (response) => {
-											hasFinalResponse = response.status >= 200 || response.status === 101;
-											httpLogger.verbose("HTTP response parser parsed: %d %s", response.status, response.statusText);
-											if (isResponseError(response)) {
-												httpLogger.verbose("response is an error response, uncorking socket reads...");
-												socketController.uncorkReads();
-												return;
-											}
-											FetchResponse.setUrl(request.url, response);
-											try {
-												httpLogger.verbose("emitting \"response\" event");
-												await this.emitter.emitAsPromise(new HttpResponseEvent({
-													initiator,
-													requestId,
-													request: context.request,
-													response,
-													responseType: "original"
-												}));
-											} finally {
-												httpLogger.verbose("uncorking socket reads");
+									if (socket.destroyed) return;
+									socketController.claim();
+									const originalResponse = FetchResponse.from(rawResponse, { url: request.url });
+									const [response, responseClone] = !isResponseError(originalResponse) && this.emitter.listenerCount("response") > 0 ? cloneResponse(originalResponse) : [originalResponse, null];
+									/**
+									* @note A successful mocked response to a "CONNECT"
+									* request establishes a tunnel to the requested authority
+									* (e.g. "127.0.0.1:80"). The exchange that follows on this
+									* socket is addressed to that authority, not to the proxy.
+									*/
+									if (request.method === "CONNECT" && response.ok) {
+										tunnelUrl = new URL(`http://${request.url}`);
+										addRequestDataListener();
+									}
+									const respond = () => {
+										return this.respondWith({
+											socket: socketController[kRawSocket],
+											request: context.request,
+											response
+										});
+									};
+									if (responseClone) await this.emitter.emitAsPromise(new HttpResponseEvent({
+										initiator,
+										requestId,
+										request: context.request,
+										response: responseClone,
+										responseType: "mock"
+									}));
+									if (socket.connecting) socket.once("connect", respond);
+									else
+ /**
+									* @note Reused sockets stay connected between requests and will not
+									* emit "connect" anymore. If that's the case, respond immediately.
+									*/
+									await respond();
+								},
+								errorWith: (reason) => {
+									if (reason instanceof Error) socket.destroy(reason);
+								},
+								passthrough: () => {
+									const realSocket = socketController.passthrough(isHttpConnection === false ? void 0 : this.#modifyHttpHeaders(context.request));
+									if (isHttpConnection === false) return;
+									if (this.emitter.listenerCount("response") > 0) {
+										httpLogger.verbose("found \"response\" listener, corking socket reads");
+										/**
+										* Suspend the delivery of the original response to the client
+										* until the "response" event listeners settle. This guarantees
+										* that the request promise (e.g. `await fetch()`) does not
+										* resolve before the listeners are done. The real socket keeps
+										* emitting data for the response parser meanwhile.
+										*/
+										socketController.corkReads();
+										let responseParserDisposed = false;
+										let responseComplete = false;
+										let hasFinalResponse = false;
+										const responseParser = new HttpResponseParser({
+											onError: (error) => {
+												disposeResponseParser(error);
 												socketController.uncorkReads();
-												/**
-												* @note Informational responses other than
-												* "101 Switching Protocols" are followed by a final
-												* response on the same connection. Keep gating that
-												* final response on the "response" event listeners.
-												*/
-												if (!responseParserDisposed && response.status < 200 && response.status !== 101) socketController.corkReads();
+											},
+											onMessageComplete: (status) => {
+												responseComplete = status >= 200 || status === 101;
+											},
+											onResponse: async (response) => {
+												hasFinalResponse = response.status >= 200 || response.status === 101;
+												httpLogger.verbose("HTTP response parser parsed: %d %s", response.status, response.statusText);
+												if (isResponseError(response)) {
+													httpLogger.verbose("response is an error response, uncorking socket reads...");
+													socketController.uncorkReads();
+													return;
+												}
+												FetchResponse.setUrl(request.url, response);
+												try {
+													httpLogger.verbose("emitting \"response\" event");
+													await this.emitter.emitAsPromise(new HttpResponseEvent({
+														initiator,
+														requestId,
+														request: context.request,
+														response,
+														responseType: "original"
+													}));
+												} finally {
+													httpLogger.verbose("uncorking socket reads");
+													socketController.uncorkReads();
+													/**
+													* @note Informational responses other than
+													* "101 Switching Protocols" are followed by a final
+													* response on the same connection. Keep gating that
+													* final response on the "response" event listeners.
+													*/
+													if (!responseParserDisposed && response.status < 200 && response.status !== 101) socketController.corkReads();
+												}
 											}
-										}
-									});
-									const onResponseData = (chunk) => {
-										responseParser.execute(chunk);
-										if (responseComplete) disposeResponseParser();
-									};
-									const onResponseClose = () => {
-										disposeResponseParser();
-										if (!hasFinalResponse) socketController.uncorkReads();
-									};
-									const disposeResponseParser = (error) => {
-										responseParserDisposed = true;
-										realSocket.removeListener("data", onResponseData);
-										realSocket.removeListener("close", onResponseClose);
-										responseParser.free(error);
-									};
-									realSocket.on("data", onResponseData).once("close", onResponseClose);
+										});
+										const onResponseData = (chunk) => {
+											responseParser.execute(chunk);
+											if (responseComplete) disposeResponseParser();
+										};
+										const onResponseEnd = () => {
+											disposeResponseParser();
+											if (!hasFinalResponse) socketController.uncorkReads();
+										};
+										const disposeResponseParser = (error) => {
+											responseParserDisposed = true;
+											realSocket.removeListener("data", onResponseData);
+											realSocket.removeListener("end", onResponseEnd);
+											realSocket.removeListener("close", onResponseEnd);
+											responseParser.free(error);
+										};
+										realSocket.on("data", onResponseData).once("end", onResponseEnd).once("close", onResponseEnd);
+									}
 								}
+							}, {
+								logger: requestLogger,
+								requestId
+							});
+							invariant(socketController["readyState"] === SocketController.PENDING, "CANNOT HANDLE ALREADY HANDLED REQUEST", request.method, request.url, socketController["readyState"]);
+							/**
+							* @note Create a request resolution context.
+							* This is so modifications to the "request" in upstream interceptors
+							* are correctly picked up by the underlying HTTP interceptor.
+							*/
+							const context = {
+								initiator,
+								requestId,
+								request,
+								controller: requestController,
+								emitter: this.emitter,
+								logger: requestLogger
+							};
+							/**
+							* @note The client destroying the socket while the request
+							* is still pending means the request was aborted (e.g. via
+							* `AbortController`). Abort the parsed request so its
+							* handling settles and late interactions with the request
+							* controller become controlled errors.
+							*/
+							abortPendingRequest = () => {
+								if (requestController.readyState === RequestController.PENDING) requestAbortController.abort();
+							};
+							pendingRequestController = requestController;
+							try {
+								await handleRequest(context);
+							} finally {
+								pendingRequestController = void 0;
+								abortPendingRequest = void 0;
 							}
-						}, {
-							logger: requestLogger,
-							requestId
-						});
-						invariant(socketController["readyState"] === SocketController.PENDING, "CANNOT HANDLE ALREADY HANDLED REQUEST", request.method, request.url, socketController["readyState"]);
-						/**
-						* @note Create a request resolution context.
-						* This is so modifications to the "request" in upstream interceptors
-						* are correctly picked up by the underlying HTTP interceptor.
-						*/
-						const context = {
-							initiator,
-							requestId,
-							request,
-							controller: requestController,
-							emitter: this.emitter,
-							logger: requestLogger
-						};
-						/**
-						* @note The client destroying the socket while the request
-						* is still pending means the request was aborted (e.g. via
-						* `AbortController`). Abort the parsed request so its
-						* handling settles and late interactions with the request
-						* controller become controlled errors.
-						*/
-						abortPendingRequest = () => {
-							if (requestController.readyState === RequestController.PENDING) requestAbortController.abort();
-						};
-						pendingRequestController = requestController;
-						try {
-							await handleRequest(context);
-						} finally {
-							pendingRequestController = void 0;
-							abortPendingRequest = void 0;
 						}
-					}
-				});
-				requestParser.execute(toBuffer(chunk));
-			});
+					});
+					executeRequestParser(requestParser, toBuffer(chunk));
+				};
+				socket.on("data", onRequestData);
+			};
+			addRequestDataListener();
 			socket.on("close", () => requestParser?.free());
 		}, { signal: controller.signal });
 	}
@@ -2076,4 +2133,4 @@ var NodeHttpRequestSource = class extends Interceptor {
 //#endregion
 export { requestContext as a, forwardHttpEvents as i, handleRequest as n, runInRequestContext as o, HttpResponseEvent as r, NodeHttpRequestSource as t };
 
-//# sourceMappingURL=source-BFZ6wg4P.js.map
+//# sourceMappingURL=source-DHVO1vzq.js.map