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

package/dist/server.js

@@ -1,29 +1,29 @@
 'use strict';
 
-var chunkEMX4G67A_js = require('./chunk-EMX4G67A.js');
+var chunkZU6IGW27_js = require('./chunk-ZU6IGW27.js');
 require('./chunk-DGUM43GV.js');
 
 
 
 Object.defineProperty(exports, "DEFAULT_ACCESS_CONTROL_HEADERS", {
   enumerable: true,
-  get: function () { return chunkEMX4G67A_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
+  get: function () { return chunkZU6IGW27_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
 });
 Object.defineProperty(exports, "DEFAULT_PREFLIGHT_STATUS_CODE", {
   enumerable: true,
-  get: function () { return chunkEMX4G67A_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
+  get: function () { return chunkZU6IGW27_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
 });
 Object.defineProperty(exports, "NotRunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunkEMX4G67A_js.NotRunningInterceptorServerError_default; }
+  get: function () { return chunkZU6IGW27_js.NotRunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "RunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunkEMX4G67A_js.RunningInterceptorServerError_default; }
+  get: function () { return chunkZU6IGW27_js.RunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "createInterceptorServer", {
   enumerable: true,
-  get: function () { return chunkEMX4G67A_js.createInterceptorServer; }
+  get: function () { return chunkZU6IGW27_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-ZPZDEDJI.mjs';
+export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-XCYZ5L2M.mjs';
 import './chunk-BJTO5JO5.mjs';
 //# sourceMappingURL=server.mjs.map
 //# sourceMappingURL=server.mjs.map

package/package.json

@@ -14,7 +14,7 @@
     "api",
     "static"
   ],
-  "version": "1.2.3-canary.0",
+  "version": "1.2.3-canary.2",
   "homepage": "https://zimic.dev/docs/interceptor",
   "repository": {
     "type": "git",
@@ -110,9 +110,9 @@
     "@types/node": "^24.10.1",
     "@types/ws": "^8.18.1",
     "@types/yargs": "^17.0.35",
-    "@vitest/browser": "^4.0.6",
-    "@vitest/browser-playwright": "^4.0.6",
-    "@vitest/coverage-istanbul": "^4.0.6",
+    "@vitest/browser": "^4.0.9",
+    "@vitest/browser-playwright": "^4.0.9",
+    "@vitest/coverage-istanbul": "^4.0.9",
     "@zimic/eslint-config-node": "workspace:*",
     "@zimic/lint-staged-config": "workspace:*",
     "@zimic/tsconfig": "workspace:*",
@@ -123,7 +123,7 @@
     "playwright": "^1.56.1",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.6"
+    "vitest": "^4.0.9"
   },
   "peerDependencies": {
     "@zimic/http": "^1.2.0 || workspace:*",

package/src/http/interceptor/HttpInterceptorClient.ts

@@ -374,25 +374,21 @@ class HttpInterceptorClient<
     }
   }
 
-  clear(options: { onCommitSuccess?: () => void; onCommitError?: () => void } = {}) {
-    const clearResults: Promise<AnyHttpRequestHandlerClient | void>[] = [
+  clear() {
+    const clearPromises: Promise<AnyHttpRequestHandlerClient | void>[] = [
       Promise.resolve(this.workerOrThrow.clearInterceptorHandlers(this)),
     ];
 
     for (const method of HTTP_METHODS) {
-      const newClearResults = this.clearMethodHandlers(method);
-
-      for (const result of newClearResults) {
-        clearResults.push(Promise.resolve(result));
+      for (const result of this.clearMethodHandlers(method)) {
+        clearPromises.push(Promise.resolve(result));
       }
 
       const pathHandlers = this.handlers[method];
       pathHandlers.clear();
     }
 
-    if (options.onCommitSuccess) {
-      void Promise.all(clearResults).then(options.onCommitSuccess, options.onCommitError);
-    }
+    return Promise.all(clearPromises);
   }
 
   private clearMethodHandlers(method: HttpMethod) {

package/src/http/interceptor/LocalHttpInterceptor.ts

@@ -116,7 +116,7 @@ class LocalHttpInterceptor<Schema extends HttpSchema> implements PublicLocalHttp
   }
 
   clear() {
-    this.client.clear();
+    void this.client.clear();
   }
 }
 

package/src/http/interceptor/RemoteHttpInterceptor.ts

@@ -157,12 +157,7 @@ class RemoteHttpInterceptor<Schema extends HttpSchema> implements PublicRemoteHt
   }
 
   async clear() {
-    await new Promise<void>((resolve, reject) => {
-      this.client.clear({
-        onCommitSuccess: resolve,
-        onCommitError: reject,
-      });
-    });
+    await this.client.clear();
   }
 }
 

package/src/http/interceptorWorker/RemoteHttpInterceptorWorker.ts

@@ -5,6 +5,7 @@ import { HttpHandlerCommit, InterceptorServerWebSocketSchema } from '@/server/ty
 import { importCrypto } from '@/utils/crypto';
 import { isClientSide, isServerSide } from '@/utils/environment';
 import { deserializeRequest, serializeResponse } from '@/utils/fetch';
+import { WebSocketMessageAbortError } from '@/utils/webSocket';
 import { WebSocketEventMessage } from '@/webSocket/types';
 import WebSocketClient from '@/webSocket/WebSocketClient';
 
@@ -173,8 +174,27 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
 
     this.httpHandlers.clear();
 
-    if (this.webSocketClient.isRunning) {
+    if (!this.webSocketClient.isRunning) {
+      return;
+    }
+
+    try {
       await this.webSocketClient.request('interceptors/workers/reset', undefined);
+    } catch (error) {
+      /* istanbul ignore next -- @preserve
+       *
+       * If the socket is closed before receiving a response, the message is aborted with an error. This can happen if
+       * we send a request message and the interceptor server closes the socket before sending a response. In this case,
+       * we can safely ignore the error because we know that the server is shutting down and resetting is no longer
+       * necessary.
+       *
+       * Due to the rare nature of this edge case, we can't reliably reproduce it in tests. */
+      const isMessageAbortError = error instanceof WebSocketMessageAbortError;
+
+      /* istanbul ignore next -- @preserve */
+      if (!isMessageAbortError) {
+        throw error;
+      }
     }
   }
 
@@ -189,15 +209,34 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
       }
     }
 
-    if (this.webSocketClient.isRunning) {
-      const groupsToRecommit = Array.from<HttpHandler, HttpHandlerCommit>(this.httpHandlers.values(), (handler) => ({
-        id: handler.id,
-        baseURL: handler.baseURL,
-        method: handler.method,
-        path: handler.path,
-      }));
+    if (!this.webSocketClient.isRunning) {
+      return;
+    }
+
+    const groupsToRecommit = Array.from<HttpHandler, HttpHandlerCommit>(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);
+    } catch (error) {
+      /* istanbul ignore next -- @preserve
+       *
+       * If the socket is closed before receiving a response, the message is aborted with an error. This can happen if
+       * we send a request message and the interceptor server closes the socket before sending a response. In this case,
+       * we can safely ignore the error because we know that the server is shutting down and resetting is no longer
+       * necessary.
+       *
+       * Due to the rare nature of this edge case, we can't reliably reproduce it in tests. */
+      const isMessageAbortError = error instanceof WebSocketMessageAbortError;
+
+      /* istanbul ignore next -- @preserve */
+      if (!isMessageAbortError) {
+        throw error;
+      }
     }
   }
 

package/src/server/InterceptorServer.ts

@@ -385,8 +385,13 @@ class InterceptorServer implements PublicInterceptorServer {
         }
       } catch (error) {
         /* istanbul ignore next -- @preserve
-         * This try..catch is for the case when the remote interceptor web socket client is closed before responding.
-         * Since simulating this scenario is difficult, we are ignoring this branch fow now. */
+         *
+         * If the socket is closed before receiving a response, the message is aborted with an error. This can happen if
+         * we send a request message and the interceptor worker closes the socket before sending a response. In this
+         * case, we can safely ignore the error because we know that the worker is shutting down and won't handle
+         * any more requests.
+         *
+         * Due to the rare nature of this edge case, we can't reliably reproduce it in tests. */
         const isMessageAbortError = error instanceof WebSocketMessageAbortError;
 
         /* istanbul ignore next -- @preserve */