@zimic/interceptor 1.5.2-canary.0 → 1.5.2-canary.2

package/src/utils/logging.ts

@@ -1,4 +1,3 @@
-import { HttpFormData, HttpHeaders, HttpSearchParams } from '@zimic/http';
 import { createCachedDynamicImport } from '@zimic/utils/import';
 import { Logger } from '@zimic/utils/logging';
 import color from 'picocolors';
@@ -9,59 +8,6 @@ export const logger = new Logger({
   prefix: color.cyan('[@zimic/interceptor]'),
 });
 
-function stringifyJSONToLog(value: unknown): string {
-  return JSON.stringify(
-    value,
-    (_key, value) => {
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      return stringifyValueToLog(value, {
-        fallback: (value) => value as string,
-      });
-    },
-    2,
-  )
-    .replace(/\n\s*/g, ' ')
-    .replace(/"(File { name: '.*?', type: '.*?', size: \d*? })"/g, '$1')
-    .replace(/"(Blob { type: '.*?', size: \d*? })"/g, '$1');
-}
-
-export function stringifyValueToLog(
-  value: unknown,
-  options: {
-    fallback?: (value: unknown) => string;
-    includeClassName?: { searchParams?: boolean };
-  } = {},
-): string {
-  const { fallback = stringifyJSONToLog, includeClassName } = options;
-
-  if (value === null || value === undefined || typeof value !== 'object') {
-    return String(value);
-  }
-
-  if (value instanceof HttpHeaders) {
-    return stringifyValueToLog(value.toObject());
-  }
-
-  if (value instanceof HttpHeaders || value instanceof HttpSearchParams) {
-    const prefix = (includeClassName?.searchParams ?? false) ? 'URLSearchParams ' : '';
-    return `${prefix}${stringifyValueToLog(value.toObject())}`;
-  }
-
-  if (value instanceof HttpFormData) {
-    return `FormData ${stringifyValueToLog(value.toObject())}`;
-  }
-
-  if (value instanceof File) {
-    return `File { name: '${value.name}', type: '${value.type}', size: ${value.size} }`;
-  }
-
-  if (value instanceof Blob) {
-    return `Blob { type: '${value.type}', size: ${value.size} }`;
-  }
-
-  return fallback(value);
-}
-
 const importUtil = createCachedDynamicImport(() => import('util'));
 
 export async function formatValueToLog(value: unknown, options: { colors?: boolean } = {}) {

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) => {
@@ -123,7 +130,7 @@ abstract class WebSocketHandler<Schema extends WebSocketSchema> {
     let parsedMessage: unknown;
 
     try {
-      parsedMessage = JSON.parse(stringifiedMessage) as unknown;
+      parsedMessage = JSON.parse(stringifiedMessage);
     } catch {
       throw new InvalidWebSocketMessageError(stringifiedMessage);
     }

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. */