@zimic/interceptor 1.1.0-canary.1 → 1.1.0-canary.3

package/dist/server.js

@@ -1,29 +1,29 @@
 'use strict';
 
-var chunkLWUFSWRA_js = require('./chunk-LWUFSWRA.js');
+var chunkQDNKVSEG_js = require('./chunk-QDNKVSEG.js');
 require('./chunk-WCQVDF3K.js');
 
 
 
 Object.defineProperty(exports, "DEFAULT_ACCESS_CONTROL_HEADERS", {
   enumerable: true,
-  get: function () { return chunkLWUFSWRA_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
+  get: function () { return chunkQDNKVSEG_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
 });
 Object.defineProperty(exports, "DEFAULT_PREFLIGHT_STATUS_CODE", {
   enumerable: true,
-  get: function () { return chunkLWUFSWRA_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
+  get: function () { return chunkQDNKVSEG_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
 });
 Object.defineProperty(exports, "NotRunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunkLWUFSWRA_js.NotRunningInterceptorServerError_default; }
+  get: function () { return chunkQDNKVSEG_js.NotRunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "RunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunkLWUFSWRA_js.RunningInterceptorServerError_default; }
+  get: function () { return chunkQDNKVSEG_js.RunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "createInterceptorServer", {
   enumerable: true,
-  get: function () { return chunkLWUFSWRA_js.createInterceptorServer; }
+  get: function () { return chunkQDNKVSEG_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-7DRPXOOJ.mjs';
+export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-RDMXECNU.mjs';
 import './chunk-CGILA3WO.mjs';
 //# sourceMappingURL=server.mjs.map
 //# sourceMappingURL=server.mjs.map

package/package.json

@@ -14,7 +14,7 @@
     "api",
     "static"
   ],
-  "version": "1.1.0-canary.1",
+  "version": "1.1.0-canary.3",
   "homepage": "https://zimic.dev/docs/interceptor",
   "repository": {
     "type": "git",
@@ -105,13 +105,13 @@
     "typescript": "^5.9.2",
     "vitest": "^3.2.4",
     "@zimic/eslint-config-node": "0.0.0",
-    "@zimic/tsconfig": "0.0.0",
     "@zimic/lint-staged-config": "0.0.0",
-    "@zimic/utils": "0.0.0"
+    "@zimic/utils": "0.0.0",
+    "@zimic/tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0",
-    "@zimic/http": "^1.0.0 || 1.1.0-canary.1"
+    "@zimic/http": "^1.0.0 || 1.1.0-canary.4"
   },
   "peerDependenciesMeta": {
     "typescript": {

package/src/http/interceptor/HttpInterceptorClient.ts

@@ -8,9 +8,8 @@ import {
   HttpSchema,
 } from '@zimic/http';
 import { Default, PossiblePromise } from '@zimic/utils/types';
-import createRegExpFromURL from '@zimic/utils/url/createRegExpFromURL';
+import createParametrizedPathPattern from '@zimic/utils/url/createParametrizedPathPattern';
 import excludeURLParams from '@zimic/utils/url/excludeURLParams';
-import joinURL from '@zimic/utils/url/joinURL';
 import validateURLProtocol from '@zimic/utils/url/validateURLProtocol';
 
 import { isServerSide } from '@/utils/environment';
@@ -246,14 +245,13 @@ class HttpInterceptorClient<
 
     this.handlerClientsByMethod[handler.method].set(handler.path, handlerClients);
 
-    const url = joinURL(this.baseURLAsString, handler.path);
-    const urlRegex = createRegExpFromURL(url);
+    const pathPattern = createParametrizedPathPattern(handler.path);
 
-    const registrationResult = this.workerOrThrow.use(this, handler.method, url, async (context) => {
+    const registrationResult = this.workerOrThrow.use(this, handler.method, handler.path, async (context) => {
       const response = await this.handleInterceptedRequest(
-        urlRegex,
         handler.method,
         handler.path,
+        pathPattern,
         context as HttpInterceptorRequestContext<Schema, Method, Path>,
       );
       return response;
@@ -268,9 +266,10 @@ class HttpInterceptorClient<
     Method extends HttpSchemaMethod<Schema>,
     Path extends HttpSchemaPath<Schema, Method>,
     Context extends HttpInterceptorRequestContext<Schema, Method, Path>,
-  >(matchedURLRegex: RegExp, method: Method, path: Path, { request }: Context): Promise<HttpResponse | null> {
+  >(method: Method, path: Path, pathPattern: RegExp, { request }: Context): Promise<HttpResponse | null> {
     const parsedRequest = await HttpInterceptorWorker.parseRawRequest<Path, Default<Schema[Path][Method]>>(request, {
-      urlRegex: matchedURLRegex,
+      baseURL: this.baseURLAsString,
+      pathPattern,
     });
 
     const matchedHandler = await this.findMatchedHandler(method, path, parsedRequest);

package/src/http/interceptor/types/requests.ts

@@ -1,14 +1,15 @@
 import { HttpBody, HttpSchema, HttpSchemaMethod, HttpSchemaPath } from '@zimic/http';
 import { Default } from '@zimic/utils/types';
 
-import { MSWHttpResponseFactoryContext } from '../../interceptorWorker/types/msw';
+import { HttpResponseFactoryContext } from '@/http/interceptorWorker/types/http';
+
 import { HttpInterceptorRequest } from '../../requestHandler/types/requests';
 
 export type HttpInterceptorRequestContext<
   Schema extends HttpSchema,
   Method extends HttpSchemaMethod<Schema>,
   Path extends HttpSchemaPath<Schema, Method>,
-> = MSWHttpResponseFactoryContext<Default<Default<Schema[Path][Method]>['request']>['body']>;
+> = HttpResponseFactoryContext<Default<Default<Schema[Path][Method]>['request']>['body']>;
 
 export type UnhandledHttpInterceptorRequestPath = string;
 

package/src/http/interceptorWorker/HttpInterceptorWorker.ts

@@ -101,7 +101,7 @@ abstract class HttpInterceptorWorker {
   abstract use<Schema extends HttpSchema>(
     interceptor: HttpInterceptorClient<Schema>,
     method: HttpMethod,
-    url: string,
+    path: string,
     createResponse: MSWHttpResponseFactory,
   ): PossiblePromise<void>;
 
@@ -229,7 +229,7 @@ abstract class HttpInterceptorWorker {
 
   static async parseRawRequest<Path extends string, MethodSchema extends HttpMethodSchema>(
     originalRawRequest: Request,
-    options: { urlRegex?: RegExp } = {},
+    options?: { baseURL: string; pathPattern: RegExp },
   ): Promise<HttpInterceptorRequest<Path, MethodSchema>> {
     const rawRequest = originalRawRequest.clone();
     const rawRequestClone = rawRequest.clone();
@@ -240,7 +240,7 @@ abstract class HttpInterceptorWorker {
     type HeadersSchema = Default<Default<MethodSchema['request']>['headers']>;
     const headers = new HttpHeaders<HeadersSchema>(rawRequest.headers);
 
-    const pathParams = options.urlRegex ? this.parseRawPathParams<Path>(options.urlRegex, rawRequest) : {};
+    const pathParams = this.parseRawPathParams<Path>(rawRequest, options);
 
     const parsedURL = new URL(rawRequest.url);
     type SearchParamsSchema = Default<Default<MethodSchema['request']>['searchParams']>;
@@ -360,10 +360,12 @@ abstract class HttpInterceptorWorker {
     return HTTP_INTERCEPTOR_RESPONSE_HIDDEN_PROPERTIES.has(property as never);
   }
 
-  static parseRawPathParams<Path extends string>(matchedURLRegex: RegExp, request: Request): InferPathParams<Path> {
-    const match = request.url.match(matchedURLRegex);
-    const pathParams = { ...match?.groups };
-    return pathParams as InferPathParams<Path>;
+  static parseRawPathParams<Path extends string>(
+    request: Request,
+    options?: { baseURL: string; pathPattern: RegExp },
+  ): InferPathParams<Path> {
+    const match = options?.pathPattern.exec(request.url.replace(options.baseURL, ''));
+    return { ...match?.groups } as InferPathParams<Path>;
   }
 
   static async parseRawBody<Body extends HttpBody>(resource: Request | Response) {

package/src/http/interceptorWorker/LocalHttpInterceptorWorker.ts

@@ -1,6 +1,7 @@
 import { HttpRequest, HttpResponse, HttpMethod, HttpSchema } from '@zimic/http';
+import createParametrizedPathPattern from '@zimic/utils/url/createParametrizedPathPattern';
 import excludeURLParams from '@zimic/utils/url/excludeURLParams';
-import validateURLPathParams from '@zimic/utils/url/validateURLPathParams';
+import validatePathParams from '@zimic/utils/url/validatePathParams';
 import { SharedOptions as MSWWorkerSharedOptions, http, passthrough } from 'msw';
 import * as mswBrowser from 'msw/browser';
 import * as mswNode from 'msw/node';
@@ -10,29 +11,38 @@ import { isClientSide, isServerSide } from '@/utils/environment';
 
 import NotRunningHttpInterceptorError from '../interceptor/errors/NotRunningHttpInterceptorError';
 import UnknownHttpInterceptorPlatformError from '../interceptor/errors/UnknownHttpInterceptorPlatformError';
-import HttpInterceptorClient from '../interceptor/HttpInterceptorClient';
+import HttpInterceptorClient, { AnyHttpInterceptorClient } from '../interceptor/HttpInterceptorClient';
 import UnregisteredBrowserServiceWorkerError from './errors/UnregisteredBrowserServiceWorkerError';
 import HttpInterceptorWorker from './HttpInterceptorWorker';
-import { BrowserMSWWorker, MSWHandler, MSWHttpResponseFactory, MSWWorker, NodeMSWWorker } from './types/msw';
+import { HttpResponseFactoryContext } from './types/http';
+import { BrowserMSWWorker, MSWHttpResponseFactory, MSWWorker, NodeMSWWorker } from './types/msw';
 import { LocalHttpInterceptorWorkerOptions } from './types/options';
 
+interface HttpHandler {
+  baseURL: string;
+  method: HttpMethod;
+  pathPattern: RegExp;
+  interceptor: AnyHttpInterceptorClient;
+  createResponse: (context: HttpResponseFactoryContext) => Promise<Response>;
+}
+
 class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
   private internalWorker?: MSWWorker;
 
-  private defaultHttpHandler: MSWHandler;
-
-  private httpHandlerGroups: {
-    interceptor: HttpInterceptorClient<any>; // eslint-disable-line @typescript-eslint/no-explicit-any
-    httpHandler: MSWHandler;
-  }[] = [];
+  private httpHandlersByMethod: {
+    [Method in HttpMethod]: HttpHandler[];
+  } = {
+    GET: [],
+    POST: [],
+    PATCH: [],
+    PUT: [],
+    DELETE: [],
+    HEAD: [],
+    OPTIONS: [],
+  };
 
   constructor(_options: LocalHttpInterceptorWorkerOptions) {
     super();
-
-    this.defaultHttpHandler = http.all('*', async (context) => {
-      const request = context.request satisfies Request as HttpRequest;
-      return this.bypassOrRejectUnhandledRequest(request);
-    });
   }
 
   get type() {
@@ -52,13 +62,21 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
   }
 
   private createInternalWorker() {
+    const mswHttpHandler = http.all('*', async (context) => {
+      const request = context.request satisfies Request as HttpRequest;
+      const response = await this.createResponseForRequest(request);
+      return response;
+    });
+
     if (isServerSide() && 'setupServer' in mswNode) {
-      return mswNode.setupServer(this.defaultHttpHandler);
+      return mswNode.setupServer(mswHttpHandler);
     }
+
     /* istanbul ignore else -- @preserve */
     if (isClientSide() && 'setupWorker' in mswBrowser) {
-      return mswBrowser.setupWorker(this.defaultHttpHandler);
+      return mswBrowser.setupWorker(mswHttpHandler);
     }
+
     /* istanbul ignore next -- @preserve
      * Ignoring because checking unknown platforms is not configured in our test setup. */
     throw new UnknownHttpInterceptorPlatformError();
@@ -142,45 +160,79 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
   use<Schema extends HttpSchema>(
     interceptor: HttpInterceptorClient<Schema>,
     method: HttpMethod,
-    rawURL: string | URL,
+    path: string,
     createResponse: MSWHttpResponseFactory,
   ) {
-    const lowercaseMethod = method.toLowerCase<typeof method>();
+    if (!this.isRunning) {
+      throw new NotRunningHttpInterceptorError();
+    }
 
-    const url = new URL(rawURL);
-    excludeURLParams(url);
-    validateURLPathParams(url);
+    validatePathParams(path);
 
-    const httpHandler = http[lowercaseMethod](url.toString(), async (context) => {
-      const request = context.request as HttpRequest;
-      const requestClone = request.clone();
+    const methodHandlers = this.httpHandlersByMethod[method];
 
-      let response: HttpResponse | null = null;
+    const handler: HttpHandler = {
+      baseURL: interceptor.baseURLAsString,
+      method,
+      pathPattern: createParametrizedPathPattern(path),
+      interceptor,
+      createResponse: async (context) => {
+        const request = context.request as HttpRequest;
+        const requestClone = request.clone();
 
-      try {
-        response = await createResponse({ ...context, request });
-      } catch (error) {
-        console.error(error);
-      }
+        let response: HttpResponse | null = null;
+
+        try {
+          response = await createResponse({ ...context, request });
+        } catch (error) {
+          console.error(error);
+        }
+
+        if (!response) {
+          return this.bypassOrRejectUnhandledRequest(requestClone);
+        }
+
+        if (context.request.method === 'HEAD') {
+          return new Response(null, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+          });
+        }
+
+        return response;
+      },
+    };
 
-      if (!response) {
-        return this.bypassOrRejectUnhandledRequest(requestClone);
+    methodHandlers.push(handler);
+  }
+
+  private async createResponseForRequest(request: HttpRequest) {
+    const methodHandlers = this.httpHandlersByMethod[request.method as HttpMethod];
+
+    const requestURL = excludeURLParams(new URL(request.url));
+    const requestURLAsString = requestURL.href === `${requestURL.origin}/` ? requestURL.origin : requestURL.href;
+
+    for (let handlerIndex = methodHandlers.length - 1; handlerIndex >= 0; handlerIndex--) {
+      const handler = methodHandlers[handlerIndex];
+      const matchesBaseURL = requestURLAsString.startsWith(handler.baseURL);
+
+      if (!matchesBaseURL) {
+        continue;
       }
 
-      if (context.request.method === 'HEAD') {
-        return new Response(null, {
-          status: response.status,
-          statusText: response.statusText,
-          headers: response.headers,
-        });
+      const requestPath = requestURLAsString.replace(handler.baseURL, '');
+      const matchesPath = handler.pathPattern.test(requestPath);
+
+      if (!matchesPath) {
+        continue;
       }
 
+      const response = await handler.createResponse({ request });
       return response;
-    });
-
-    this.internalWorkerOrThrow.use(httpHandler);
+    }
 
-    this.httpHandlerGroups.push({ interceptor, httpHandler });
+    return this.bypassOrRejectUnhandledRequest(request);
   }
 
   private async bypassOrRejectUnhandledRequest(request: HttpRequest) {
@@ -198,22 +250,33 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
 
   clearHandlers() {
     this.internalWorkerOrThrow.resetHandlers();
-    this.httpHandlerGroups = [];
+
+    for (const handlers of Object.values(this.httpHandlersByMethod)) {
+      handlers.length = 0;
+    }
   }
 
   clearInterceptorHandlers<Schema extends HttpSchema>(interceptor: HttpInterceptorClient<Schema>) {
-    const groupToRemoveIndex = this.httpHandlerGroups.findIndex((group) => group.interceptor === interceptor);
-    removeArrayIndex(this.httpHandlerGroups, groupToRemoveIndex);
-
-    this.internalWorkerOrThrow.resetHandlers();
+    if (!this.isRunning) {
+      throw new NotRunningHttpInterceptorError();
+    }
 
-    for (const { httpHandler } of this.httpHandlerGroups) {
-      this.internalWorkerOrThrow.use(httpHandler);
+    for (const methodHandlers of Object.values(this.httpHandlersByMethod)) {
+      const groupToRemoveIndex = methodHandlers.findIndex((group) => group.interceptor === interceptor);
+      removeArrayIndex(methodHandlers, groupToRemoveIndex);
     }
   }
 
   get interceptorsWithHandlers() {
-    return this.httpHandlerGroups.map((group) => group.interceptor);
+    const interceptors = new Set<AnyHttpInterceptorClient>();
+
+    for (const handlers of Object.values(this.httpHandlersByMethod)) {
+      for (const handler of handlers) {
+        interceptors.add(handler.interceptor);
+      }
+    }
+
+    return Array.from(interceptors);
   }
 }
 

package/src/http/interceptorWorker/RemoteHttpInterceptorWorker.ts

@@ -1,6 +1,5 @@
-import { HttpResponse, HttpMethod, HttpSchema } from '@zimic/http';
-import excludeURLParams from '@zimic/utils/url/excludeURLParams';
-import validateURLPathParams from '@zimic/utils/url/validateURLPathParams';
+import { HttpMethod, HttpSchema } from '@zimic/http';
+import validatePathParams from '@zimic/utils/url/validatePathParams';
 
 import { HttpHandlerCommit, InterceptorServerWebSocketSchema } from '@/server/types/schema';
 import { importCrypto } from '@/utils/crypto';
@@ -14,15 +13,17 @@ import UnknownHttpInterceptorPlatformError from '../interceptor/errors/UnknownHt
 import HttpInterceptorClient, { AnyHttpInterceptorClient } from '../interceptor/HttpInterceptorClient';
 import { HttpInterceptorPlatform } from '../interceptor/types/options';
 import HttpInterceptorWorker from './HttpInterceptorWorker';
-import { MSWHttpResponseFactory, MSWHttpResponseFactoryContext } from './types/msw';
+import { HttpResponseFactoryContext } from './types/http';
+import { MSWHttpResponseFactory } from './types/msw';
 import { RemoteHttpInterceptorWorkerOptions } from './types/options';
 
 interface HttpHandler {
   id: string;
-  url: { base: string; full: string };
+  baseURL: string;
   method: HttpMethod;
+  path: string;
   interceptor: AnyHttpInterceptorClient;
-  createResponse: (context: MSWHttpResponseFactoryContext) => Promise<HttpResponse | null>;
+  createResponse: (context: HttpResponseFactoryContext) => Promise<Response | null>;
 }
 
 class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
@@ -132,26 +133,22 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
   async use<Schema extends HttpSchema>(
     interceptor: HttpInterceptorClient<Schema>,
     method: HttpMethod,
-    rawURL: string | URL,
+    path: string,
     createResponse: MSWHttpResponseFactory,
   ) {
     if (!this.isRunning) {
       throw new NotRunningHttpInterceptorError();
     }
 
-    const crypto = await importCrypto();
+    validatePathParams(path);
 
-    const url = new URL(rawURL);
-    excludeURLParams(url);
-    validateURLPathParams(url);
+    const crypto = await importCrypto();
 
     const handler: HttpHandler = {
       id: crypto.randomUUID(),
-      url: {
-        base: interceptor.baseURLAsString,
-        full: url.toString(),
-      },
+      baseURL: interceptor.baseURLAsString,
       method,
+      path,
       interceptor,
       async createResponse(context) {
         const response = await createResponse(context);
@@ -163,8 +160,9 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
 
     await this.webSocketClient.request('interceptors/workers/commit', {
       id: handler.id,
-      url: handler.url,
-      method,
+      baseURL: handler.baseURL,
+      method: handler.method,
+      path: handler.path,
     });
   }
 
@@ -194,8 +192,9 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     if (this.webSocketClient.isRunning) {
       const groupsToRecommit = Array.from<HttpHandler, HttpHandlerCommit>(this.httpHandlers.values(), (handler) => ({
         id: handler.id,
-        url: handler.url,
+        baseURL: handler.baseURL,
         method: handler.method,
+        path: handler.path,
       }));
 
       await this.webSocketClient.request('interceptors/workers/reset', groupsToRecommit);

package/src/http/interceptorWorker/types/http.ts

@@ -0,0 +1,5 @@
+import { HttpBody, HttpRequest } from '@zimic/http';
+
+export interface HttpResponseFactoryContext<Body extends HttpBody = HttpBody> {
+  request: HttpRequest<Body>;
+}

package/src/http/interceptorWorker/types/msw.ts

@@ -1,18 +1,16 @@
-import { HttpResponse, HttpBody, HttpRequest } from '@zimic/http';
+import { HttpResponse, HttpBody } from '@zimic/http';
 import { PossiblePromise } from '@zimic/utils/types';
 import type { HttpHandler as MSWHandler } from 'msw';
 import type { SetupWorker as BrowserMSWWorker } from 'msw/browser';
 import type { SetupServer as NodeMSWWorker } from 'msw/node';
 
+import { HttpResponseFactoryContext } from './http';
+
 export type { MSWHandler, NodeMSWWorker, BrowserMSWWorker };
 
 export type MSWWorker = NodeMSWWorker | BrowserMSWWorker;
 
-export interface MSWHttpResponseFactoryContext<Body extends HttpBody = HttpBody> {
-  request: HttpRequest<Body>;
-}
-
 export type MSWHttpResponseFactory<
   RequestBody extends HttpBody = HttpBody,
   ResponseBody extends HttpBody = HttpBody,
-> = (context: MSWHttpResponseFactoryContext<RequestBody>) => PossiblePromise<HttpResponse<ResponseBody> | null>;
+> = (context: HttpResponseFactoryContext<RequestBody>) => PossiblePromise<HttpResponse<ResponseBody> | null>;

package/src/server/InterceptorServer.ts

@@ -1,6 +1,6 @@
 import { normalizeNodeRequest, sendNodeResponse } from '@whatwg-node/server';
 import { HttpRequest, HttpMethod } from '@zimic/http';
-import createRegExpFromURL from '@zimic/utils/url/createRegExpFromURL';
+import createParametrizedPathPattern from '@zimic/utils/url/createParametrizedPathPattern';
 import excludeURLParams from '@zimic/utils/url/excludeURLParams';
 import { createServer, Server as HttpServer, IncomingMessage, ServerResponse } from 'http';
 import type { WebSocket as Socket } from 'isomorphic-ws';
@@ -29,10 +29,8 @@ import { getFetchAPI } from './utils/fetch';
 
 interface HttpHandler {
   id: string;
-  url: {
-    base: string;
-    fullRegex: RegExp;
-  };
+  baseURL: string;
+  pathPattern: RegExp;
   socket: Socket;
 }
 
@@ -45,7 +43,7 @@ class InterceptorServer implements PublicInterceptorServer {
   logUnhandledRequests: boolean;
   tokensDirectory?: string;
 
-  private httpHandlerGroups: {
+  private httpHandlersByMethod: {
     [Method in HttpMethod]: HttpHandler[];
   } = {
     GET: [],
@@ -218,18 +216,13 @@ class InterceptorServer implements PublicInterceptorServer {
     return {};
   };
 
-  private registerHttpHandler({ id, url, method }: HttpHandlerCommit, socket: Socket) {
-    const handlerGroups = this.httpHandlerGroups[method];
-
-    const fullURL = new URL(url.full);
-    excludeURLParams(fullURL);
+  private registerHttpHandler({ id, baseURL, method, path }: HttpHandlerCommit, socket: Socket) {
+    const handlerGroups = this.httpHandlersByMethod[method];
 
     handlerGroups.push({
       id,
-      url: {
-        base: url.base,
-        fullRegex: createRegExpFromURL(fullURL.toString()),
-      },
+      baseURL,
+      pathPattern: createParametrizedPathPattern(path),
       socket,
     });
   }
@@ -248,7 +241,7 @@ class InterceptorServer implements PublicInterceptorServer {
   }
 
   private removeHttpHandlersBySocket(socket: Socket) {
-    for (const handlerGroups of Object.values(this.httpHandlerGroups)) {
+    for (const handlerGroups of Object.values(this.httpHandlersByMethod)) {
       const socketIndex = handlerGroups.findIndex((handlerGroup) => handlerGroup.socket === socket);
       removeArrayIndex(handlerGroups, socketIndex);
     }
@@ -319,17 +312,25 @@ class InterceptorServer implements PublicInterceptorServer {
   };
 
   private async createResponseForRequest(request: SerializedHttpRequest) {
-    const methodHandlers = this.httpHandlerGroups[request.method as HttpMethod];
+    const methodHandlers = this.httpHandlersByMethod[request.method as HttpMethod];
 
-    const requestURL = excludeURLParams(new URL(request.url)).toString();
+    const requestURL = excludeURLParams(new URL(request.url));
+    const requestURLAsString = requestURL.href === `${requestURL.origin}/` ? requestURL.origin : requestURL.href;
 
     let matchedSomeInterceptor = false;
 
-    for (let index = methodHandlers.length - 1; index >= 0; index--) {
-      const handler = methodHandlers[index];
+    for (let handlerIndex = methodHandlers.length - 1; handlerIndex >= 0; handlerIndex--) {
+      const handler = methodHandlers[handlerIndex];
+      const matchesBaseURL = requestURLAsString.startsWith(handler.baseURL);
+
+      if (!matchesBaseURL) {
+        continue;
+      }
+
+      const requestPath = requestURLAsString.replace(handler.baseURL, '');
+      const matchesPath = handler.pathPattern.test(requestPath);
 
-      const matchesHandlerURL = handler.url.fullRegex.test(requestURL);
-      if (!matchesHandlerURL) {
+      if (!matchesPath) {
         continue;
       }
 
@@ -403,12 +404,9 @@ class InterceptorServer implements PublicInterceptorServer {
   }
 
   private findHttpHandlerByRequestBaseURL(request: HttpRequest) {
-    const methodHandlers = this.httpHandlerGroups[request.method as HttpMethod];
-
-    const handler = methodHandlers.findLast((handler) => {
-      return request.url.startsWith(handler.url.base);
-    });
+    const methodHandlers = this.httpHandlersByMethod[request.method as HttpMethod];
 
+    const handler = methodHandlers.findLast((handler) => request.url.startsWith(handler.baseURL));
     return handler;
   }
 }

package/src/server/types/schema.ts

@@ -5,8 +5,9 @@ import { WebSocketSchema } from '@/webSocket/types';
 
 export interface HttpHandlerCommit {
   id: string;
-  url: { base: string; full: string };
+  baseURL: string;
   method: HttpMethod;
+  path: string;
 }
 
 export type InterceptorServerWebSocketSchema = WebSocketSchema<{