@zimic/interceptor 1.2.3 → 1.2.4-canary.1

package/dist/server.js

@@ -1,29 +1,29 @@
 'use strict';
 
-var chunkZU6IGW27_js = require('./chunk-ZU6IGW27.js');
+var chunkOKZEX5DQ_js = require('./chunk-OKZEX5DQ.js');
 require('./chunk-DGUM43GV.js');
 
 
 
 Object.defineProperty(exports, "DEFAULT_ACCESS_CONTROL_HEADERS", {
   enumerable: true,
-  get: function () { return chunkZU6IGW27_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
+  get: function () { return chunkOKZEX5DQ_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
 });
 Object.defineProperty(exports, "DEFAULT_PREFLIGHT_STATUS_CODE", {
   enumerable: true,
-  get: function () { return chunkZU6IGW27_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
+  get: function () { return chunkOKZEX5DQ_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
 });
 Object.defineProperty(exports, "NotRunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunkZU6IGW27_js.NotRunningInterceptorServerError_default; }
+  get: function () { return chunkOKZEX5DQ_js.NotRunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "RunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunkZU6IGW27_js.RunningInterceptorServerError_default; }
+  get: function () { return chunkOKZEX5DQ_js.RunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "createInterceptorServer", {
   enumerable: true,
-  get: function () { return chunkZU6IGW27_js.createInterceptorServer; }
+  get: function () { return chunkOKZEX5DQ_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-XCYZ5L2M.mjs';
+export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-EIYQEPK2.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",
+  "version": "1.2.4-canary.1",
   "homepage": "https://zimic.dev/docs/interceptor",
   "repository": {
     "type": "git",

package/src/http/interceptor/HttpInterceptorClient.ts

@@ -376,7 +376,7 @@ class HttpInterceptorClient<
 
   clear() {
     const clearPromises: Promise<AnyHttpRequestHandlerClient | void>[] = [
-      Promise.resolve(this.workerOrThrow.clearInterceptorHandlers(this)),
+      Promise.resolve(this.workerOrThrow.clearHandlers({ interceptor: this })),
     ];
 
     for (const method of HTTP_METHODS) {

package/src/http/interceptor/HttpInterceptorStore.ts

@@ -25,10 +25,13 @@ class HttpInterceptorStore {
   }
 
   private getRemoteWorkerKey(baseURL: URL, options: RemoteWorkerKeyOptions) {
-    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: URL, options: RemoteWorkerKeyOptions) {

package/src/http/interceptor/RemoteHttpInterceptor.ts

@@ -24,7 +24,7 @@ class RemoteHttpInterceptor<Schema extends HttpSchema> implements PublicRemoteHt
       baseURL,
       createWorker: () => {
         return this.store.getOrCreateRemoteWorker({
-          serverURL: new URL(baseURL.origin),
+          serverURL: baseURL,
           auth: this._auth,
         });
       },

package/src/http/interceptor/errors/UnknownHttpInterceptorPlatformError.ts

@@ -9,7 +9,7 @@ class UnknownHttpInterceptorPlatformError 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';
   }
 }
 

package/src/http/interceptorWorker/HttpInterceptorWorker.ts

@@ -183,11 +183,9 @@ abstract class HttpInterceptorWorker {
     return interceptor.onUnhandledRequest;
   }
 
-  abstract clearHandlers(): PossiblePromise<void>;
-
-  abstract clearInterceptorHandlers<Schema extends HttpSchema>(
-    interceptor: HttpInterceptorClient<Schema>,
-  ): PossiblePromise<void>;
+  abstract clearHandlers<Schema extends HttpSchema>(options?: {
+    interceptor?: HttpInterceptorClient<Schema>;
+  }): PossiblePromise<void>;
 
   abstract get interceptorsWithHandlers(): AnyHttpInterceptorClient[];
 

package/src/http/interceptorWorker/LocalHttpInterceptorWorker.ts

@@ -50,6 +50,8 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
   }
 
   get internalWorkerOrThrow() {
+    /* istanbul ignore if -- @preserve
+     * Trying to access the internal worker when it does not exist should not happen. */
     if (!this.internalWorker) {
       throw new NotRunningHttpInterceptorError();
     }
@@ -248,22 +250,24 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
     }
   }
 
-  clearHandlers() {
-    this.internalWorkerOrThrow.resetHandlers();
-
-    for (const handlers of Object.values(this.httpHandlersByMethod)) {
-      handlers.length = 0;
-    }
-  }
-
-  clearInterceptorHandlers<Schema extends HttpSchema>(interceptor: HttpInterceptorClient<Schema>) {
+  clearHandlers<Schema extends HttpSchema>(
+    options: {
+      interceptor?: HttpInterceptorClient<Schema>;
+    } = {},
+  ) {
     if (!this.isRunning) {
       throw new NotRunningHttpInterceptorError();
     }
 
-    for (const methodHandlers of Object.values(this.httpHandlersByMethod)) {
-      const groupToRemoveIndex = methodHandlers.findIndex((group) => group.interceptor === interceptor);
-      removeArrayIndex(methodHandlers, groupToRemoveIndex);
+    if (options.interceptor === undefined) {
+      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);
+      }
     }
   }
 

package/src/http/interceptorWorker/RemoteHttpInterceptorWorker.ts

@@ -55,14 +55,14 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
 
   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 } : undefined,
         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;
     });
@@ -120,10 +120,10 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
 
   async stop() {
     await super.sharedStop(async () => {
-      await this.clearHandlers();
+      this.webSocketClient.offChannel('event', 'interceptors/responses/create', this.createResponse);
+      this.webSocketClient.offChannel('event', 'interceptors/responses/unhandled', this.handleUnhandledServerRequest);
 
-      this.webSocketClient.offEvent('interceptors/responses/create', this.createResponse);
-      this.webSocketClient.offEvent('interceptors/responses/unhandled', this.handleUnhandledServerRequest);
+      await this.clearHandlers();
 
       await this.webSocketClient.stop();
 
@@ -167,45 +167,22 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     });
   }
 
-  async clearHandlers() {
-    if (!this.isRunning) {
-      throw new NotRunningHttpInterceptorError();
-    }
-
-    this.httpHandlers.clear();
-
-    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;
-      }
-    }
-  }
-
-  async clearInterceptorHandlers<Schema extends HttpSchema>(interceptor: HttpInterceptorClient<Schema>) {
+  async clearHandlers<Schema extends HttpSchema>(
+    options: {
+      interceptor?: HttpInterceptorClient<Schema>;
+    } = {},
+  ) {
     if (!this.isRunning) {
       throw new NotRunningHttpInterceptorError();
     }
 
-    for (const handler of this.httpHandlers.values()) {
-      if (handler.interceptor === interceptor) {
-        this.httpHandlers.delete(handler.id);
+    if (options.interceptor === undefined) {
+      this.httpHandlers.clear();
+    } else {
+      for (const handler of this.httpHandlers.values()) {
+        if (handler.interceptor === options.interceptor) {
+          this.httpHandlers.delete(handler.id);
+        }
       }
     }
 
@@ -213,7 +190,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
       return;
     }
 
-    const groupsToRecommit = Array.from<HttpHandler, HttpHandlerCommit>(this.httpHandlers.values(), (handler) => ({
+    const handlersToRecommit = Array.from<HttpHandler, HttpHandlerCommit>(this.httpHandlers.values(), (handler) => ({
       id: handler.id,
       baseURL: handler.baseURL,
       method: handler.method,
@@ -221,7 +198,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     }));
 
     try {
-      await this.webSocketClient.request('interceptors/workers/reset', groupsToRecommit);
+      await this.webSocketClient.request('interceptors/workers/reset', handlersToRecommit);
     } catch (error) {
       /* istanbul ignore next -- @preserve
        *

package/src/server/InterceptorServer.ts

@@ -164,20 +164,21 @@ class InterceptorServer implements PublicInterceptorServer {
   }
 
   private 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);
+    this.port = getHttpServerPort(this.httpServerOrThrow);
   }
 
   private startWebSocketServer() {
-    this.webSocketServerOrThrow.start();
+    this.webSocketServerOrThrow.onChannel('event', 'interceptors/workers/commit', this.commitWorker);
+    this.webSocketServerOrThrow.onChannel('event', 'interceptors/workers/reset', this.resetWorker);
 
-    this.webSocketServerOrThrow.onEvent('interceptors/workers/commit', this.commitWorker);
-    this.webSocketServerOrThrow.onEvent('interceptors/workers/reset', this.resetWorker);
+    this.webSocketServerOrThrow.start();
   }
 
   private commitWorker = (
@@ -193,25 +194,42 @@ class InterceptorServer implements PublicInterceptorServer {
   };
 
   private resetWorker = (
-    message: WebSocketEventMessage<InterceptorServerWebSocketSchema, 'interceptors/workers/reset'>,
+    { data: handlersToRecommit }: WebSocketEventMessage<InterceptorServerWebSocketSchema, 'interceptors/workers/reset'>,
     socket: Socket,
   ) => {
-    this.removeHttpHandlersBySocket(socket);
+    this.registerWorkerSocketIfUnknown(socket);
+
+    this.webSocketServerOrThrow.emitSocket('abortRequests', socket, {
+      shouldAbortRequest: (request) => {
+        const isResponseCreationRequest = this.webSocketServerOrThrow.isChannelEvent(
+          request,
+          'interceptors/responses/create',
+        );
 
-    const handlersToResetTo = message.data;
-    const isWorkerNoLongerCommitted = handlersToResetTo === undefined;
+        /* 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. */
+        if (!isResponseCreationRequest) {
+          return false;
+        }
 
-    if (isWorkerNoLongerCommitted) {
-      // When a worker is no longer committed, we should abort all requests that were using it.
-      // This ensures that we only wait for responses from committed worker sockets.
-      this.webSocketServerOrThrow.abortSocketMessages([socket]);
-    } else {
-      for (const handler of handlersToResetTo) {
-        this.registerHttpHandler(handler, socket);
-      }
-    }
+        // TODO: create a test with two interceptors, one for each path,, and reset only one of them.
+        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.registerWorkerSocketIfUnknown(socket);
+    this.removeHttpHandlersBySocket(socket);
+
+    for (const handler of handlersToRecommit) {
+      this.registerHttpHandler(handler, socket);
+    }
 
     return {};
   };
@@ -263,8 +281,8 @@ class InterceptorServer implements PublicInterceptorServer {
   }
 
   private 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();
 

package/src/server/types/schema.ts

@@ -17,7 +17,7 @@ export type InterceptorServerWebSocketSchema = WebSocketSchema<{
   };
 
   'interceptors/workers/reset': {
-    event?: HttpHandlerCommit[];
+    event: HttpHandlerCommit[];
     reply: {};
   };
 

package/src/utils/http.ts

@@ -6,14 +6,14 @@ class HttpServerTimeoutError extends Error {}
 export class HttpServerStartTimeoutError extends HttpServerTimeoutError {
   constructor(reachedTimeout: number) {
     super(`HTTP server start timed out after ${reachedTimeout}ms.`);
-    this.name = 'HttpServerStartTimeout';
+    this.name = 'HttpServerStartTimeoutError';
   }
 }
 
 export class HttpServerStopTimeoutError extends HttpServerTimeoutError {
   constructor(reachedTimeout: number) {
     super(`HTTP server stop timed out after ${reachedTimeout}ms.`);
-    this.name = 'HttpServerStopTimeout';
+    this.name = 'HttpServerStopTimeoutError';
   }
 }
 

package/src/utils/webSocket.ts

@@ -8,14 +8,14 @@ class WebSocketTimeoutError extends Error {}
 export class WebSocketOpenTimeoutError extends WebSocketTimeoutError {
   constructor(reachedTimeout: number) {
     super(`Web socket open timed out after ${reachedTimeout}ms.`);
-    this.name = 'WebSocketOpenTimeout';
+    this.name = 'WebSocketOpenTimeoutError';
   }
 }
 
 export class WebSocketMessageTimeoutError extends WebSocketTimeoutError {
   constructor(reachedTimeout: number) {
     super(`Web socket message timed out after ${reachedTimeout}ms.`);
-    this.name = 'WebSocketMessageTimeout';
+    this.name = 'WebSocketMessageTimeoutError';
   }
 }
 
@@ -29,7 +29,7 @@ export class WebSocketMessageAbortError extends WebSocketTimeoutError {
 export class WebSocketCloseTimeoutError extends WebSocketTimeoutError {
   constructor(reachedTimeout: number) {
     super(`Web socket close timed out after ${reachedTimeout}ms.`);
-    this.name = 'WebSocketCloseTimeout';
+    this.name = 'WebSocketCloseTimeoutError';
   }
 }
 

package/src/webSocket/WebSocketClient.ts

@@ -49,11 +49,11 @@ class WebSocketClient<Schema extends WebSocketSchema> extends WebSocketHandler<S
   }
 
   async stop() {
-    super.removeAllChannelListeners();
+    super.offAny();
 
-    const sockets = this.socket ? [this.socket] : [];
-    super.abortSocketMessages(sockets);
-    await super.closeClientSockets(sockets);
+    if (this.socket) {
+      await super.closeClientSockets([this.socket]);
+    }
 
     this.socket = undefined;
   }