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

package/dist/http.js

@@ -958,16 +958,88 @@ var LocalHttpRequestHandler = class {
 };
 var LocalHttpRequestHandler_default = LocalHttpRequestHandler;
 
-// ../zimic-utils/dist/chunk-4RR2YNYT.mjs
-var URL_PATH_PARAM_REGEX = /\/:([^/]+)/g;
-function createRegExpFromURL(url) {
-  URL_PATH_PARAM_REGEX.lastIndex = 0;
-  const urlWithReplacedPathParams = encodeURI(url).replace(/([.()*?+$\\])/g, "\\$1").replace(URL_PATH_PARAM_REGEX, "/(?<$1>[^/]+)").replace(/^(\/)|(\/)$/g, "");
-  return new RegExp(`^(?:/)?${urlWithReplacedPathParams}(?:/)?$`);
+// ../zimic-utils/dist/chunk-7KDKOZM7.mjs
+function getExtraPatternsToEscape() {
+  return /([.(){}+$])/g;
 }
-__name(createRegExpFromURL, "createRegExpFromURL");
-__name2(createRegExpFromURL, "createRegExpFromURL");
-var createRegExpFromURL_default = createRegExpFromURL;
+__name(getExtraPatternsToEscape, "getExtraPatternsToEscape");
+__name2(getExtraPatternsToEscape, "getExtraPatternsToEscape");
+function getURIEncodedBackSlashPattern() {
+  return /%5C/g;
+}
+__name(getURIEncodedBackSlashPattern, "getURIEncodedBackSlashPattern");
+__name2(getURIEncodedBackSlashPattern, "getURIEncodedBackSlashPattern");
+function getPathParamPattern() {
+  return /(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)/gu;
+}
+__name(getPathParamPattern, "getPathParamPattern");
+__name2(getPathParamPattern, "getPathParamPattern");
+function getRepeatingPathParamPattern() {
+  return /(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)\\+/gu;
+}
+__name(getRepeatingPathParamPattern, "getRepeatingPathParamPattern");
+__name2(getRepeatingPathParamPattern, "getRepeatingPathParamPattern");
+function getOptionalPathParamPattern() {
+  return /(?<leadingSlash>\/)?(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)\?(?<trailingSlash>\/)?/gu;
+}
+__name(getOptionalPathParamPattern, "getOptionalPathParamPattern");
+__name2(getOptionalPathParamPattern, "getOptionalPathParamPattern");
+function getOptionalRepeatingPathParamPattern() {
+  return /(?<leadingSlash>\/)?(?<escape>\\)?:(?<identifier>[$_\p{ID_Start}][$\p{ID_Continue}]+)\*(?<trailingSlash>\/)?/gu;
+}
+__name(getOptionalRepeatingPathParamPattern, "getOptionalRepeatingPathParamPattern");
+__name2(getOptionalRepeatingPathParamPattern, "getOptionalRepeatingPathParamPattern");
+function createParametrizedPathPattern(path) {
+  const replacedURL = encodeURI(path).replace(/^\/+/g, "").replace(/\/+$/g, "").replace(getExtraPatternsToEscape(), "\\$1").replace(getURIEncodedBackSlashPattern(), "\\").replace(
+    getOptionalRepeatingPathParamPattern(),
+    (_match, leadingSlash, escape, identifier, trailingSlash) => {
+      if (escape) {
+        return `:${identifier}`;
+      }
+      const hasSegmentBeforePrefix = leadingSlash === "/";
+      const prefixExpression = hasSegmentBeforePrefix ? "/?" : leadingSlash;
+      const hasSegmentAfterSuffix = trailingSlash === "/";
+      const suffixExpression = hasSegmentAfterSuffix ? "/?" : trailingSlash;
+      if (prefixExpression && suffixExpression) {
+        return `(?:${prefixExpression}(?<${identifier}>.+?)?${suffixExpression})?`;
+      } else if (prefixExpression) {
+        return `(?:${prefixExpression}(?<${identifier}>.+?))?`;
+      } else if (suffixExpression) {
+        return `(?:(?<${identifier}>.+?)${suffixExpression})?`;
+      } else {
+        return `(?<${identifier}>.+?)?`;
+      }
+    }
+  ).replace(getRepeatingPathParamPattern(), (_match, escape, identifier) => {
+    return escape ? `:${identifier}` : `(?<${identifier}>.+)`;
+  }).replace(
+    getOptionalPathParamPattern(),
+    (_match, leadingSlash, escape, identifier, trailingSlash) => {
+      if (escape) {
+        return `:${identifier}`;
+      }
+      const hasNoSegmentBeforePrefix = leadingSlash === "/";
+      const prefixExpression = hasNoSegmentBeforePrefix ? "/?" : leadingSlash;
+      const hasNoSegmentAfterSuffix = trailingSlash === "/";
+      const suffixExpression = hasNoSegmentAfterSuffix ? "/?" : trailingSlash;
+      if (prefixExpression && suffixExpression) {
+        return `(?:${prefixExpression}(?<${identifier}>[^\\/]+?)?${suffixExpression})`;
+      } else if (prefixExpression) {
+        return `(?:${prefixExpression}(?<${identifier}>[^\\/]+?))?`;
+      } else if (suffixExpression) {
+        return `(?:(?<${identifier}>[^\\/]+?)${suffixExpression})?`;
+      } else {
+        return `(?<${identifier}>[^\\/]+?)?`;
+      }
+    }
+  ).replace(getPathParamPattern(), (_match, escape, identifier) => {
+    return escape ? `:${identifier}` : `(?<${identifier}>[^\\/]+?)`;
+  });
+  return new RegExp(`^/?${replacedURL}/?$`);
+}
+__name(createParametrizedPathPattern, "createParametrizedPathPattern");
+__name2(createParametrizedPathPattern, "createParametrizedPathPattern");
+var createParametrizedPathPattern_default = createParametrizedPathPattern;
 
 // ../zimic-utils/dist/url/excludeURLParams.mjs
 function excludeURLParams(url) {
@@ -981,25 +1053,6 @@ __name(excludeURLParams, "excludeURLParams");
 __name2(excludeURLParams, "excludeURLParams");
 var excludeURLParams_default = excludeURLParams;
 
-// ../zimic-utils/dist/url/joinURL.mjs
-function joinURL(...parts) {
-  return parts.map((part, index) => {
-    const isFirstPart = index === 0;
-    const isLastPart = index === parts.length - 1;
-    let partAsString = part.toString();
-    if (!isFirstPart) {
-      partAsString = partAsString.replace(/^\//, "");
-    }
-    if (!isLastPart) {
-      partAsString = partAsString.replace(/\/$/, "");
-    }
-    return partAsString;
-  }).filter((part) => part.length > 0).join("/");
-}
-__name(joinURL, "joinURL");
-__name2(joinURL, "joinURL");
-var joinURL_default = joinURL;
-
 // ../zimic-utils/dist/url/validateURLProtocol.mjs
 var UnsupportedURLProtocolError = class extends TypeError {
   static {
@@ -1198,12 +1251,12 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
       request
     );
   }
-  static async parseRawRequest(originalRawRequest, options = {}) {
+  static async parseRawRequest(originalRawRequest, options) {
     const rawRequest = originalRawRequest.clone();
     const rawRequestClone = rawRequest.clone();
     const parsedBody = await this.parseRawBody(rawRequest);
     const headers = new http.HttpHeaders(rawRequest.headers);
-    const pathParams = options.urlRegex ? this.parseRawPathParams(options.urlRegex, rawRequest) : {};
+    const pathParams = this.parseRawPathParams(rawRequest, options);
     const parsedURL = new URL(rawRequest.url);
     const searchParams = new http.HttpSearchParams(parsedURL.searchParams);
     const parsedRequest = new Proxy(rawRequest, {
@@ -1297,10 +1350,9 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
   static isHiddenResponseProperty(property) {
     return HTTP_INTERCEPTOR_RESPONSE_HIDDEN_PROPERTIES.has(property);
   }
-  static parseRawPathParams(matchedURLRegex, request) {
-    const match = request.url.match(matchedURLRegex);
-    const pathParams = { ...match?.groups };
-    return pathParams;
+  static parseRawPathParams(request, options) {
+    const match = options?.pathPattern.exec(request.url.replace(options.baseURL, ""));
+    return { ...match?.groups };
   }
   static async parseRawBody(resource) {
     const contentType = resource.headers.get("content-type");
@@ -1653,13 +1705,12 @@ var HttpInterceptorClient = class {
       return;
     }
     this.handlerClientsByMethod[handler.method].set(handler.path, handlerClients);
-    const url = joinURL_default(this.baseURLAsString, handler.path);
-    const urlRegex = createRegExpFromURL_default(url);
-    const registrationResult = this.workerOrThrow.use(this, handler.method, url, async (context) => {
+    const pathPattern = createParametrizedPathPattern_default(handler.path);
+    const registrationResult = this.workerOrThrow.use(this, handler.method, handler.path, async (context) => {
       const response = await this.handleInterceptedRequest(
-        urlRegex,
         handler.method,
         handler.path,
+        pathPattern,
         context
       );
       return response;
@@ -1668,9 +1719,10 @@ var HttpInterceptorClient = class {
       handler.registerSyncPromise(registrationResult);
     }
   }
-  async handleInterceptedRequest(matchedURLRegex, method, path, { request }) {
+  async handleInterceptedRequest(method, path, pathPattern, { request }) {
     const parsedRequest = await HttpInterceptorWorker_default.parseRawRequest(request, {
-      urlRegex: matchedURLRegex
+      baseURL: this.baseURLAsString,
+      pathPattern
     });
     const matchedHandler = await this.findMatchedHandler(method, path, parsedRequest);
     if (!matchedHandler) {
@@ -1742,7 +1794,7 @@ var HttpInterceptorClient = class {
 };
 var HttpInterceptorClient_default = HttpInterceptorClient;
 
-// ../zimic-utils/dist/url/validateURLPathParams.mjs
+// ../zimic-utils/dist/url/validatePathParams.mjs
 var DuplicatedPathParamError = class extends Error {
   static {
     __name(this, "DuplicatedPathParamError");
@@ -1750,41 +1802,46 @@ var DuplicatedPathParamError = class extends Error {
   static {
     __name2(this, "DuplicatedPathParamError");
   }
-  constructor(url, paramName) {
+  constructor(path, paramName) {
     super(
-      `The path parameter '${paramName}' appears more than once in the URL '${url.toString()}'. This is not supported. Please make sure that each parameter is unique.`
+      `The path parameter '${paramName}' appears more than once in '${path}'. This is not supported. Please make sure that each parameter is unique.`
     );
     this.name = "DuplicatedPathParamError";
   }
 };
-function validateURLPathParams(url) {
-  URL_PATH_PARAM_REGEX.lastIndex = 0;
-  const matches = url.toString().matchAll(URL_PATH_PARAM_REGEX);
+function validatePathParams(path) {
+  const pathParamMatches = path.toString().matchAll(getPathParamPattern());
   const uniqueParamNames = /* @__PURE__ */ new Set();
-  for (const match of matches) {
-    const paramName = match[1];
+  for (const paramMatch of pathParamMatches) {
+    const paramName = paramMatch.groups?.identifier;
+    if (!paramName) {
+      continue;
+    }
     if (uniqueParamNames.has(paramName)) {
-      throw new DuplicatedPathParamError(url, paramName);
+      throw new DuplicatedPathParamError(path, paramName);
     }
     uniqueParamNames.add(paramName);
   }
 }
-__name(validateURLPathParams, "validateURLPathParams");
-__name2(validateURLPathParams, "validateURLPathParams");
-var validateURLPathParams_default = validateURLPathParams;
+__name(validatePathParams, "validatePathParams");
+__name2(validatePathParams, "validatePathParams");
+var validatePathParams_default = validatePathParams;
 var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   static {
     __name(this, "LocalHttpInterceptorWorker");
   }
   internalWorker;
-  defaultHttpHandler;
-  httpHandlerGroups = [];
+  httpHandlersByMethod = {
+    GET: [],
+    POST: [],
+    PATCH: [],
+    PUT: [],
+    DELETE: [],
+    HEAD: [],
+    OPTIONS: []
+  };
   constructor(_options) {
     super();
-    this.defaultHttpHandler = msw.http.all("*", async (context) => {
-      const request = context.request;
-      return this.bypassOrRejectUnhandledRequest(request);
-    });
   }
   get type() {
     return "local";
@@ -1800,11 +1857,16 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     return this.internalWorker;
   }
   createInternalWorker() {
+    const mswHttpHandler = msw.http.all("*", async (context) => {
+      const request = context.request;
+      const response = await this.createResponseForRequest(request);
+      return response;
+    });
     if (isServerSide() && "setupServer" in mswNode__namespace) {
-      return mswNode__namespace.setupServer(this.defaultHttpHandler);
+      return mswNode__namespace.setupServer(mswHttpHandler);
     }
     if (isClientSide() && "setupWorker" in mswBrowser__namespace) {
-      return mswBrowser__namespace.setupWorker(this.defaultHttpHandler);
+      return mswBrowser__namespace.setupWorker(mswHttpHandler);
     }
     throw new UnknownHttpInterceptorPlatformError_default();
   }
@@ -1868,34 +1930,60 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   hasInternalNodeWorker() {
     return !this.hasInternalBrowserWorker();
   }
-  use(interceptor, method, rawURL, createResponse) {
-    const lowercaseMethod = method.toLowerCase();
-    const url = new URL(rawURL);
-    excludeURLParams_default(url);
-    validateURLPathParams_default(url);
-    const httpHandler = msw.http[lowercaseMethod](url.toString(), async (context) => {
-      const request = context.request;
-      const requestClone = request.clone();
-      let response = null;
-      try {
-        response = await createResponse({ ...context, request });
-      } catch (error) {
-        console.error(error);
-      }
-      if (!response) {
-        return this.bypassOrRejectUnhandledRequest(requestClone);
+  use(interceptor, method, path, createResponse) {
+    if (!this.isRunning) {
+      throw new NotRunningHttpInterceptorError_default();
+    }
+    validatePathParams_default(path);
+    const methodHandlers = this.httpHandlersByMethod[method];
+    const handler = {
+      baseURL: interceptor.baseURLAsString,
+      method,
+      pathPattern: createParametrizedPathPattern_default(path),
+      interceptor,
+      createResponse: /* @__PURE__ */ __name(async (context) => {
+        const request = context.request;
+        const requestClone = request.clone();
+        let response = 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;
+      }, "createResponse")
+    };
+    methodHandlers.push(handler);
+  }
+  async createResponseForRequest(request) {
+    const methodHandlers = this.httpHandlersByMethod[request.method];
+    const requestURL = excludeURLParams_default(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);
   }
   async bypassOrRejectUnhandledRequest(request) {
     const requestClone = request.clone();
@@ -1909,18 +1997,27 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   }
   clearHandlers() {
     this.internalWorkerOrThrow.resetHandlers();
-    this.httpHandlerGroups = [];
+    for (const handlers of Object.values(this.httpHandlersByMethod)) {
+      handlers.length = 0;
+    }
   }
   clearInterceptorHandlers(interceptor) {
-    const groupToRemoveIndex = this.httpHandlerGroups.findIndex((group) => group.interceptor === interceptor);
-    removeArrayIndex(this.httpHandlerGroups, groupToRemoveIndex);
-    this.internalWorkerOrThrow.resetHandlers();
-    for (const { httpHandler } of this.httpHandlerGroups) {
-      this.internalWorkerOrThrow.use(httpHandler);
+    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);
     }
   }
   get interceptorsWithHandlers() {
-    return this.httpHandlerGroups.map((group) => group.interceptor);
+    const interceptors = /* @__PURE__ */ new Set();
+    for (const handlers of Object.values(this.httpHandlersByMethod)) {
+      for (const handler of handlers) {
+        interceptors.add(handler.interceptor);
+      }
+    }
+    return Array.from(interceptors);
   }
 };
 var LocalHttpInterceptorWorker_default = LocalHttpInterceptorWorker;
@@ -2500,21 +2597,17 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
       this.isRunning = false;
     });
   }
-  async use(interceptor, method, rawURL, createResponse) {
+  async use(interceptor, method, path, createResponse) {
     if (!this.isRunning) {
       throw new NotRunningHttpInterceptorError_default();
     }
+    validatePathParams_default(path);
     const crypto = await importCrypto();
-    const url = new URL(rawURL);
-    excludeURLParams_default(url);
-    validateURLPathParams_default(url);
     const handler = {
       id: crypto.randomUUID(),
-      url: {
-        base: interceptor.baseURLAsString,
-        full: url.toString()
-      },
+      baseURL: interceptor.baseURLAsString,
       method,
+      path,
       interceptor,
       async createResponse(context) {
         const response = await createResponse(context);
@@ -2524,8 +2617,9 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     this.httpHandlers.set(handler.id, handler);
     await this.webSocketClient.request("interceptors/workers/commit", {
       id: handler.id,
-      url: handler.url,
-      method
+      baseURL: handler.baseURL,
+      method: handler.method,
+      path: handler.path
     });
   }
   async clearHandlers() {
@@ -2549,8 +2643,9 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     if (this.webSocketClient.isRunning) {
       const groupsToRecommit = Array.from(this.httpHandlers.values(), (handler) => ({
         id: handler.id,
-        url: handler.url,
-        method: handler.method
+        baseURL: handler.baseURL,
+        method: handler.method,
+        path: handler.path
       }));
       await this.webSocketClient.request("interceptors/workers/reset", groupsToRecommit);
     }