@zimic/interceptor 1.1.4 → 1.1.5-canary.2

package/dist/server.js

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

package/package.json

@@ -14,7 +14,7 @@
     "api",
     "static"
   ],
-  "version": "1.1.4",
+  "version": "1.1.5-canary.2",
   "homepage": "https://zimic.dev/docs/interceptor",
   "repository": {
     "type": "git",
@@ -79,6 +79,23 @@
     },
     "./package.json": "./package.json"
   },
+  "scripts": {
+    "dev": "tsup --watch",
+    "cli": "node --enable-source-maps ./dist/cli.js",
+    "build": "tsup",
+    "lint": "eslint --cache --no-error-on-unmatched-pattern --no-warn-ignored --fix",
+    "lint:turbo": "pnpm lint . --max-warnings 0",
+    "style": "prettier --log-level warn --ignore-unknown --no-error-on-unmatched-pattern --cache",
+    "style:check": "pnpm style --check",
+    "style:format": "pnpm style --write",
+    "test": "dotenv -v NODE_ENV=test -v FORCE_COLOR=1 -- vitest",
+    "test:turbo": "dotenv -v CI=true -- pnpm run test run --coverage",
+    "types:check": "tsc --noEmit",
+    "deps:install-playwright": "playwright install chromium",
+    "deps:init-msw": "msw init ./public --no-save",
+    "deps:prepare": "pnpm deps:install-playwright && pnpm deps:init-msw",
+    "postinstall": "node --enable-source-maps -e \"try{require('./dist/scripts/postinstall')}catch(error){console.error(error)}\""
+  },
   "dependencies": {
     "@whatwg-node/server": "0.10.12",
     "execa": "9.6.0",
@@ -98,41 +115,24 @@
     "@types/yargs": "^17.0.33",
     "@vitest/browser": "^3.2.4",
     "@vitest/coverage-istanbul": "^3.2.4",
+    "@zimic/eslint-config-node": "workspace:*",
+    "@zimic/lint-staged-config": "workspace:*",
+    "@zimic/tsconfig": "workspace:*",
+    "@zimic/utils": "workspace:*",
     "dotenv-cli": "^10.0.0",
     "eslint": "^9.37.0",
     "playwright": "^1.55.1",
     "tsup": "^8.4.0",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4",
-    "@zimic/eslint-config-node": "0.0.0",
-    "@zimic/lint-staged-config": "0.0.0",
-    "@zimic/tsconfig": "0.0.0",
-    "@zimic/utils": "0.0.0"
+    "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "typescript": ">=5.0.0",
-    "@zimic/http": "^1.2.0 || 1.2.0"
+    "@zimic/http": "^1.2.0 || workspace:*",
+    "typescript": ">=5.0.0"
   },
   "peerDependenciesMeta": {
     "typescript": {
       "optional": true
     }
-  },
-  "scripts": {
-    "dev": "tsup --watch",
-    "cli": "node --enable-source-maps ./dist/cli.js",
-    "build": "tsup",
-    "lint": "eslint --cache --no-error-on-unmatched-pattern --no-warn-ignored --fix",
-    "lint:turbo": "pnpm lint . --max-warnings 0",
-    "style": "prettier --log-level warn --ignore-unknown --no-error-on-unmatched-pattern --cache",
-    "style:check": "pnpm style --check",
-    "style:format": "pnpm style --write",
-    "test": "dotenv -v NODE_ENV=test -v FORCE_COLOR=1 -- vitest",
-    "test:turbo": "dotenv -v CI=true -- pnpm run test run --coverage",
-    "types:check": "tsc --noEmit",
-    "deps:install-playwright": "playwright install chromium",
-    "deps:init-msw": "msw init ./public --no-save",
-    "deps:prepare": "pnpm deps:install-playwright && pnpm deps:init-msw",
-    "postinstall": "node --enable-source-maps -e \"try{require('./dist/scripts/postinstall')}catch(error){console.error(error)}\""
   }
-}
+}

package/src/http/interceptor/HttpInterceptorClient.ts

@@ -15,7 +15,10 @@ import validateURLProtocol from '@zimic/utils/url/validateURLProtocol';
 import { isServerSide } from '@/utils/environment';
 
 import HttpInterceptorWorker from '../interceptorWorker/HttpInterceptorWorker';
-import HttpRequestHandlerClient, { AnyHttpRequestHandlerClient } from '../requestHandler/HttpRequestHandlerClient';
+import HttpRequestHandlerClient, {
+  AnyHttpRequestHandlerClient,
+  HttpRequestHandlerRequestMatch,
+} from '../requestHandler/HttpRequestHandlerClient';
 import LocalHttpRequestHandler from '../requestHandler/LocalHttpRequestHandler';
 import RemoteHttpRequestHandler from '../requestHandler/RemoteHttpRequestHandler';
 import { HttpRequestHandler, InternalHttpRequestHandler } from '../requestHandler/types/public';
@@ -54,7 +57,7 @@ class HttpInterceptorClient<
 
   private Handler: HandlerConstructor;
 
-  private handlerClientsByMethod: {
+  private handlers: {
     [Method in HttpMethod]: Map<string, AnyHttpRequestHandlerClient[]>;
   } = {
     GET: new Map(),
@@ -229,21 +232,23 @@ class HttpInterceptorClient<
     Path extends HttpSchemaPath<Schema, Method>,
     StatusCode extends HttpStatusCode = never,
   >(handler: InternalHttpRequestHandler<Schema, Method, Path, StatusCode>) {
-    const handlerClients = this.handlerClientsByMethod[handler.method].get(handler.path) ?? [];
+    const pathHandlers = this.handlers[handler.method].get(handler.path) ?? [];
+
+    const isAlreadyRegistered = pathHandlers.includes(handler.client);
 
-    const isAlreadyRegistered = handlerClients.includes(handler.client);
     if (isAlreadyRegistered) {
       return;
     }
 
-    handlerClients.push(handler.client);
+    pathHandlers.push(handler.client);
+
+    const isFirstHandlerForMethodPath = pathHandlers.length === 1;
 
-    const isFirstHandlerForMethodPath = handlerClients.length === 1;
     if (!isFirstHandlerForMethodPath) {
       return;
     }
 
-    this.handlerClientsByMethod[handler.method].set(handler.path, handlerClients);
+    this.handlers[handler.method].set(handler.path, pathHandlers);
 
     const pathRegex = createRegexFromPath(handler.path);
 
@@ -312,18 +317,45 @@ class HttpInterceptorClient<
   >(
     method: Method,
     path: Path,
-    parsedRequest: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
+    request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ): Promise<HttpRequestHandlerClient<Schema, Method, Path, any> | undefined> {
     /* istanbul ignore next -- @preserve
      * Ignoring because there will always be a handler for the given method and path at this point. */
-    const handlersByPath = this.handlerClientsByMethod[method].get(path) ?? [];
+    const pathHandlers = this.handlers[method].get(path) ?? [];
+
+    const failedRequestMatches = new Map<
+      AnyHttpRequestHandlerClient,
+      Extract<HttpRequestHandlerRequestMatch, { success: false }>
+    >();
+
+    // If we find a matching handler that can accept more requests, we return it immediately.
+    for (let handlerIndex = pathHandlers.length - 1; handlerIndex >= 0; handlerIndex--) {
+      const handler = pathHandlers[handlerIndex];
+      const requestMatch = await handler.matchesRequest(request);
 
-    for (let handlerIndex = handlersByPath.length - 1; handlerIndex >= 0; handlerIndex--) {
-      const handler = handlersByPath[handlerIndex];
-      if (await handler.matchesRequest(parsedRequest)) {
+      if (requestMatch.success) {
+        handler.markRequestAsMatched(request);
         return handler;
       }
+
+      failedRequestMatches.set(handler, requestMatch);
+    }
+
+    // If no handler matched or could accept more requests, we iterate again over the handlers to check which ones
+    // could have matched considering only restrictions.
+    for (let handlerIndex = pathHandlers.length - 1; handlerIndex >= 0; handlerIndex--) {
+      const handler = pathHandlers[handlerIndex];
+      const requestMatch = failedRequestMatches.get(handler);
+
+      // Handlers that did not match due to anything other than restrictions are still marked as matched to trigger a
+      // times check error.
+      if (requestMatch?.cause === 'unmatchedRestrictions') {
+        handler.markRequestAsUnmatched(request, { diff: requestMatch.diff });
+      } else {
+        handler.markRequestAsMatched(request);
+        break;
+      }
     }
 
     return undefined;
@@ -331,10 +363,11 @@ class HttpInterceptorClient<
 
   checkTimes() {
     for (const method of HTTP_METHODS) {
-      const handlersByPath = this.handlerClientsByMethod[method];
+      const pathHandlers = this.handlers[method];
 
-      for (const handlers of handlersByPath.values()) {
-        for (const handler of handlers) {
+      for (const handlers of pathHandlers.values()) {
+        for (let handlerIndex = handlers.length - 1; handlerIndex >= 0; handlerIndex--) {
+          const handler = handlers[handlerIndex];
           handler.checkTimes();
         }
       }
@@ -353,8 +386,8 @@ class HttpInterceptorClient<
         clearResults.push(Promise.resolve(result));
       }
 
-      const handlersByPath = this.handlerClientsByMethod[method];
-      handlersByPath.clear();
+      const pathHandlers = this.handlers[method];
+      pathHandlers.clear();
     }
 
     if (options.onCommitSuccess) {
@@ -363,10 +396,10 @@ class HttpInterceptorClient<
   }
 
   private clearMethodHandlers(method: HttpMethod) {
-    const handlersByPath = this.handlerClientsByMethod[method];
+    const pathHandlers = this.handlers[method];
     const clearResults: PossiblePromise<AnyHttpRequestHandlerClient>[] = [];
 
-    for (const handlers of handlersByPath.values()) {
+    for (const handlers of pathHandlers.values()) {
       for (const handler of handlers) {
         clearResults.push(handler.clear());
       }

package/src/http/requestHandler/HttpRequestHandlerClient.ts

@@ -43,6 +43,11 @@ const DEFAULT_NUMBER_OF_REQUEST_LIMITS: Range<number> = Object.freeze({
   max: Infinity,
 });
 
+export type HttpRequestHandlerRequestMatch =
+  | { success: true }
+  | { success: false; cause: 'missingResponseDeclaration' | 'exceededNumberOfRequests' }
+  | { success: false; cause: 'unmatchedRestrictions'; diff: RestrictionDiffs };
+
 class HttpRequestHandlerClient<
   Schema extends HttpSchema,
   Method extends HttpSchemaMethod<Schema>,
@@ -158,33 +163,49 @@ class HttpRequestHandlerClient<
     return this;
   }
 
-  async matchesRequest(request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>): Promise<boolean> {
-    const hasDeclaredResponse = this.createResponseDeclaration !== undefined;
+  async matchesRequest(
+    request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
+  ): Promise<HttpRequestHandlerRequestMatch> {
+    const restrictionsMatch = await this.matchesRestrictions(request);
 
-    const restrictionsMatch = await this.matchesRequestRestrictions(request);
+    if (!restrictionsMatch.success) {
+      return { success: false, cause: 'unmatchedRestrictions', diff: restrictionsMatch.diff };
+    }
 
-    if (restrictionsMatch.success) {
-      this.numberOfMatchedRequests++;
-    } else {
-      const shouldSaveUnmatchedGroup =
-        this.interceptor.requestSaving.enabled &&
-        this.restrictions.length > 0 &&
-        this.timesDeclarationPointer !== undefined;
+    const hasResponseDeclaration = this.createResponseDeclaration !== undefined;
 
-      if (shouldSaveUnmatchedGroup) {
-        this.unmatchedRequestGroups.push({ request, diff: restrictionsMatch.diff });
-      }
+    if (!hasResponseDeclaration) {
+      return { success: false, cause: 'missingResponseDeclaration' };
     }
 
-    if (!hasDeclaredResponse) {
-      return false;
+    const canAcceptMoreRequests = this.numberOfMatchedRequests < this.limits.numberOfRequests.max;
+
+    if (!canAcceptMoreRequests) {
+      return { success: false, cause: 'exceededNumberOfRequests' };
     }
 
-    const isWithinLimits = this.numberOfMatchedRequests <= this.limits.numberOfRequests.max;
-    return restrictionsMatch.success && isWithinLimits;
+    return { success: true };
+  }
+
+  markRequestAsMatched(_request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>) {
+    this.numberOfMatchedRequests++;
   }
 
-  private async matchesRequestRestrictions(
+  markRequestAsUnmatched(
+    request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
+    options: { diff: RestrictionDiffs },
+  ) {
+    const shouldSaveUnmatchedRequests =
+      this.interceptor.requestSaving.enabled &&
+      this.restrictions.length > 0 &&
+      this.timesDeclarationPointer !== undefined;
+
+    if (shouldSaveUnmatchedRequests) {
+      this.unmatchedRequestGroups.push({ request, diff: options.diff });
+    }
+  }
+
+  async matchesRestrictions(
     request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
   ): Promise<RestrictionMatchResult<RestrictionDiffs>> {
     for (const restriction of this.restrictions) {
@@ -392,6 +413,7 @@ class HttpRequestHandlerClient<
     if (!this.createResponseDeclaration) {
       throw new NoResponseDefinitionError();
     }
+
     const appliedDeclaration = await this.createResponseDeclaration(request);
     return appliedDeclaration;
   }

package/src/http/requestHandler/LocalHttpRequestHandler.ts

@@ -70,8 +70,18 @@ class LocalHttpRequestHandler<
     return this.client.requests;
   }
 
-  matchesRequest(request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>): Promise<boolean> {
-    return this.client.matchesRequest(request);
+  async matchesRequest(request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>) {
+    const requestMatch = await this.client.matchesRequest(request);
+
+    if (requestMatch.success) {
+      this.client.markRequestAsMatched(request);
+    } else if (requestMatch.cause === 'unmatchedRestrictions') {
+      this.client.markRequestAsUnmatched(request, { diff: requestMatch.diff });
+    } else {
+      this.client.markRequestAsMatched(request);
+    }
+
+    return requestMatch;
   }
 
   async applyResponseDeclaration(

package/src/http/requestHandler/RemoteHttpRequestHandler.ts

@@ -110,8 +110,18 @@ class RemoteHttpRequestHandler<
     return this.client.requests;
   }
 
-  matchesRequest(request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>): Promise<boolean> {
-    return this.client.matchesRequest(request);
+  async matchesRequest(request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>) {
+    const requestMatch = await this.client.matchesRequest(request);
+
+    if (requestMatch.success) {
+      this.client.markRequestAsMatched(request);
+    } else if (requestMatch.cause === 'unmatchedRestrictions') {
+      this.client.markRequestAsUnmatched(request, { diff: requestMatch.diff });
+    } else {
+      this.client.markRequestAsMatched(request);
+    }
+
+    return requestMatch;
   }
 
   async applyResponseDeclaration(

package/src/http/requestHandler/types/restrictions.ts

@@ -106,8 +106,8 @@ export type RestrictionMatchResult<Value> = { success: true; diff?: undefined }
 
 export interface RestrictionDiffs {
   computed?: RestrictionDiff<boolean>;
-  headers?: RestrictionDiff<HttpHeaders<any>>; // eslint-disable-line @typescript-eslint/no-explicit-any
-  searchParams?: RestrictionDiff<HttpSearchParams<any>>; // eslint-disable-line @typescript-eslint/no-explicit-any
+  headers?: RestrictionDiff<HttpHeaders>;
+  searchParams?: RestrictionDiff<HttpSearchParams>;
   body?: RestrictionDiff<unknown>;
 }
 

package/src/utils/http.ts

@@ -94,10 +94,6 @@ export function getHttpServerPort(server: HttpServer) {
 
 export const HTTP_METHODS_WITH_REQUEST_BODY = new Set<HttpMethod>(['POST', 'PUT', 'PATCH', 'DELETE']);
 
-export function methodCanHaveRequestBody(method: HttpMethod) {
-  return HTTP_METHODS_WITH_REQUEST_BODY.has(method);
-}
-
 export const HTTP_METHODS_WITH_RESPONSE_BODY = new Set<HttpMethod>([
   'GET',
   'POST',