@mswjs/interceptors 0.42.2 → 0.42.4

package/lib/node/websocket-CC0nB0md.d.ts

@@ -0,0 +1,285 @@
+import { t as Interceptor } from "./interceptor-dtJZ_9QT.js";
+import { TypedEvent } from "rettime";
+//#region src/interceptors/WebSocket/utils/events.d.ts
+declare const kCancelable: unique symbol;
+declare const kDefaultPrevented: unique symbol;
+/**
+ * A `MessageEvent` superset that supports event cancellation
+ * in Node.js. It's rather non-intrusive so it can be safely
+ * used in the browser as well.
+ *
+ * @see https://github.com/nodejs/node/issues/51767
+ */
+declare class CancelableMessageEvent<T = any> extends MessageEvent<T> {
+  [kCancelable]: boolean;
+  [kDefaultPrevented]: boolean;
+  constructor(type: string, init: MessageEventInit<T>);
+  get cancelable(): boolean;
+  set cancelable(nextCancelable: boolean);
+  get defaultPrevented(): boolean;
+  set defaultPrevented(nextDefaultPrevented: boolean);
+  preventDefault(): void;
+}
+interface CloseEventInit extends EventInit {
+  code?: number;
+  reason?: string;
+  wasClean?: boolean;
+}
+declare class CloseEvent extends Event {
+  code: number;
+  reason: string;
+  wasClean: boolean;
+  constructor(type: string, init?: CloseEventInit);
+}
+declare class CancelableCloseEvent extends CloseEvent {
+  [kCancelable]: boolean;
+  [kDefaultPrevented]: boolean;
+  constructor(type: string, init?: CloseEventInit);
+  get cancelable(): boolean;
+  set cancelable(nextCancelable: boolean);
+  get defaultPrevented(): boolean;
+  set defaultPrevented(nextDefaultPrevented: boolean);
+  preventDefault(): void;
+}
+//#endregion
+//#region src/interceptors/WebSocket/web-socket-transport.d.ts
+type WebSocketData = string | ArrayBuffer | Blob | ArrayBufferView<ArrayBuffer>;
+type WebSocketTransportEventMap = {
+  incoming: MessageEvent<WebSocketData>;
+  outgoing: MessageEvent<WebSocketData>;
+  close: CloseEvent;
+};
+type StrictEventListenerOrEventListenerObject<EventType extends Event> = ((this: WebSocket, event: EventType) => void) | {
+  handleEvent(this: WebSocket, event: EventType): void;
+};
+interface WebSocketTransport {
+  addEventListener<EventType extends keyof WebSocketTransportEventMap>(event: EventType, listener: StrictEventListenerOrEventListenerObject<WebSocketTransportEventMap[EventType]> | null, options?: boolean | AddEventListenerOptions): void;
+  dispatchEvent<EventType extends keyof WebSocketTransportEventMap>(event: WebSocketTransportEventMap[EventType]): boolean;
+  /**
+   * Send the data from the server to this client.
+   */
+  send(data: WebSocketData): void;
+  /**
+   * Close the client connection.
+   */
+  close(code?: number, reason?: string): void;
+}
+//#endregion
+//#region src/interceptors/WebSocket/web-socket-override.d.ts
+type WebSocketEventListener<EventType extends WebSocketEventMap[keyof WebSocketEventMap] = Event> = (this: WebSocket, event: EventType) => void;
+declare const kPassthroughPromise: unique symbol;
+declare const kOnSend: unique symbol;
+declare const kClose: unique symbol;
+declare class WebSocketOverride extends EventTarget implements WebSocket {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSING = 2;
+  static readonly CLOSED = 3;
+  readonly CONNECTING = 0;
+  readonly OPEN = 1;
+  readonly CLOSING = 2;
+  readonly CLOSED = 3;
+  url: string;
+  protocol: string;
+  extensions: string;
+  binaryType: BinaryType;
+  readyState: WebSocket['readyState'];
+  bufferedAmount: number;
+  private _onopen;
+  private _onmessage;
+  private _onerror;
+  private _onclose;
+  private [kPassthroughPromise];
+  private [kOnSend]?;
+  constructor(url: string | URL, protocols?: string | Array<string>);
+  set onopen(listener: WebSocketEventListener | null);
+  get onopen(): WebSocketEventListener | null;
+  set onmessage(listener: WebSocketEventListener<MessageEvent<WebSocketData>> | null);
+  get onmessage(): WebSocketEventListener<MessageEvent<WebSocketData>> | null;
+  set onerror(listener: WebSocketEventListener | null);
+  get onerror(): WebSocketEventListener | null;
+  set onclose(listener: WebSocketEventListener<CloseEvent> | null);
+  get onclose(): WebSocketEventListener<CloseEvent> | null;
+  /**
+   * @see https://websockets.spec.whatwg.org/#ref-for-dom-websocket-send%E2%91%A0
+   */
+  send(data: WebSocketData): void;
+  close(code?: number, reason?: string): void;
+  private [kClose];
+  addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, event: WebSocketEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+  addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+  removeEventListener<K extends keyof WebSocketEventMap>(type: K, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+}
+//#endregion
+//#region src/interceptors/WebSocket/web-socket-client-connection.d.ts
+declare const kEmitter$1: unique symbol;
+interface WebSocketClientEventMap {
+  message: MessageEvent<WebSocketData>;
+  close: CloseEvent;
+}
+declare abstract class WebSocketClientConnectionProtocol {
+  abstract id: string;
+  abstract url: URL;
+  abstract send(data: WebSocketData): void;
+  abstract close(code?: number, reason?: string): void;
+  abstract addEventListener<EventType extends keyof WebSocketClientEventMap>(type: EventType, listener: WebSocketEventListener<WebSocketClientEventMap[EventType]>, options?: AddEventListenerOptions | boolean): void;
+  abstract removeEventListener<EventType extends keyof WebSocketClientEventMap>(event: EventType, listener: WebSocketEventListener<WebSocketClientEventMap[EventType]>, options?: EventListenerOptions | boolean): void;
+}
+/**
+ * The WebSocket client instance represents an incoming
+ * client connection. The user can control the connection,
+ * send and receive events.
+ */
+declare class WebSocketClientConnection implements WebSocketClientConnectionProtocol {
+  readonly socket: WebSocket;
+  private readonly transport;
+  readonly id: string;
+  readonly url: URL;
+  private [kEmitter$1];
+  constructor(socket: WebSocket, transport: WebSocketTransport);
+  /**
+   * Listen for the outgoing events from the connected WebSocket client.
+   */
+  addEventListener<EventType extends keyof WebSocketClientEventMap>(type: EventType, listener: WebSocketEventListener<WebSocketClientEventMap[EventType]>, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * Removes the listener for the given event.
+   */
+  removeEventListener<EventType extends keyof WebSocketClientEventMap>(event: EventType, listener: WebSocketEventListener<WebSocketClientEventMap[EventType]>, options?: EventListenerOptions | boolean): void;
+  /**
+   * Send data to the connected client.
+   */
+  send(data: WebSocketData): void;
+  /**
+   * Close the WebSocket connection.
+   * @param {number} code A status code (see https://www.rfc-editor.org/rfc/rfc6455#section-7.4.1).
+   * @param {string} reason A custom connection close reason.
+   */
+  close(code?: number, reason?: string): void;
+}
+//#endregion
+//#region src/interceptors/WebSocket/web-socket-class-transport.d.ts
+/**
+ * Abstraction over the given mock `WebSocket` instance that allows
+ * for controlling that instance (e.g. sending and receiving messages).
+ */
+declare class WebSocketClassTransport extends EventTarget implements WebSocketTransport {
+  protected readonly socket: WebSocketOverride;
+  constructor(socket: WebSocketOverride);
+  addEventListener<EventType extends keyof WebSocketTransportEventMap>(type: EventType, callback: StrictEventListenerOrEventListenerObject<WebSocketTransportEventMap[EventType]> | null, options?: boolean | AddEventListenerOptions): void;
+  dispatchEvent<EventType extends keyof WebSocketTransportEventMap>(event: WebSocketTransportEventMap[EventType]): boolean;
+  send(data: WebSocketData): void;
+  close(code: number, reason?: string): void;
+}
+//#endregion
+//#region src/interceptors/WebSocket/web-socket-server-connection.d.ts
+declare const kEmitter: unique symbol;
+declare const kSend: unique symbol;
+interface WebSocketServerEventMap {
+  open: Event;
+  message: MessageEvent<WebSocketData>;
+  error: Event;
+  close: CloseEvent;
+}
+declare abstract class WebSocketServerConnectionProtocol {
+  abstract connect(): void;
+  abstract send(data: WebSocketData): void;
+  abstract close(): void;
+  abstract addEventListener<EventType extends keyof WebSocketServerEventMap>(event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap[EventType]>, options?: AddEventListenerOptions | boolean): void;
+  abstract removeEventListener<EventType extends keyof WebSocketServerEventMap>(event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap[EventType]>, options?: EventListenerOptions | boolean): void;
+}
+/**
+ * The WebSocket server instance represents the actual production
+ * WebSocket server connection. It's idle by default but you can
+ * establish it by calling `server.connect()`.
+ */
+declare class WebSocketServerConnection implements WebSocketServerConnectionProtocol {
+  private readonly client;
+  private readonly transport;
+  private readonly createConnection;
+  /**
+   * A WebSocket instance connected to the original server.
+   */
+  private realWebSocket?;
+  private mockCloseController;
+  private realCloseController;
+  private [kEmitter];
+  constructor(client: WebSocketOverride, transport: WebSocketClassTransport, createConnection: () => WebSocket);
+  /**
+   * The `WebSocket` instance connected to the original server.
+   * Accessing this before calling `server.connect()` will throw.
+   */
+  get socket(): WebSocket;
+  /**
+   * Open connection to the original WebSocket server.
+   */
+  connect(): void;
+  /**
+   * Listen for the incoming events from the original WebSocket server.
+   */
+  addEventListener<EventType extends keyof WebSocketServerEventMap>(event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap[EventType]>, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * Remove the listener for the given event.
+   */
+  removeEventListener<EventType extends keyof WebSocketServerEventMap>(event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap[EventType]>, options?: EventListenerOptions | boolean): void;
+  /**
+   * Send data to the original WebSocket server.
+   * @example
+   * server.send('hello')
+   * server.send(new Blob(['hello']))
+   * server.send(new TextEncoder().encode('hello'))
+   */
+  send(data: WebSocketData): void;
+  private [kSend];
+  /**
+   * Close the actual server connection.
+   */
+  close(): void;
+  private handleIncomingMessage;
+  private handleMockClose;
+  private handleRealClose;
+}
+//#endregion
+//#region src/interceptors/WebSocket/index.d.ts
+/**
+ * Intercept the outgoing WebSocket connections created using
+ * the global `WebSocket` class.
+ */
+declare class WebSocketInterceptor extends Interceptor<WebSocketEventMap$1> {
+  static symbol: symbol;
+  protected predicate(): boolean;
+  protected setup(): void;
+}
+//#endregion
+//#region src/events/websocket.d.ts
+/**
+ * The connection information.
+ */
+interface WebSocketConnectionInfo {
+  /**
+   * The protocols supported by the WebSocket client.
+   */
+  protocols: string | Array<string> | undefined;
+}
+interface WebSocketConnectionEventData {
+  /**
+   * The incoming WebSocket client connection.
+   */
+  client: WebSocketClientConnection;
+  /**
+   * The original WebSocket server connection.
+   */
+  server: WebSocketServerConnection;
+  info: WebSocketConnectionInfo;
+}
+declare class WebSocketConnectionEvent<DataType extends WebSocketConnectionEventData = WebSocketConnectionEventData> extends TypedEvent<DataType, void, 'connection'> {
+  client: WebSocketClientConnection;
+  server: WebSocketServerConnection;
+  info: WebSocketConnectionInfo;
+  constructor(data: DataType);
+}
+type WebSocketEventMap$1 = {
+  connection: WebSocketConnectionEvent;
+};
+//#endregion
+export { WebSocketServerConnectionProtocol as a, WebSocketClientConnectionProtocol as c, WebSocketTransport as d, CancelableCloseEvent as f, WebSocketServerConnection as i, WebSocketClientEventMap as l, CloseEvent as m, WebSocketEventMap$1 as n, WebSocketServerEventMap as o, CancelableMessageEvent as p, WebSocketInterceptor as r, WebSocketClientConnection as s, WebSocketConnectionEvent as t, WebSocketData as u };
+//# sourceMappingURL=websocket-CC0nB0md.d.ts.map

package/package.json

@@ -2,7 +2,7 @@
   "type": "module",
   "name": "@mswjs/interceptors",
   "description": "Low-level network interception library for Node.js.",
-  "version": "0.42.2",
+  "version": "0.42.4",
   "main": "./lib/node/index.js",
   "types": "./lib/node/index.d.ts",
   "exports": {
@@ -34,7 +34,10 @@
     },
     "./fetch/node": "./lib/node/interceptors/fetch/node.js",
     "./fetch/web": "./lib/browser/interceptors/fetch/web.js",
-    "./WebSocket": "./lib/browser/interceptors/WebSocket/index.js",
+    "./WebSocket": {
+      "browser": "./lib/browser/interceptors/WebSocket/index.js",
+      "default": "./lib/node/interceptors/WebSocket/index.js"
+    },
     "./RemoteHttpInterceptor": {
       "browser": null,
       "default": "./lib/node/remote-http-interceptor.js"

package/src/interceptors/WebSocket/index.ts

@@ -23,6 +23,7 @@ import { bindEvent } from './utils/bind-event'
 import { hasConfigurableGlobal } from '../../utils/has-configurable-global'
 import { patchesRegistry } from '../../utils/patches-registry'
 import { createLogger } from '../../utils/logger'
+import { runAsInternalConnection } from '../../utils/internal-connection'
 
 export {
   type WebSocketData,
@@ -73,7 +74,9 @@ export class WebSocketInterceptor extends Interceptor<WebSocketEventMap> {
         })
 
         const createConnection = (): WebSocket => {
-          return Reflect.construct(target, args, newTarget)
+          return runAsInternalConnection(() => {
+            return Reflect.construct(target, args, newTarget)
+          })
         }
 
         // All WebSocket instances are mocked and don't forward

package/src/interceptors/http/http-parser/index.ts

@@ -29,6 +29,7 @@ const KIND_RESPONSE = constants.TYPE.RESPONSE
 type ParserKind = typeof KIND_REQUEST | typeof KIND_RESPONSE
 
 export interface ParserCallbacks<K extends ParserKind> {
+  onError?: (error: Error) => void
   onMessageBegin?: () => number | void
   onHeadersComplete?: (
     info: K extends typeof KIND_REQUEST
@@ -305,6 +306,13 @@ export class HttpParser<K extends ParserKind> {
     const buffer = new Uint8Array(llhttp_memory.buffer)
     const length = buffer.indexOf(0, errorPointer) - errorPointer
 
-    throw new Error(readStringFrom(errorPointer, length))
+    const error = new Error(readStringFrom(errorPointer, length))
+
+    if (this[kCallbacks].onError) {
+      this[kCallbacks].onError(error)
+      return
+    }
+
+    throw error
   }
 }

package/src/interceptors/http/http-parser.ts

@@ -4,19 +4,24 @@ import { FetchRequest, FetchResponse } from '../../utils/fetch-utils'
 import { HttpParser } from './http-parser/index'
 
 interface HttpRequestParserOptions {
+  onError: (error: Error) => void
   connectionOptions: {
     method?: string
     url: URL
   }
   onRequest: (request: Request, abortController: AbortController) => void
+  onMessageComplete?: () => void
 }
 
 export class HttpRequestParser extends HttpParser<1> {
   #requestBodyStream?: Readable
+  #upgrade = false
 
   constructor(options: HttpRequestParserOptions) {
     super(1, {
-      onHeadersComplete: ({ rawHeaders, method, url: path }) => {
+      onError: options.onError,
+      onHeadersComplete: ({ rawHeaders, method, url: path, upgrade }) => {
+        this.#upgrade = upgrade
         /**
          * @note When the socket is reused, "connectionOptions" will point
          * to the "net.connect()" call options that established the connection,
@@ -79,27 +84,44 @@ export class HttpRequestParser extends HttpParser<1> {
       },
       onMessageComplete: () => {
         this.#requestBodyStream?.push(null)
+        this.#requestBodyStream = undefined
+
+        /**
+         * @note An upgraded exchange (e.g. "CONNECT", WebSocket) has
+         * no message boundary: it takes the connection over, and the
+         * bytes that follow belong to it, not to a next exchange.
+         */
+        if (!this.#upgrade) {
+          options.onMessageComplete?.()
+        }
       },
     })
   }
 
-  public free(): void {
+  public free(error?: Error): void {
     this.destroy()
-    this.#requestBodyStream?.destroy()
+    this.#requestBodyStream?.destroy(error)
     this.#requestBodyStream = undefined
   }
 }
 
 export class HttpResponseParser extends HttpParser<2> {
   #responseBodyStream?: Readable | null
+  #status = 0
 
-  constructor(options: { onResponse: (response: Response) => void }) {
+  constructor(options: {
+    onResponse: (response: Response) => void
+    onError: (error: Error) => void
+    onMessageComplete?: (status: number) => void
+  }) {
     super(2, {
+      onError: options.onError,
       onHeadersComplete: ({
         rawHeaders,
         statusCode: status,
         statusMessage: statusText,
       }) => {
+        this.#status = status
         const headers = FetchResponse.parseRawHeaders([...rawHeaders])
 
         const response = new FetchResponse(
@@ -127,12 +149,19 @@ export class HttpResponseParser extends HttpParser<2> {
       },
       onMessageComplete: () => {
         this.#responseBodyStream?.push(null)
+        this.#responseBodyStream = null
+        options.onMessageComplete?.(this.#status)
       },
     })
   }
 
-  public free(): void {
+  public free(error?: Error): void {
     this.destroy()
+
+    if (error) {
+      this.#responseBodyStream?.destroy(error)
+    }
+
     this.#responseBodyStream = null
   }
 }

package/src/interceptors/http/source.ts

@@ -67,6 +67,24 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
         let requestParser: HttpRequestParser | undefined
         let tunnelUrl: URL | undefined
         let abortPendingRequest: (() => void) | undefined
+        let pendingRequestController: RequestController | undefined
+
+        // A malformed request loses the boundary for subsequent requests.
+        // Preserve the original bytes for the client and server to handle.
+        const stopParsingRequests = (error: Error) => {
+          httpLogger.verbose('stopping HTTP request parsing: %o', error)
+          isHttpConnection = false
+
+          if (
+            pendingRequestController?.readyState === RequestController.PENDING
+          ) {
+            void pendingRequestController.passthrough()
+          } else {
+            socketController.decline()
+          }
+
+          requestParser?.free(error)
+        }
 
         /**
          * @note Capture the request context of the connection itself.
@@ -99,6 +117,7 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
          */
         socket.on('data', (chunk) => {
           if (isHttpConnection === false) {
+            socketController.decline()
             return
           }
 
@@ -164,10 +183,22 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
           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) ??
@@ -276,9 +307,15 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
                   },
                   passthrough: () => {
                     const realSocket = socketController.passthrough(
-                      this.#modifyHttpHeaders(context.request)
+                      isHttpConnection === false
+                        ? undefined
+                        : this.#modifyHttpHeaders(context.request)
                     )
 
+                    if (isHttpConnection === false) {
+                      return
+                    }
+
                     if (this.emitter.listenerCount('response') > 0) {
                       httpLogger.verbose(
                         'found "response" listener, corking socket reads'
@@ -293,8 +330,20 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
                        */
                       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,
@@ -334,6 +383,7 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
                              * final response on the "response" event listeners.
                              */
                             if (
+                              !responseParserDisposed &&
                               response.status < 200 &&
                               response.status !== 101
                             ) {
@@ -343,9 +393,35 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
                         },
                       })
 
+                      const onResponseData = (chunk: Buffer) => {
+                        responseParser.execute(chunk)
+
+                        // Free only after llhttp returns from its callbacks.
+                        if (responseComplete) {
+                          disposeResponseParser()
+                        }
+                      }
+
+                      const onResponseClose = () => {
+                        disposeResponseParser()
+
+                        // Without a response, no response listener will release
+                        // the buffered EOF/close that rejects the client request.
+                        if (!hasFinalResponse) {
+                          socketController.uncorkReads()
+                        }
+                      }
+
+                      const disposeResponseParser = (error?: Error) => {
+                        responseParserDisposed = true
+                        realSocket.removeListener('data', onResponseData)
+                        realSocket.removeListener('close', onResponseClose)
+                        responseParser.free(error)
+                      }
+
                       realSocket
-                        .on('data', (chunk) => responseParser.execute(chunk))
-                        .on('close', () => responseParser.free())
+                        .on('data', onResponseData)
+                        .once('close', onResponseClose)
                     }
                   },
                 },
@@ -392,9 +468,12 @@ export class NodeHttpRequestSource extends Interceptor<HttpRequestEventMap> {
                 }
               }
 
+              pendingRequestController = requestController
+
               try {
                 await handleRequest(context)
               } finally {
+                pendingRequestController = undefined
                 abortPendingRequest = undefined
               }
             },