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

package/dist/server.js

@@ -1,29 +1,29 @@
 'use strict';
 
-var chunk6YD4TBYJ_js = require('./chunk-6YD4TBYJ.js');
+var chunkUJTX22M5_js = require('./chunk-UJTX22M5.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 chunkUJTX22M5_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 chunkUJTX22M5_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
 });
 Object.defineProperty(exports, "NotRunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunk6YD4TBYJ_js.NotRunningInterceptorServerError_default; }
+  get: function () { return chunkUJTX22M5_js.NotRunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "RunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunk6YD4TBYJ_js.RunningInterceptorServerError_default; }
+  get: function () { return chunkUJTX22M5_js.RunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "createInterceptorServer", {
   enumerable: true,
-  get: function () { return chunk6YD4TBYJ_js.createInterceptorServer; }
+  get: function () { return chunkUJTX22M5_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-V5VFQ6WK.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.2",
   "homepage": "https://zimic.dev/docs/interceptor",
   "repository": {
     "type": "git",

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