@mswjs/interceptors - npm Package Compare versions

Comparing version 0.34.0 to 0.34.1

lib/browser/interceptors/WebSocket/index.js

@@ -238,3 +238,3 @@ "use strict";Object.defineProperty(exports, "__esModule", {value: true});
   }
-  [(kPassthroughPromise, kOnSend, kClose)](code = 1e3, reason) {
+  [(kPassthroughPromise, kOnSend, kClose)](code = 1e3, reason, wasClean = true) {
     if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
@@ -252,3 +252,3 @@ return;
             reason,
-            wasClean: code === 1e3
+            wasClean
           })
@@ -574,25 +574,35 @@ )
         queueMicrotask(() => {
-          const server = new WebSocketServerConnection(
-            socket,
-            transport,
-            createConnection
-          );
-          const hasConnectionListeners = this.emitter.emit("connection", {
-            client: new WebSocketClientConnection(socket, transport),
-            server,
-            info: {
-              protocols
+          try {
+            const server = new WebSocketServerConnection(
+              socket,
+              transport,
+              createConnection
+            );
+            const hasConnectionListeners = this.emitter.emit("connection", {
+              client: new WebSocketClientConnection(socket, transport),
+              server,
+              info: {
+                protocols
+              }
+            });
+            if (hasConnectionListeners) {
+              socket[kPassthroughPromise].resolve(false);
+            } else {
+              socket[kPassthroughPromise].resolve(true);
+              server.connect();
+              server.addEventListener("open", () => {
+                socket.dispatchEvent(bindEvent(socket, new Event("open")));
+                if (server["realWebSocket"]) {
+                  socket.protocol = server["realWebSocket"].protocol;
+                }
+              });
             }
-          });
-          if (hasConnectionListeners) {
-            socket[kPassthroughPromise].resolve(false);
-          } else {
-            socket[kPassthroughPromise].resolve(true);
-            server.connect();
-            server.addEventListener("open", () => {
-              socket.dispatchEvent(bindEvent(socket, new Event("open")));
-              if (server["realWebSocket"]) {
-                socket.protocol = server["realWebSocket"].protocol;
+          } catch (error) {
+            if (error instanceof Error) {
+              socket.dispatchEvent(new Event("error"));
+              if (socket.readyState !== WebSocket.CLOSING && socket.readyState !== WebSocket.CLOSED) {
+                socket[kClose](1011, error.message, false);
               }
-            });
+              console.error(error);
+            }
           }
@@ -599,0 +609,0 @@ });

package.json

 {
   "name": "@mswjs/interceptors",
   "description": "Low-level HTTP/HTTPS/XHR/fetch request interception library.",
-  "version": "0.34.0",
+  "version": "0.34.1",
   "main": "./lib/node/index.js",
@@ -6,0 +6,0 @@ "module": "./lib/node/index.mjs",

src/interceptors/WebSocket/index.ts

@@ -8,3 +8,7 @@ import { Interceptor } from '../../Interceptor'
 import { WebSocketClassTransport } from './WebSocketClassTransport'
-import { kPassthroughPromise, WebSocketOverride } from './WebSocketOverride'
+import {
+  kClose,
+  kPassthroughPromise,
+  WebSocketOverride,
+} from './WebSocketOverride'
 import { bindEvent } from './utils/bindEvent'
@@ -87,37 +91,60 @@
         queueMicrotask(() => {
-          const server = new WebSocketServerConnection(
-            socket,
-            transport,
-            createConnection
-          )
+          try {
+            const server = new WebSocketServerConnection(
+              socket,
+              transport,
+              createConnection
+            )
 
-          // The "globalThis.WebSocket" class stands for
-          // the client-side connection. Assume it's established
-          // as soon as the WebSocket instance is constructed.
-          const hasConnectionListeners = this.emitter.emit('connection', {
-            client: new WebSocketClientConnection(socket, transport),
-            server,
-            info: {
-              protocols,
-            },
-          })
+            // The "globalThis.WebSocket" class stands for
+            // the client-side connection. Assume it's established
+            // as soon as the WebSocket instance is constructed.
+            const hasConnectionListeners = this.emitter.emit('connection', {
+              client: new WebSocketClientConnection(socket, transport),
+              server,
+              info: {
+                protocols,
+              },
+            })
 
-          if (hasConnectionListeners) {
-            socket[kPassthroughPromise].resolve(false)
-          } else {
-            socket[kPassthroughPromise].resolve(true)
+            if (hasConnectionListeners) {
+              socket[kPassthroughPromise].resolve(false)
+            } else {
+              socket[kPassthroughPromise].resolve(true)
 
-            server.connect()
+              server.connect()
 
-            // Forward the "open" event from the original server
-            // to the mock WebSocket client in the case of a passthrough connection.
-            server.addEventListener('open', () => {
-              socket.dispatchEvent(bindEvent(socket, new Event('open')))
+              // Forward the "open" event from the original server
+              // to the mock WebSocket client in the case of a passthrough connection.
+              server.addEventListener('open', () => {
+                socket.dispatchEvent(bindEvent(socket, new Event('open')))
 
-              // Forward the original connection protocol to the
-              // mock WebSocket client.
-              if (server['realWebSocket']) {
-                socket.protocol = server['realWebSocket'].protocol
+                // Forward the original connection protocol to the
+                // mock WebSocket client.
+                if (server['realWebSocket']) {
+                  socket.protocol = server['realWebSocket'].protocol
+                }
+              })
+            }
+          } catch (error) {
+            /**
+             * @note Translate unhandled exceptions during the connection
+             * handling (i.e. interceptor exceptions) as WebSocket connection
+             * closures with error. This prevents from the exceptions occurring
+             * in `queueMicrotask` from being process-wide and uncatchable.
+             */
+            if (error instanceof Error) {
+              socket.dispatchEvent(new Event('error'))
+
+              // No need to close the connection if it's already being closed.
+              // E.g. the interceptor called `client.close()` and then threw an error.
+              if (
+                socket.readyState !== WebSocket.CLOSING &&
+                socket.readyState !== WebSocket.CLOSED
+              ) {
+                socket[kClose](1011, error.message, false)
               }
-            })
+
+              console.error(error)
+            }
           }
@@ -124,0 +151,0 @@ })

src/interceptors/WebSocket/WebSocketOverride.ts

@@ -166,3 +166,7 @@ import { invariant } from 'outvariant'
 
-  private [kClose](code: number = 1000, reason?: string): void {
+  private [kClose](
+    code: number = 1000,
+    reason?: string,
+    wasClean = true
+  ): void {
     /**
@@ -188,3 +192,3 @@ * @note Move this check here so that even internall closures,
             reason,
-            wasClean: code === 1000,
+            wasClean,
           })
@@ -191,0 +195,0 @@ )

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

1221900

increased by0.37%

Lines of code

16308

increased by0.3%

No dependency changes