msw 0.36.0 → 0.36.4

package/node/lib/index.js

@@ -2248,14 +2248,6 @@ function tryDecode(str, decode) {
   }
 }
 
-function uuidv4() {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = (Math.random() * 16) | 0;
-        const v = c == 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    });
-}
-
 /**
  * Parses a given value into a JSON.
  * Does not throw an exception on an invalid JSON string.
@@ -2934,10 +2926,8 @@ function setRequestCookies(request) {
  * Converts a given isomorphic request to a `MockedRequest` instance.
  */
 function parseIsomorphicRequest(request) {
-    const requestId = uuidv4();
-    request.headers.set('x-msw-request-id', requestId);
     const mockedRequest = {
-        id: requestId,
+        id: request.id,
         url: request.url,
         method: request.method,
         body: parseBody(request.body, request.headers),
@@ -7273,12 +7263,23 @@ function cleanUrl(path) {
     return path.replace(REDUNDANT_CHARACTERS_EXP, '');
 }
 
+/**
+ * Determines if the given URL string is an absolute URL.
+ */
+function isAbsoluteUrl(url) {
+    return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+}
+
 /**
  * Returns an absolute URL based on the given path.
  */
 function getAbsoluteUrl(path, baseUrl) {
-    // Ignore absolute URLs.
-    if (!path.startsWith('/')) {
+    // already absolute URL
+    if (isAbsoluteUrl(path)) {
+        return path;
+    }
+    // Ignore path with pattern start with *
+    if (path.startsWith('*')) {
         return path;
     }
     // Resolve a relative request URL against a given custom "baseUrl"
@@ -7312,18 +7313,31 @@ function normalizePath(path, baseUrl) {
  */
 function coercePath(path) {
     return (path
-        /**
-         * Escape the protocol so that "path-to-regexp" could match
-         * absolute URL.
-         * @see https://github.com/pillarjs/path-to-regexp/issues/259
-         */
-        .replace(/^([^\/]+)(:)(?=\/\/)/g, '$1\\$2')
         /**
          * Replace wildcards ("*") with unnamed capturing groups
          * because "path-to-regexp" doesn't support wildcards.
          * Ignore path parameter' modifiers (i.e. ":name*").
          */
-        .replace(/(?<!(^|\/|\*+):[\w]+)(\*{1,2})/g, '(.*)'));
+        .replace(/([:a-zA-Z_-]*)(\*{1,2})+/g, (_, parameterName, wildcard) => {
+        const expression = '(.*)';
+        if (!parameterName) {
+            return expression;
+        }
+        return parameterName.startsWith(':')
+            ? `${parameterName}${wildcard}`
+            : `${parameterName}${expression}`;
+    })
+        /**
+         * Escape the port so that "path-to-regexp" can match
+         * absolute URLs including port numbers.
+         */
+        .replace(/([^\/])(:)(?=\d+)/, '$1\\$2')
+        /**
+         * Escape the protocol so that "path-to-regexp" could match
+         * absolute URL.
+         * @see https://github.com/pillarjs/path-to-regexp/issues/259
+         */
+        .replace(/^([^\/]+)(:)(?=\/\/)/, '$1\\$2'));
 }
 /**
  * Returns the result of matching given request URL against a mask.
@@ -7583,7 +7597,6 @@ class RestHandler extends RequestHandler {
         const matchesMethod = this.info.method instanceof RegExp
             ? this.info.method.test(request.method)
             : isStringEqual(this.info.method, request.method);
-        // console.log({ request, matchesMethod, parsedResult })
         return matchesMethod && parsedResult.matches;
     }
     log(request, response) {
@@ -7716,10 +7729,10 @@ function groupHandlersByType(handlers) {
         graphql: [],
     });
 }
-function getScoreForRestHandler() {
+function getRestHandlerScore() {
     return (request, handler) => {
         const { path, method } = handler.info;
-        if (path instanceof RegExp) {
+        if (path instanceof RegExp || method instanceof RegExp) {
             return Infinity;
         }
         const hasSameMethod = isStringEqual(request.method, method);
@@ -7730,12 +7743,15 @@ function getScoreForRestHandler() {
         return score - methodScoreDelta;
     };
 }
-function getScoreForGraphQLHandler(parsedQuery) {
+function getGraphQLHandlerScore(parsedQuery) {
     return (_, handler) => {
         if (typeof parsedQuery.operationName === 'undefined') {
             return Infinity;
         }
         const { operationType, operationName } = handler.info;
+        if (typeof operationName !== 'string') {
+            return Infinity;
+        }
         const hasSameOperationType = parsedQuery.operationType === operationType;
         // Always treat a handler with the same operation type as a more similar one.
         const operationTypeScoreDelta = hasSameOperationType ? TYPE_MATCH_DELTA : 0;
@@ -7745,16 +7761,12 @@ function getScoreForGraphQLHandler(parsedQuery) {
 }
 function getSuggestedHandler(request, handlers, getScore) {
     const suggestedHandlers = handlers
-        .reduce((acc, handler) => {
+        .reduce((suggestions, handler) => {
         const score = getScore(request, handler);
-        return acc.concat([[score, handler]]);
+        return suggestions.concat([[score, handler]]);
     }, [])
-        .sort(([leftScore], [rightScore]) => {
-        return leftScore - rightScore;
-    })
-        .filter(([score]) => {
-        return score <= MAX_MATCH_SCORE;
-    })
+        .sort(([leftScore], [rightScore]) => leftScore - rightScore)
+        .filter(([score]) => score <= MAX_MATCH_SCORE)
         .slice(0, MAX_SUGGESTION_COUNT)
         .map(([, handler]) => handler);
     return suggestedHandlers;
@@ -7784,8 +7796,8 @@ function onUnhandledRequest(request, handlers, strategy = 'warn') {
         ? handlerGroups.graphql
         : handlerGroups.rest;
     const suggestedHandlers = getSuggestedHandler(request, relevantHandlers, parsedGraphQLQuery
-        ? getScoreForGraphQLHandler(parsedGraphQLQuery)
-        : getScoreForRestHandler());
+        ? getGraphQLHandlerScore(parsedGraphQLQuery)
+        : getRestHandlerScore());
     const handlerSuggestion = suggestedHandlers.length > 0
         ? getSuggestedHandlersMessage(suggestedHandlers)
         : '';
@@ -7808,7 +7820,7 @@ Read more: https://mswjs.io/docs/getting-started/mocks\
             // Print a developer-friendly error.
             devUtils.error('Error: %s', message);
             // Throw an exception to halt request processing and not perform the original request.
-            throw new Error('Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.');
+            throw new Error(devUtils.formatMessage('Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.'));
         }
         case 'warn': {
             devUtils.warn('Warning: %s', message);
@@ -7940,15 +7952,14 @@ function createSetupServer(...interceptors$1) {
             },
         });
         interceptor.on('response', (request, response) => {
-            const requestId = request.headers.get('x-msw-request-id');
-            if (!requestId) {
+            if (!request.id) {
                 return;
             }
             if (response.headers.get('x-powered-by') === 'msw') {
-                emitter.emit('response:mocked', response, requestId);
+                emitter.emit('response:mocked', response, request.id);
             }
             else {
-                emitter.emit('response:bypass', response, requestId);
+                emitter.emit('response:bypass', response, request.id);
             }
         });
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "0.36.0",
+  "version": "0.36.4",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "main": "lib/umd/index.js",
   "module": "lib/esm/index.js",