@mswjs/interceptors 0.42.5 → 0.42.6

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

@@ -2,7 +2,7 @@ import { n as createLogger, r as formatRequest, t as Interceptor } from "./inter
 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-Bh16MP4u.js";
+import { i as unwrapPendingData, n as SocketController, r as kRawSocket, t as SocketInterceptor } from "./net-B3HDxRlp.js";
 import { TypedEvent } from "rettime";
 import { invariant } from "outvariant";
 import { IncomingMessage, METHODS, STATUS_CODES, ServerResponse } from "node:http";
@@ -1656,11 +1656,16 @@ var NodeHttpRequestSource = class extends Interceptor {
 			let tunnelUrl;
 			let abortPendingRequest;
 			let pendingRequestController;
+			const passthroughNonHttp = () => {
+				setImmediate(() => {
+					if (socketController.readyState === SocketController.PENDING && !socket.destroyed) socketController.passthrough();
+				});
+			};
 			const stopParsingRequests = (error) => {
 				httpLogger.verbose("stopping HTTP request parsing: %o", error);
 				isHttpConnection = false;
 				if (pendingRequestController?.readyState === RequestController.PENDING) pendingRequestController.passthrough();
-				else socketController.decline();
+				else passthroughNonHttp();
 				requestParser?.free(error);
 			};
 			/**
@@ -1686,265 +1691,262 @@ var NodeHttpRequestSource = class extends Interceptor {
 				abortPendingRequest?.();
 				realSocketDestroy(error, callback);
 			};
-			const addRequestDataListener = () => {
-				const executeRequestParser = (parser, chunk) => {
-					if (parser.execute(chunk) !== null) {
-						socket.removeListener("data", onRequestData);
-						parser.free();
-						requestParser = void 0;
-					}
-				};
+			const executeRequestParser = (parser, chunk) => {
+				if (parser.execute(chunk) !== null) {
+					socket.removeListener("data", onRequestData);
+					parser.free();
+					requestParser = void 0;
+				}
+			};
+			/**
+			* @note Inspect the first sent packet to determine the protocol,
+			* including when entering a mocked "CONNECT" tunnel.
+			*/
+			const onRequestData = (chunk) => {
+				if (isHttpConnection === false) {
+					passthroughNonHttp();
+					return;
+				}
 				/**
-				* @note Inspect the first sent packet to determine the protocol,
-				* including when entering a mocked "CONNECT" tunnel.
+				* @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.
 				*/
-				const onRequestData = (chunk) => {
-					if (isHttpConnection === false) {
-						socketController.decline();
-						return;
-					}
+				if (tunnelUrl && !requestParser) {
+					isHttpConnection = 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 previous parser was freed at the upgrade
-					* boundary, so detect the tunneled protocol anew.
+					* @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 (tunnelUrl && !requestParser) {
-						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) {
-						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
+					socketController.reset({
+						host: tunnelUrl.hostname,
+						port: Number(tunnelUrl.port) || 80,
+						path: null
 					});
-					const requestContextValue = requestContext.getStore() ?? connectionRequestContext;
-					const initiator = requestContextValue?.initiator || socket;
-					requestParser = new HttpRequestParser({
-						onError: stopParsingRequests,
-						connectionOptions: {
-							method: httpMethod,
-							url: baseUrl
-						},
+				}
+				if (requestParser) {
+					executeRequestParser(requestParser, toBuffer(chunk));
+					return;
+				}
+				const httpMessage = chunk.toString();
+				const httpMethod = httpMessage.split(" ")[0] || "";
+				if (!METHODS.includes(httpMethod.toUpperCase())) {
+					isHttpConnection = false;
+					passthroughNonHttp();
+					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 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 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.
 						*/
-						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
-									});
-									/**
-									* @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 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,
+						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
+								});
+								/**
+								* @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 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}`);
+									socket.on("data", onRequestData);
+								}
+								const respond = () => {
+									return this.respondWith({
+										socket: socketController[kRawSocket],
 										request: context.request,
-										response: responseClone,
-										responseType: "mock"
-									}));
-									if (socket.connecting) socket.once("connect", respond);
-									else
+										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.
+								* @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.
 									*/
-									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.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();
-											},
-											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();
-												}
+												return;
 											}
-										});
-										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);
-									}
+											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 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;
 						}
-					});
-					executeRequestParser(requestParser, toBuffer(chunk));
-				};
-				socket.on("data", onRequestData);
+					}
+				});
+				executeRequestParser(requestParser, toBuffer(chunk));
 			};
-			addRequestDataListener();
+			socket.on("data", onRequestData);
 			socket.on("close", () => requestParser?.free());
 		}, { signal: controller.signal });
 	}
@@ -2133,4 +2135,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-DHVO1vzq.js.map
+//# sourceMappingURL=source-C_hSJzNQ.js.map