@zimic/interceptor 1.5.2-canary.1 → 1.5.2-canary.3

package/dist/server.js

@@ -1,29 +1,29 @@
 'use strict';
 
-var chunk6YD4TBYJ_js = require('./chunk-6YD4TBYJ.js');
+var chunk7DXCXCFO_js = require('./chunk-7DXCXCFO.js');
 require('./chunk-DGUM43GV.js');
 
 
 
 Object.defineProperty(exports, "DEFAULT_ACCESS_CONTROL_HEADERS", {
   enumerable: true,
-  get: function () { return chunk6YD4TBYJ_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
+  get: function () { return chunk7DXCXCFO_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
 });
 Object.defineProperty(exports, "DEFAULT_PREFLIGHT_STATUS_CODE", {
   enumerable: true,
-  get: function () { return chunk6YD4TBYJ_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
+  get: function () { return chunk7DXCXCFO_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
 });
 Object.defineProperty(exports, "NotRunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunk6YD4TBYJ_js.NotRunningInterceptorServerError_default; }
+  get: function () { return chunk7DXCXCFO_js.NotRunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "RunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunk6YD4TBYJ_js.RunningInterceptorServerError_default; }
+  get: function () { return chunk7DXCXCFO_js.RunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "createInterceptorServer", {
   enumerable: true,
-  get: function () { return chunk6YD4TBYJ_js.createInterceptorServer; }
+  get: function () { return chunk7DXCXCFO_js.createInterceptorServer; }
 });
 //# sourceMappingURL=server.js.map
 //# sourceMappingURL=server.js.map

package/dist/server.mjs

@@ -1,4 +1,4 @@
-export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-MCLPYYCY.mjs';
+export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-PHFZDUNS.mjs';
 import './chunk-BJTO5JO5.mjs';
 //# sourceMappingURL=server.mjs.map
 //# sourceMappingURL=server.mjs.map

package/package.json

@@ -14,7 +14,7 @@
     "api",
     "static"
   ],
-  "version": "1.5.2-canary.1",
+  "version": "1.5.2-canary.3",
   "homepage": "https://zimic.dev/docs/interceptor",
   "repository": {
     "type": "git",
@@ -80,6 +80,9 @@
     },
     "./package.json": "./package.json"
   },
+  "browser": {
+    "msw/node": "msw/browser"
+  },
   "scripts": {
     "setup": "concurrently --names playwright,msw 'playwright install chromium' 'msw init ./public --no-save'",
     "dev": "tsup --watch",
@@ -96,39 +99,43 @@
     "postinstall": "node --enable-source-maps -e \"try{require('./dist/scripts/postinstall')}catch(error){console.error(error)}\""
   },
   "dependencies": {
-    "@whatwg-node/server": "0.11.0",
+    "@whatwg-node/server": "0.13.0",
     "isomorphic-ws": "5.0.0",
     "msw": "2.15.0",
     "picocolors": "^1.1.1",
-    "ws": "8.21.3",
-    "yargs": "18.1.0",
-    "zod": "^4.5.1"
+    "ws": "8.22.0",
+    "yargs": "18.2.0",
+    "zod": "^4.6.5"
   },
   "devDependencies": {
-    "@types/node": "^26.4.0",
+    "@types/node": "^26.6.3",
     "@types/ws": "^8.18.1",
     "@types/yargs": "^17.0.35",
     "@typescript/native": "npm:typescript@^7.0.2",
-    "@vitest/browser": "^4.1.11",
-    "@vitest/browser-playwright": "^4.1.11",
-    "@vitest/coverage-istanbul": "^4.1.11",
+    "@vitest/browser": "^5.0.2",
+    "@vitest/browser-playwright": "^5.0.2",
+    "@vitest/coverage-istanbul": "^5.0.2",
     "@zimic/eslint-config-node": "workspace:*",
     "@zimic/lint-staged-config": "workspace:*",
     "@zimic/tsconfig": "workspace:*",
     "@zimic/utils": "workspace:*",
     "concurrently": "^10.0.5",
     "dotenv-cli": "^11.0.0",
-    "eslint": "^9.39.5",
-    "playwright": "^1.62.1",
+    "eslint": "^10.11.0",
+    "playwright": "^1.63.0",
     "tsup": "^8.5.1",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "vitest": "^4.1.11"
+    "vitest": "^5.0.2"
   },
   "peerDependencies": {
     "@zimic/http": "workspace:^1.2.0",
+    "@zimic/ws": "workspace:^0.2.0-canary.0",
     "typescript": "^5.0.0 || ^6.0.0 || ^7.0.0"
   },
   "peerDependenciesMeta": {
+    "@zimic/ws": {
+      "optional": true
+    },
     "typescript": {
       "optional": true
     }

package/src/server/utils/fetch.ts

@@ -16,7 +16,6 @@ export function getFetchAPI(): FetchAPI {
     TextEncoderStream,
     Blob,
     File,
-    crypto: globalThis.crypto,
     btoa,
     TextEncoder,
     TextDecoder,

package/src/utils/webSocket/WebSocketHandler.ts

@@ -64,7 +64,12 @@ abstract class WebSocketHandler<Schema extends WebSocketSchema> {
     };
     socket.addEventListener('message', handleSocketMessage);
 
-    await openPromise;
+    try {
+      await openPromise;
+    } catch (error) {
+      socket.removeEventListener('message', handleSocketMessage);
+      throw error;
+    }
 
     /* istanbul ignore next -- @preserve
      * It is difficult to reliably simulate socket errors in tests. */
@@ -87,6 +92,8 @@ abstract class WebSocketHandler<Schema extends WebSocketSchema> {
     socket.addEventListener('close', handleSocketClose);
 
     this.sockets.add(socket);
+
+    return handleSocketClose;
   }
 
   private handleSocketMessage = async (socket: ClientSocket, rawMessage: ClientSocket.MessageEvent) => {

package/src/utils/webSocket/WebSocketServer.ts

@@ -4,29 +4,41 @@ import ClientSocket from 'isomorphic-ws';
 
 import { closeServerSocket } from '@/utils/webSocket';
 
-import { WebSocketControlMessage } from './constants';
+import { WEB_SOCKET_CLOSE_CODES, WebSocketControlMessage } from './constants';
 import { WebSocketSchema } from './types';
 import WebSocketHandler from './WebSocketHandler';
 
 const { WebSocketServer: ServerSocket } = ClientSocket;
 
+function isSocketOpen(socket: ClientSocket) {
+  return socket.readyState === socket.OPEN;
+}
+
 export type WebSocketServerAuthenticate = (
   socket: ClientSocket,
   request: IncomingMessage,
 ) => PossiblePromise<{ isValid: true } | { isValid: false; message: string }>;
 
+export type WebSocketServerConnectionHandler = (
+  socket: ClientSocket,
+  request: IncomingMessage,
+) => PossiblePromise<{ handled: boolean }>;
+
 interface WebSocketServerOptions {
   httpServer: HttpServer;
   socketTimeout?: number;
   messageTimeout?: number;
   authenticate?: WebSocketServerAuthenticate;
+  handleConnection?: WebSocketServerConnectionHandler;
 }
 
 class WebSocketServer<Schema extends WebSocketSchema> extends WebSocketHandler<Schema> {
   private webSocketServer?: InstanceType<typeof ServerSocket>;
+  private isStopping = false;
 
   private httpServer: HttpServer;
   private authenticate?: WebSocketServerOptions['authenticate'];
+  private handleConnection?: WebSocketServerOptions['handleConnection'];
 
   constructor(options: WebSocketServerOptions) {
     super({
@@ -36,6 +48,7 @@ class WebSocketServer<Schema extends WebSocketSchema> extends WebSocketHandler<S
 
     this.httpServer = options.httpServer;
     this.authenticate = options.authenticate;
+    this.handleConnection = options.handleConnection;
   }
 
   get isRunning() {
@@ -54,19 +67,46 @@ class WebSocketServer<Schema extends WebSocketSchema> extends WebSocketHandler<S
     });
 
     webSocketServer.on('connection', async (socket, request) => {
-      if (this.authenticate) {
-        const result = await this.authenticate(socket, request);
+      socket.pause();
 
-        if (!result.isValid) {
-          socket.close(1008, result.message);
+      try {
+        if (this.authenticate) {
+          const result = await this.authenticate(socket, request);
+
+          if (!isSocketOpen(socket)) {
+            return;
+          }
+
+          if (!result.isValid) {
+            socket.resume();
+            socket.close(WEB_SOCKET_CLOSE_CODES.POLICY_VIOLATION, result.message);
+            return;
+          }
+        }
+
+        const connectionResult = await this.handleConnection?.(socket, request);
+
+        if (!isSocketOpen(socket)) {
           return;
         }
-      }
 
-      try {
-        await super.registerSocket(socket);
+        if (connectionResult?.handled) {
+          return;
+        }
+
+        const unregisterSocket = await super.registerSocket(socket);
+
+        if (this.isStopping || !isSocketOpen(socket)) {
+          unregisterSocket();
+          return;
+        }
+
+        socket.resume();
         socket.send('socket:auth:valid' satisfies WebSocketControlMessage);
       } catch (error) {
+        socket.resume();
+        socket.close(WEB_SOCKET_CLOSE_CODES.INTERNAL_ERROR);
+
         webSocketServer.emit('error', error);
       }
     });
@@ -79,12 +119,18 @@ class WebSocketServer<Schema extends WebSocketSchema> extends WebSocketHandler<S
       return;
     }
 
-    super.offAny();
-    await super.closeClientSockets();
+    this.isStopping = true;
 
-    await closeServerSocket(this.webSocketServer, { timeout: this.socketTimeout });
+    try {
+      super.offAny();
+      await super.closeClientSockets();
 
-    this.webSocketServer = undefined;
+      await closeServerSocket(this.webSocketServer, { timeout: this.socketTimeout });
+
+      this.webSocketServer = undefined;
+    } finally {
+      this.isStopping = false;
+    }
   }
 }
 

package/src/utils/webSocket/constants.ts

@@ -1,2 +1,9 @@
 export const WEB_SOCKET_CONTROL_MESSAGES = Object.freeze(['socket:auth:valid'] as const);
 export type WebSocketControlMessage = (typeof WEB_SOCKET_CONTROL_MESSAGES)[number];
+
+export const WEB_SOCKET_CLOSE_CODES = Object.freeze({
+  DEFAULT: 1000,
+  PROTOCOL_ERROR: 1002,
+  POLICY_VIOLATION: 1008,
+  INTERNAL_ERROR: 1011,
+} as const);

package/src/utils/webSocket/types.ts

@@ -1,5 +1,4 @@
-import { JSONValue } from '@zimic/http';
-import { PossiblePromise } from '@zimic/utils/types';
+import type { JSONValue, PossiblePromise } from '@zimic/utils/types';
 import type { WebSocket as ClientSocket } from 'isomorphic-ws';
 
 export interface WebSocketChannelFrame<Channel extends string> {

package/src/utils/webSocket.ts

@@ -1,6 +1,6 @@
 import ClientSocket, { type WebSocketServer as ServerSocket } from 'isomorphic-ws';
 
-import { WebSocketControlMessage } from '@/utils/webSocket/constants';
+import { WEB_SOCKET_CLOSE_CODES, WebSocketControlMessage } from '@/utils/webSocket/constants';
 import UnauthorizedWebSocketConnectionError from '@/utils/webSocket/errors/UnauthorizedWebSocketConnectionError';
 
 class WebSocketTimeoutError extends Error {}
@@ -65,7 +65,7 @@ export async function waitForOpenClientSocket(
     }
 
     function handleClose(event: ClientSocket.CloseEvent) {
-      const isUnauthorized = event.code === 1008;
+      const isUnauthorized = event.code === WEB_SOCKET_CLOSE_CODES.POLICY_VIOLATION;
 
       /* istanbul ignore else -- @preserve
        * An unauthorized close event is the only one we expect to happen here. */

package/src/ws/interceptorWorker/types/messages.ts

@@ -0,0 +1,11 @@
+export interface SerializedWebSocketBinaryMessageData {
+  type: 'binary';
+  data: string;
+}
+
+export interface SerializedWebSocketTextMessageData {
+  type: 'text';
+  data: string;
+}
+
+export type SerializedWebSocketMessageData = SerializedWebSocketBinaryMessageData | SerializedWebSocketTextMessageData;

package/src/ws/utils/messageData.ts

@@ -0,0 +1,122 @@
+import { assertTypeOf, ValidationError } from '@zimic/utils/validation';
+import { WebSocketMessageData, WebSocketSchema } from '@zimic/ws';
+
+import { convertArrayBufferToBase64, convertBase64ToArrayBuffer } from '@/utils/data';
+
+import {
+  SerializedWebSocketBinaryMessageData,
+  SerializedWebSocketMessageData,
+  SerializedWebSocketTextMessageData,
+} from '../interceptorWorker/types/messages';
+
+export function isWebSocketBinaryMessageData(data: unknown): data is Blob | BufferSource {
+  return data instanceof Blob || data instanceof ArrayBuffer || ArrayBuffer.isView(data);
+}
+
+export function normalizeBufferSource(bufferSource: BufferSource): ArrayBuffer {
+  if (bufferSource instanceof ArrayBuffer) {
+    return bufferSource;
+  }
+
+  const bytes = new Uint8Array(bufferSource.buffer, bufferSource.byteOffset, bufferSource.byteLength);
+  const normalizedBytes = new Uint8Array(bytes.byteLength);
+  normalizedBytes.set(bytes);
+
+  return normalizedBytes.buffer;
+}
+
+function tryParseJSONMessageData(data: string): unknown {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return data;
+  }
+}
+
+export function normalizeWebSocketBinaryMessageData(data: Blob | BufferSource): ArrayBuffer | Blob {
+  if (data instanceof Blob) {
+    return data;
+  }
+  return normalizeBufferSource(data);
+}
+
+export function normalizeWebSocketMessageData<Schema extends WebSocketSchema>(
+  data: Schema | WebSocketMessageData<Schema>,
+): Schema {
+  if (typeof data === 'string') {
+    const normalizedStringData = tryParseJSONMessageData(data);
+    return normalizedStringData as Schema;
+  }
+
+  return data as Schema;
+}
+
+export function serializeWebSocketMessageDataForSocket<Schema extends WebSocketSchema>(
+  data: Schema | WebSocketMessageData<Schema> | undefined,
+): WebSocketMessageData<Schema> {
+  if (isWebSocketBinaryMessageData(data) || typeof data === 'string') {
+    return data as WebSocketMessageData<Schema>;
+  }
+
+  const serializedData = JSON.stringify(data);
+  assertTypeOf('serialized WebSocket message data', serializedData, 'string');
+  return serializedData as unknown as WebSocketMessageData<Schema>;
+}
+
+export async function serializeWebSocketMessageDataForTransport(
+  data: WebSocketMessageData<WebSocketSchema> | undefined,
+): Promise<SerializedWebSocketMessageData> {
+  if (data === undefined) {
+    throw new ValidationError('WebSocket message data must not be undefined.');
+  }
+
+  if (isWebSocketBinaryMessageData(data)) {
+    const normalizedData = normalizeWebSocketBinaryMessageData(data);
+    const arrayBuffer = normalizedData instanceof Blob ? await normalizedData.arrayBuffer() : normalizedData;
+
+    return {
+      type: 'binary',
+      data: convertArrayBufferToBase64(arrayBuffer),
+    };
+  }
+
+  assertTypeOf('WebSocket message data', data, 'string');
+
+  return { type: 'text', data };
+}
+
+export function isSerializedWebSocketBinaryMessageData(data: unknown): data is SerializedWebSocketBinaryMessageData {
+  return (
+    typeof data === 'object' &&
+    data !== null &&
+    'type' in data &&
+    data.type === 'binary' &&
+    'data' in data &&
+    typeof data.data === 'string'
+  );
+}
+
+export function isSerializedWebSocketTextMessageData(data: unknown): data is SerializedWebSocketTextMessageData {
+  return (
+    typeof data === 'object' &&
+    data !== null &&
+    'type' in data &&
+    data.type === 'text' &&
+    'data' in data &&
+    typeof data.data === 'string'
+  );
+}
+
+export function isSerializedWebSocketMessageData(data: unknown): data is SerializedWebSocketMessageData {
+  return isSerializedWebSocketBinaryMessageData(data) || isSerializedWebSocketTextMessageData(data);
+}
+
+export function deserializeWebSocketMessageDataFromTransport(
+  data: SerializedWebSocketMessageData,
+): string | ArrayBuffer {
+  if (isSerializedWebSocketBinaryMessageData(data)) {
+    return normalizeBufferSource(convertBase64ToArrayBuffer(data.data));
+  }
+
+  return data.data;
+}