@zimic/interceptor 1.2.3-canary.7 → 1.2.4-canary.0

package/dist/{chunk-ZU6IGW27.js → chunk-IPL73BDI.js}

@@ -897,7 +897,7 @@ var WebSocketHandler = class {
   messageTimeout;
   channelListeners = {};
   socketListeners = {
-    messageAbort: /* @__PURE__ */ new Map()
+    abortRequests: /* @__PURE__ */ new Map()
   };
   constructor(options) {
     this.socketTimeout = options.socketTimeout ?? DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT;
@@ -918,10 +918,12 @@ var WebSocketHandler = class {
     }
     socket.addEventListener("error", handleSocketError);
     const handleSocketClose = () => {
+      this.sockets.delete(socket);
+      this.emitSocket("abortRequests", socket);
+      this.socketListeners.abortRequests.delete(socket);
       socket.removeEventListener("message", handleSocketMessage);
       socket.removeEventListener("close", handleSocketClose);
       socket.removeEventListener("error", handleSocketError);
-      this.removeSocket(socket);
     };
     socket.addEventListener("close", handleSocketClose);
     this.sockets.add(socket);
@@ -975,6 +977,9 @@ var WebSocketHandler = class {
   isMessage(message) {
     return typeof message === "object" && message !== null && "id" in message && typeof message.id === "string" && "channel" in message && typeof message.channel === "string" && (!("requestId" in message) || typeof message.requestId === "string");
   }
+  isChannelEvent(event, channel) {
+    return event.channel === channel;
+  }
   async notifyListeners(message, socket) {
     if (this.isReplyMessage(message)) {
       await this.notifyReplyListeners(message, socket);
@@ -1003,10 +1008,6 @@ var WebSocketHandler = class {
     });
     await Promise.all(closingPromises);
   }
-  removeSocket(socket) {
-    this.abortSocketMessages([socket]);
-    this.sockets.delete(socket);
-  }
   async createEventMessage(channel, eventData) {
     const crypto2 = await importCrypto();
     const eventMessage = {
@@ -1023,31 +1024,46 @@ var WebSocketHandler = class {
   async request(channel, requestData, options = {}) {
     const request = await this.createEventMessage(channel, requestData);
     this.sendMessage(request, options.sockets);
-    const response = await this.waitForReply(channel, request.id, options.sockets);
+    const response = await this.waitForReply(channel, request, options.sockets);
     return response.data;
   }
-  async waitForReply(channel, requestId, sockets = this.sockets) {
+  async waitForReply(channel, request, sockets = this.sockets) {
     return new Promise((resolve, reject) => {
       const replyTimeout = setTimeout(() => {
-        this.offReply(channel, replyListener);
-        this.offAbortSocketMessages(sockets, abortListener);
+        this.offChannel("reply", channel, replyListener);
+        for (const socket of sockets) {
+          this.offSocket("abortRequests", socket, abortRequestsHandler);
+        }
         const timeoutError = new WebSocketMessageTimeoutError(this.messageTimeout);
         reject(timeoutError);
       }, this.messageTimeout);
-      const abortListener = this.onAbortSocketMessages(sockets, (error) => {
+      const replyListener = this.onChannel("reply", channel, (message) => {
+        if (message.requestId !== request.id) {
+          return;
+        }
         clearTimeout(replyTimeout);
-        this.offReply(channel, replyListener);
-        this.offAbortSocketMessages(sockets, abortListener);
-        reject(error);
-      });
-      const replyListener = this.onReply(channel, (message) => {
-        if (message.requestId === requestId) {
-          clearTimeout(replyTimeout);
-          this.offReply(channel, replyListener);
-          this.offAbortSocketMessages(sockets, abortListener);
-          resolve(message);
+        this.offChannel("reply", channel, replyListener);
+        for (const socket of sockets) {
+          this.offSocket("abortRequests", socket, abortRequestsHandler);
         }
+        resolve(message);
       });
+      const abortRequestsHandler = (options) => {
+        const shouldAbortRequest = options.shouldAbortRequest === void 0 || options.shouldAbortRequest(request);
+        if (!shouldAbortRequest) {
+          return;
+        }
+        clearTimeout(replyTimeout);
+        this.offChannel("reply", channel, replyListener);
+        for (const socket of sockets) {
+          this.offSocket("abortRequests", socket, abortRequestsHandler);
+        }
+        const abortError = new WebSocketMessageAbortError();
+        reject(abortError);
+      };
+      for (const socket of sockets) {
+        this.onSocket("abortRequests", socket, abortRequestsHandler);
+      }
     });
   }
   isReplyMessage(message) {
@@ -1078,9 +1094,9 @@ var WebSocketHandler = class {
       socket.send(stringifiedMessage);
     }
   }
-  onEvent(channel, listener) {
+  onChannel(type, channel, listener) {
     const listeners = this.getOrCreateChannelListeners(channel);
-    listeners.event.add(listener);
+    listeners[type].add(listener);
     return listener;
   }
   getOrCreateChannelListeners(channel) {
@@ -1093,42 +1109,36 @@ var WebSocketHandler = class {
     }
     return listeners;
   }
-  onReply(channel, listener) {
-    const listeners = this.getOrCreateChannelListeners(channel);
-    listeners.reply.add(listener);
-    return listener;
-  }
-  offEvent(channel, listener) {
-    this.channelListeners[channel]?.event.delete(listener);
+  offChannel(type, channel, listener) {
+    const listeners = this.channelListeners[channel];
+    listeners?.[type].delete(listener);
   }
-  offReply(channel, listener) {
-    this.channelListeners[channel]?.reply.delete(listener);
-  }
-  removeAllChannelListeners() {
-    this.channelListeners = {};
+  onSocket(type, socket, listener) {
+    const listeners = this.getOrCreateSocketListeners(type, socket);
+    listeners.add(listener);
+    return listener;
   }
-  onAbortSocketMessages(sockets, listener) {
-    for (const socket of sockets) {
-      let listeners = this.socketListeners.messageAbort.get(socket);
-      if (!listeners) {
-        listeners = /* @__PURE__ */ new Set();
-        this.socketListeners.messageAbort.set(socket, listeners);
-      }
-      listeners.add(listener);
+  getOrCreateSocketListeners(type, socket) {
+    const listeners = this.socketListeners[type].get(socket) ?? /* @__PURE__ */ new Set();
+    if (!this.socketListeners[type].has(socket)) {
+      this.socketListeners[type].set(socket, listeners);
     }
-    return listener;
+    return listeners;
   }
-  offAbortSocketMessages(sockets, listener) {
-    for (const socket of sockets) {
-      this.socketListeners.messageAbort.get(socket)?.delete(listener);
+  offSocket(type, socket, listener) {
+    const listeners = this.socketListeners[type].get(socket);
+    listeners?.delete(listener);
+  }
+  emitSocket(type, socket, options = {}) {
+    for (const listener of this.socketListeners[type].get(socket) ?? []) {
+      listener(options);
     }
   }
-  abortSocketMessages(sockets = this.sockets) {
-    const abortError = new WebSocketMessageAbortError();
-    for (const socket of sockets) {
-      const listeners = this.socketListeners.messageAbort.get(socket) ?? [];
-      for (const listener of listeners) {
-        listener(abortError);
+  offAny() {
+    this.channelListeners = {};
+    for (const listenersBySocket of Object.values(this.socketListeners)) {
+      for (const listeners of listenersBySocket.values()) {
+        listeners.clear();
       }
     }
   }
@@ -1181,11 +1191,9 @@ var WebSocketServer = class extends WebSocketHandler_default {
     if (!this.webSocketServer || !this.isRunning) {
       return;
     }
-    super.removeAllChannelListeners();
-    super.abortSocketMessages();
+    super.offAny();
     await super.closeClientSockets();
     await closeServerSocket(this.webSocketServer, { timeout: this.socketTimeout });
-    this.webSocketServer.removeAllListeners();
     this.webSocketServer = void 0;
   }
 };
@@ -1535,17 +1543,17 @@ var InterceptorServer = class {
     return void 0;
   }
   async startHttpServer() {
+    this.httpServerOrThrow.on("request", this.handleHttpRequest);
     await startHttpServer(this.httpServerOrThrow, {
       hostname: this.hostname,
       port: this.port
     });
     this.port = getHttpServerPort(this.httpServerOrThrow);
-    this.httpServerOrThrow.on("request", this.handleHttpRequest);
   }
   startWebSocketServer() {
+    this.webSocketServerOrThrow.onChannel("event", "interceptors/workers/commit", this.commitWorker);
+    this.webSocketServerOrThrow.onChannel("event", "interceptors/workers/reset", this.resetWorker);
     this.webSocketServerOrThrow.start();
-    this.webSocketServerOrThrow.onEvent("interceptors/workers/commit", this.commitWorker);
-    this.webSocketServerOrThrow.onEvent("interceptors/workers/reset", this.resetWorker);
   }
   commitWorker = (message, socket) => {
     const commit = message.data;
@@ -1553,18 +1561,31 @@ var InterceptorServer = class {
     this.registerWorkerSocketIfUnknown(socket);
     return {};
   };
-  resetWorker = (message, socket) => {
-    this.removeHttpHandlersBySocket(socket);
-    const handlersToResetTo = message.data;
-    const isWorkerNoLongerCommitted = handlersToResetTo === void 0;
-    if (isWorkerNoLongerCommitted) {
-      this.webSocketServerOrThrow.abortSocketMessages([socket]);
-    } else {
-      for (const handler of handlersToResetTo) {
-        this.registerHttpHandler(handler, socket);
+  resetWorker = ({ data: handlersToRecommit }, socket) => {
+    this.registerWorkerSocketIfUnknown(socket);
+    this.webSocketServerOrThrow.emitSocket("abortRequests", socket, {
+      shouldAbortRequest: (request) => {
+        const isResponseCreationRequest = this.webSocketServerOrThrow.isChannelEvent(
+          request,
+          "interceptors/responses/create"
+        );
+        if (!isResponseCreationRequest) {
+          return false;
+        }
+        const isHandlerStillCommitted = handlersToRecommit.some(
+          /* istanbul ignore next -- @preserve
+           * Ensuring this function is called in tests is difficult because it requires clearing or stopping a worker
+           * at the exact moment a request is being handled, in a scenario when there are other handlers still
+           * committed. */
+          (handler) => request.data.handlerId === handler.id
+        );
+        return !isHandlerStillCommitted;
       }
+    });
+    this.removeHttpHandlersBySocket(socket);
+    for (const handler of handlersToRecommit) {
+      this.registerHttpHandler(handler, socket);
     }
-    this.registerWorkerSocketIfUnknown(socket);
     return {};
   };
   registerHttpHandler({ id, baseURL, method, path: path2 }, socket) {
@@ -1605,8 +1626,8 @@ var InterceptorServer = class {
     this.httpServer = void 0;
   }
   async stopWebSocketServer() {
-    this.webSocketServerOrThrow.offEvent("interceptors/workers/commit", this.commitWorker);
-    this.webSocketServerOrThrow.offEvent("interceptors/workers/reset", this.resetWorker);
+    this.webSocketServerOrThrow.offChannel("event", "interceptors/workers/commit", this.commitWorker);
+    this.webSocketServerOrThrow.offChannel("event", "interceptors/workers/reset", this.resetWorker);
     await this.webSocketServerOrThrow.stop();
     this.webSocketServer = void 0;
   }
@@ -1736,6 +1757,8 @@ function createInterceptorServer(options = {}) {
 /* istanbul ignore next -- @preserve
  * Reply listeners are always present when notified in normal conditions. If they were not present, the request
  * would reach a timeout and not be responded. The empty set serves as a fallback. */
+/* istanbul ignore if -- @preserve
+ * Aborting requests is highly non-deterministic because it depends on specific timing of socket events. */
 /* istanbul ignore if -- @preserve
  * This should never happen, but let's check that the token identifier is valid after generated. */
 /* istanbul ignore if -- @preserve
@@ -1746,6 +1769,9 @@ function createInterceptorServer(options = {}) {
  * The HTTP server is initialized before using this method in normal conditions. */
 /* istanbul ignore if -- @preserve
  * The web socket server is initialized before using this method in normal conditions. */
+/* istanbul ignore if -- @preserve
+ * While resetting a worker, there could be other types of requests in progress. These are not guaranteed to
+ * exist and are not related to handler resets, so we let them continue. */
 /* istanbul ignore else -- @preserve
  * This is always true during tests because we force max-age=0 to disable CORS caching. */
 /* istanbul ignore next -- @preserve
@@ -1769,5 +1795,5 @@ exports.listInterceptorTokens = listInterceptorTokens;
 exports.logger = logger;
 exports.readInterceptorTokenFromFile = readInterceptorTokenFromFile;
 exports.removeInterceptorToken = removeInterceptorToken;
-//# sourceMappingURL=chunk-ZU6IGW27.js.map
-//# sourceMappingURL=chunk-ZU6IGW27.js.map
+//# sourceMappingURL=chunk-IPL73BDI.js.map
+//# sourceMappingURL=chunk-IPL73BDI.js.map