@zimic/interceptor 1.2.3 → 1.2.4-canary.1

package/dist/http.js

@@ -58,7 +58,7 @@ var UnknownHttpInterceptorPlatformError = class extends Error {
    * Ignoring because checking unknown platforms is currently not possible in our Vitest setup. */
   constructor() {
     super("Unknown interceptor platform.");
-    this.name = "UnknownHttpInterceptorPlatform";
+    this.name = "UnknownHttpInterceptorPlatformError";
   }
 };
 var UnknownHttpInterceptorPlatformError_default = UnknownHttpInterceptorPlatformError;
@@ -1664,7 +1664,7 @@ var HttpInterceptorClient = class {
   }
   clear() {
     const clearPromises = [
-      Promise.resolve(this.workerOrThrow.clearInterceptorHandlers(this))
+      Promise.resolve(this.workerOrThrow.clearHandlers({ interceptor: this }))
     ];
     for (const method of http.HTTP_METHODS) {
       for (const result of this.clearMethodHandlers(method)) {
@@ -1878,19 +1878,19 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
       return msw.passthrough();
     }
   }
-  clearHandlers() {
-    this.internalWorkerOrThrow.resetHandlers();
-    for (const handlers of Object.values(this.httpHandlersByMethod)) {
-      handlers.length = 0;
-    }
-  }
-  clearInterceptorHandlers(interceptor) {
+  clearHandlers(options = {}) {
     if (!this.isRunning) {
       throw new NotRunningHttpInterceptorError_default();
     }
-    for (const methodHandlers of Object.values(this.httpHandlersByMethod)) {
-      const groupToRemoveIndex = methodHandlers.findIndex((group) => group.interceptor === interceptor);
-      removeArrayIndex(methodHandlers, groupToRemoveIndex);
+    if (options.interceptor === void 0) {
+      for (const handlers of Object.values(this.httpHandlersByMethod)) {
+        handlers.length = 0;
+      }
+    } else {
+      for (const methodHandlers of Object.values(this.httpHandlersByMethod)) {
+        const groupToRemoveIndex = methodHandlers.findIndex((group) => group.interceptor === options.interceptor);
+        removeArrayIndex(methodHandlers, groupToRemoveIndex);
+      }
     }
   }
   get interceptorsWithHandlers() {
@@ -1955,13 +1955,13 @@ var WebSocketTimeoutError = class extends Error {
 var WebSocketOpenTimeoutError = class extends WebSocketTimeoutError {
   constructor(reachedTimeout) {
     super(`Web socket open timed out after ${reachedTimeout}ms.`);
-    this.name = "WebSocketOpenTimeout";
+    this.name = "WebSocketOpenTimeoutError";
   }
 };
 var WebSocketMessageTimeoutError = class extends WebSocketTimeoutError {
   constructor(reachedTimeout) {
     super(`Web socket message timed out after ${reachedTimeout}ms.`);
-    this.name = "WebSocketMessageTimeout";
+    this.name = "WebSocketMessageTimeoutError";
   }
 };
 var WebSocketMessageAbortError = class extends WebSocketTimeoutError {
@@ -1973,7 +1973,7 @@ var WebSocketMessageAbortError = class extends WebSocketTimeoutError {
 var WebSocketCloseTimeoutError = class extends WebSocketTimeoutError {
   constructor(reachedTimeout) {
     super(`Web socket close timed out after ${reachedTimeout}ms.`);
-    this.name = "WebSocketCloseTimeout";
+    this.name = "WebSocketCloseTimeoutError";
   }
 };
 var DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT = 60 * 1e3;
@@ -2061,14 +2061,14 @@ async function closeClientSocket(socket, options = {}) {
 // src/webSocket/constants.ts
 var WEB_SOCKET_CONTROL_MESSAGES = Object.freeze(["socket:auth:valid"]);
 
-// src/webSocket/errors/InvalidWebSocketMessage.ts
-var InvalidWebSocketMessage = class extends Error {
+// src/webSocket/errors/InvalidWebSocketMessageError.ts
+var InvalidWebSocketMessageError = class extends Error {
   constructor(message) {
     super(`Web socket message is invalid and could not be parsed: ${message}`);
-    this.name = "InvalidWebSocketMessage";
+    this.name = "InvalidWebSocketMessageError";
   }
 };
-var InvalidWebSocketMessage_default = InvalidWebSocketMessage;
+var InvalidWebSocketMessageError_default = InvalidWebSocketMessageError;
 
 // src/webSocket/errors/NotRunningWebSocketHandlerError.ts
 var NotRunningWebSocketHandlerError = class extends Error {
@@ -2086,7 +2086,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;
@@ -2107,10 +2107,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);
@@ -2134,7 +2136,7 @@ var WebSocketHandler = class {
     if (typeof data === "string") {
       return data;
     } else {
-      throw new InvalidWebSocketMessage_default(data);
+      throw new InvalidWebSocketMessageError_default(data);
     }
   }
   parseMessage(stringifiedMessage) {
@@ -2142,10 +2144,10 @@ var WebSocketHandler = class {
     try {
       parsedMessage = JSON.parse(stringifiedMessage);
     } catch {
-      throw new InvalidWebSocketMessage_default(stringifiedMessage);
+      throw new InvalidWebSocketMessageError_default(stringifiedMessage);
     }
     if (!this.isMessage(parsedMessage)) {
-      throw new InvalidWebSocketMessage_default(stringifiedMessage);
+      throw new InvalidWebSocketMessageError_default(stringifiedMessage);
     }
     if (this.isReplyMessage(parsedMessage)) {
       return {
@@ -2164,6 +2166,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);
@@ -2192,10 +2197,6 @@ var WebSocketHandler = class {
     });
     await Promise.all(closingPromises);
   }
-  removeSocket(socket) {
-    this.abortSocketMessages([socket]);
-    this.sockets.delete(socket);
-  }
   async createEventMessage(channel, eventData) {
     const crypto = await importCrypto();
     const eventMessage = {
@@ -2212,31 +2213,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) {
@@ -2267,9 +2283,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) {
@@ -2282,42 +2298,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);
-  }
-  offReply(channel, listener) {
-    this.channelListeners[channel]?.reply.delete(listener);
+  offChannel(type, channel, listener) {
+    const listeners = this.channelListeners[channel];
+    listeners?.[type].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();
       }
     }
   }
@@ -2351,10 +2361,10 @@ var WebSocketClient = class extends WebSocketHandler_default {
     }
   }
   async stop() {
-    super.removeAllChannelListeners();
-    const sockets = this.socket ? [this.socket] : [];
-    super.abortSocketMessages(sockets);
-    await super.closeClientSockets(sockets);
+    super.offAny();
+    if (this.socket) {
+      await super.closeClientSockets([this.socket]);
+    }
     this.socket = void 0;
   }
 };
@@ -2382,12 +2392,12 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   }
   async start() {
     await super.sharedStart(async () => {
+      this.webSocketClient.onChannel("event", "interceptors/responses/create", this.createResponse);
+      this.webSocketClient.onChannel("event", "interceptors/responses/unhandled", this.handleUnhandledServerRequest);
       await this.webSocketClient.start({
         parameters: this.auth ? { token: this.auth.token } : void 0,
         waitForAuthentication: true
       });
-      this.webSocketClient.onEvent("interceptors/responses/create", this.createResponse);
-      this.webSocketClient.onEvent("interceptors/responses/unhandled", this.handleUnhandledServerRequest);
       this.platform = this.readPlatform();
       this.isRunning = true;
     });
@@ -2427,9 +2437,9 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   }
   async stop() {
     await super.sharedStop(async () => {
+      this.webSocketClient.offChannel("event", "interceptors/responses/create", this.createResponse);
+      this.webSocketClient.offChannel("event", "interceptors/responses/unhandled", this.handleUnhandledServerRequest);
       await this.clearHandlers();
-      this.webSocketClient.offEvent("interceptors/responses/create", this.createResponse);
-      this.webSocketClient.offEvent("interceptors/responses/unhandled", this.handleUnhandledServerRequest);
       await this.webSocketClient.stop();
       this.isRunning = false;
     });
@@ -2459,43 +2469,30 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
       path: handler.path
     });
   }
-  async clearHandlers() {
-    if (!this.isRunning) {
-      throw new NotRunningHttpInterceptorError_default();
-    }
-    this.httpHandlers.clear();
-    if (!this.webSocketClient.isRunning) {
-      return;
-    }
-    try {
-      await this.webSocketClient.request("interceptors/workers/reset", void 0);
-    } catch (error) {
-      const isMessageAbortError = error instanceof WebSocketMessageAbortError;
-      if (!isMessageAbortError) {
-        throw error;
-      }
-    }
-  }
-  async clearInterceptorHandlers(interceptor) {
+  async clearHandlers(options = {}) {
     if (!this.isRunning) {
       throw new NotRunningHttpInterceptorError_default();
     }
-    for (const handler of this.httpHandlers.values()) {
-      if (handler.interceptor === interceptor) {
-        this.httpHandlers.delete(handler.id);
+    if (options.interceptor === void 0) {
+      this.httpHandlers.clear();
+    } else {
+      for (const handler of this.httpHandlers.values()) {
+        if (handler.interceptor === options.interceptor) {
+          this.httpHandlers.delete(handler.id);
+        }
       }
     }
     if (!this.webSocketClient.isRunning) {
       return;
     }
-    const groupsToRecommit = Array.from(this.httpHandlers.values(), (handler) => ({
+    const handlersToRecommit = Array.from(this.httpHandlers.values(), (handler) => ({
       id: handler.id,
       baseURL: handler.baseURL,
       method: handler.method,
       path: handler.path
     }));
     try {
-      await this.webSocketClient.request("interceptors/workers/reset", groupsToRecommit);
+      await this.webSocketClient.request("interceptors/workers/reset", handlersToRecommit);
     } catch (error) {
       const isMessageAbortError = error instanceof WebSocketMessageAbortError;
       if (!isMessageAbortError) {
@@ -2530,10 +2527,11 @@ var HttpInterceptorStore = class _HttpInterceptorStore {
     return this.class._localWorker;
   }
   getRemoteWorkerKey(baseURL, options) {
-    if (!options.auth) {
-      return baseURL.origin;
+    const key = [`${baseURL.origin}${baseURL.pathname}`];
+    if (options.auth) {
+      key.push(options.auth.token);
     }
-    return `${baseURL.origin}:${options.auth.token}`;
+    return key.join(":");
   }
   remoteWorker(baseURL, options) {
     const remoteWorkerKey = this.getRemoteWorkerKey(baseURL, options);
@@ -2698,7 +2696,7 @@ var RemoteHttpInterceptor = class {
       baseURL,
       createWorker: () => {
         return this.store.getOrCreateRemoteWorker({
-          serverURL: new URL(baseURL.origin),
+          serverURL: baseURL,
           auth: this._auth
         });
       },
@@ -2832,6 +2830,8 @@ var InvalidJSONError = class extends http.InvalidJSONError {
 };
 /* istanbul ignore next -- @preserve
  * Ignoring because there will always be a handler for the given method and path at this point. */
+/* istanbul ignore if -- @preserve
+ * Trying to access the internal worker when it does not exist should not happen. */
 /* istanbul ignore else -- @preserve */
 /* istanbul ignore next -- @preserve
  * Ignoring because checking unknown platforms is not configured in our test setup. */
@@ -2848,6 +2848,8 @@ var InvalidJSONError = class extends http.InvalidJSONError {
 /* 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 next -- @preserve
  *
  * If the socket is closed before receiving a response, the message is aborted with an error. This can happen if