msw 0.20.1 → 0.20.5

package/lib/esm/fetch-deps.js

@@ -1,4 +1,4 @@
-var statuses = {
+var codes = {
 	"100": "Continue",
 	"101": "Switching Protocols",
 	"102": "Processing",
@@ -64,6 +64,11 @@ var statuses = {
 	"511": "Network Authentication Required"
 };
 
+var statuses = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  'default': codes
+});
+
 const status = (statusCode, statusText) => {
     return (res) => {
         res.status = statusCode;

package/lib/esm/graphql.js

@@ -1,6 +1,6 @@
 import { a as set, s as status, d as delay, f as fetch } from './fetch-deps.js';
 import { d as data, e as errors } from './errors-deps.js';
-import { j as jsonParse, p as prepareRequest, a as prepareResponse, b as getTimestamp, c as getStatusCodeColor } from './getStatusCodeColor-deps.js';
+import { j as jsonParse, m as matchRequestUrl, p as prepareRequest, a as prepareResponse, b as getTimestamp, c as getStatusCodeColor } from './matchRequest-deps.js';
 
 // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
 var nodejsCustomInspectSymbol = typeof Symbol === 'function' && typeof Symbol.for === 'function' ? Symbol.for('nodejs.util.inspect.custom') : undefined;
@@ -3015,11 +3015,12 @@ function parseQuery(query, definitionOperation = 'query') {
         operationName: (_a = operationDef === null || operationDef === void 0 ? void 0 : operationDef.name) === null || _a === void 0 ? void 0 : _a.value,
     };
 }
-const createGraphQLHandler = (operationType) => {
+const createGraphQLHandler = (operationType, mask) => {
     return (expectedOperation, resolver) => {
         return {
             resolver,
             parse(req) {
+                var _a;
                 // According to the GraphQL specification, a GraphQL request can be issued
                 // using both "GET" and "POST" methods.
                 switch (req.method) {
@@ -3040,7 +3041,7 @@ const createGraphQLHandler = (operationType) => {
                         };
                     }
                     case 'POST': {
-                        if (!req.body) {
+                        if (!((_a = req.body) === null || _a === void 0 ? void 0 : _a.query)) {
                             return null;
                         }
                         const { query, variables } = req.body;
@@ -3062,10 +3063,13 @@ const createGraphQLHandler = (operationType) => {
                 if (!parsed || !parsed.operationName) {
                     return false;
                 }
+                // Match the request URL against a given mask,
+                // in case of an endpoint-specific request handler.
+                const hasMatchingMask = matchRequestUrl(req.url, mask);
                 const isMatchingOperation = expectedOperation instanceof RegExp
                     ? expectedOperation.test(parsed.operationName)
                     : expectedOperation === parsed.operationName;
-                return isMatchingOperation;
+                return isMatchingOperation && hasMatchingMask.matches;
             },
             defineContext() {
                 return graphqlContext;
@@ -3087,9 +3091,16 @@ const createGraphQLHandler = (operationType) => {
         };
     };
 };
-const graphql = {
-    query: createGraphQLHandler('query'),
-    mutation: createGraphQLHandler('mutation'),
-};
+const graphqlStandardHandlers = {
+    query: createGraphQLHandler('query', '*'),
+    mutation: createGraphQLHandler('mutation', '*'),
+};
+function createGraphQLLink(uri) {
+    return {
+        query: createGraphQLHandler('query', uri),
+        mutation: createGraphQLHandler('mutation', uri),
+    };
+}
+const graphql = Object.assign(Object.assign({}, graphqlStandardHandlers), { link: createGraphQLLink });
 
 export { graphql, graphqlContext, parseQuery };

package/lib/esm/index-deps.js

@@ -1,5 +1,5 @@
 import { s as status, a as set, d as delay, f as fetch, j as json } from './fetch-deps.js';
-import { a as cookie, b as body, t as text, x as xml } from './xml-deps.js';
+import { c as cookie, b as body, t as text, x as xml } from './xml-deps.js';
 import { d as data, e as errors } from './errors-deps.js';
 
 var index = /*#__PURE__*/Object.freeze({

package/lib/esm/index.js

@@ -1,8 +1,9 @@
 import { c as createCommonjsModule, s as status, a as set, d as delay, f as fetch, l as lib$1, i as isNodeProcess } from './fetch-deps.js';
-import { c as cookie } from './xml-deps.js';
+import { p as parse_1 } from './xml-deps.js';
 import './errors-deps.js';
 export { i as context } from './index-deps.js';
-import { g as getJsonBody } from './getStatusCodeColor-deps.js';
+import { g as getJsonBody } from './matchRequest-deps.js';
+export { m as matchRequestUrl } from './matchRequest-deps.js';
 import { i as isStringEqual } from './rest-deps.js';
 export { R as RESTMethods, r as rest, a as restContext } from './rest-deps.js';
 export { graphql, graphqlContext } from './graphql.js';
@@ -59,11 +60,20 @@ exports.until = until.until;
 });
 
 /**
- * Attempts to resolve a Service Worker instance from any of its states:
- * active, installing, or waiting.
+ * Attempts to resolve a Service Worker instance from a given registration,
+ * regardless of its state (active, installing, waiting).
  */
-const getWorkerByRegistration = (registration) => {
-    return registration.active || registration.installing || registration.waiting;
+const getWorkerByRegistration = (registration, absoluteWorkerUrl) => {
+    const allStates = [
+        registration.active,
+        registration.installing,
+        registration.waiting,
+    ];
+    const existingStates = allStates.filter(Boolean);
+    const mockWorker = existingStates.find((worker) => {
+        return worker.scriptURL === absoluteWorkerUrl;
+    });
+    return mockWorker || null;
 };
 
 /**
@@ -84,9 +94,7 @@ const getWorkerInstance = (url, options) => __awaiter(void 0, void 0, void 0, fu
     const [, mockRegistrations] = yield lib.until(() => __awaiter(void 0, void 0, void 0, function* () {
         const registrations = yield navigator.serviceWorker.getRegistrations();
         return registrations.filter((registration) => {
-            const worker = getWorkerByRegistration(registration);
-            // Filter out other workers that can be associated with this page
-            return (worker === null || worker === void 0 ? void 0 : worker.scriptURL) === absoluteWorkerUrl;
+            return getWorkerByRegistration(registration, absoluteWorkerUrl);
         });
     }));
     if (!navigator.serviceWorker.controller && mockRegistrations.length > 0) {
@@ -98,21 +106,24 @@ const getWorkerInstance = (url, options) => __awaiter(void 0, void 0, void 0, fu
         // at this point we are sure it's hard reload that falls into this clause.
         location.reload();
     }
-    const [, existingRegistration] = yield lib.until(() => {
-        return navigator.serviceWorker.getRegistration(url);
-    });
+    const [existingRegistration] = mockRegistrations;
     if (existingRegistration) {
         // Update existing service worker to ensure it's up-to-date
         return existingRegistration.update().then(() => {
             return [
-                getWorkerByRegistration(existingRegistration),
+                getWorkerByRegistration(existingRegistration, absoluteWorkerUrl),
                 existingRegistration,
             ];
         });
     }
     const [error, instance] = yield lib.until(() => __awaiter(void 0, void 0, void 0, function* () {
         const registration = yield navigator.serviceWorker.register(url, options);
-        return [getWorkerByRegistration(registration), registration];
+        return [
+            // Compare existing worker registration by its worker URL,
+            // to prevent irrelevant workers to resolve here (such as Codesandbox worker).
+            getWorkerByRegistration(registration, absoluteWorkerUrl),
+            registration,
+        ];
     }));
     if (error) {
         const isWorkerMissing = error.message.includes('(404)');
@@ -219,49 +230,72 @@ const response = Object.assign(createResponseComposition(), {
  * Returns a mocked response for a given request using following request handlers.
  */
 const getResponse = (req, handlers) => __awaiter(void 0, void 0, void 0, function* () {
-    const [relevantHandler, parsedRequest] = handlers.reduce((found, requestHandler) => {
-        // Skip any request handlers lookup if a handler is already found,
-        // or the current handler is a one-time handler that's been already used.
-        if ((found && found[0]) || requestHandler.shouldSkip) {
-            return found;
-        }
+    const relevantHandlers = handlers
+        .filter((requestHandler) => {
+        // Skip a handler if it has been already used for a one-time response.
+        return !requestHandler.shouldSkip;
+    })
+        .map((requestHandler) => {
         // Parse the captured request to get additional information.
         // Make the predicate function accept all the necessary information
         // to decide on the interception.
         const parsedRequest = requestHandler.parse
             ? requestHandler.parse(req)
             : null;
-        if (requestHandler.predicate(req, parsedRequest)) {
-            return [requestHandler, parsedRequest];
-        }
-    }, []) || [null, null];
-    if (relevantHandler == null) {
+        return [requestHandler, parsedRequest];
+    })
+        .filter(([requestHandler, parsedRequest]) => {
+        return requestHandler.predicate(req, parsedRequest);
+    });
+    if (relevantHandlers.length == 0) {
+        // Handle a scenario when a request has no relevant request handlers.
+        // In that case it would be bypassed (performed as-is).
         return {
             handler: null,
             response: null,
         };
     }
-    const { getPublicRequest, defineContext, resolver } = relevantHandler;
-    const publicRequest = getPublicRequest
-        ? getPublicRequest(req, parsedRequest)
-        : req;
-    const context = defineContext ? defineContext(publicRequest) : defaultContext;
-    const mockedResponse = yield resolver(publicRequest, response, context);
-    // Handle a scenario when a request handler is present,
-    // but returns no mocked response (i.e. misses a `return res()` statement).
-    if (!mockedResponse) {
+    const { requestHandler, parsedRequest, mockedResponse, publicRequest, } = yield relevantHandlers.reduce((asyncAcc, [requestHandler, parsedRequest]) => __awaiter(void 0, void 0, void 0, function* () {
+        // Now the reduce function is async so we need to await if response was found
+        const acc = yield asyncAcc;
+        // If a first not empty response was found we'll stop evaluating other requests
+        if (acc.requestHandler) {
+            return acc;
+        }
+        const { getPublicRequest, defineContext, resolver } = requestHandler;
+        const publicRequest = getPublicRequest
+            ? getPublicRequest(req, parsedRequest)
+            : req;
+        const context = defineContext
+            ? defineContext(publicRequest)
+            : defaultContext;
+        const mockedResponse = yield resolver(publicRequest, response, context);
+        if (!mockedResponse) {
+            return acc;
+        }
+        if (mockedResponse && mockedResponse.once) {
+            // When responded with a one-time response, match the relevant request handler
+            // as skipped, so it cannot affect the captured requests anymore.
+            requestHandler.shouldSkip = true;
+        }
+        return {
+            requestHandler,
+            parsedRequest,
+            mockedResponse,
+            publicRequest,
+        };
+    }), Promise.resolve({ mockedResponse: null }));
+    // Although reducing a list of relevant request handlers, it's possible
+    // that in the end there will be no handler associted with the request
+    // (i.e. if relevant handlers are fall-through).
+    if (!requestHandler) {
         return {
-            handler: relevantHandler,
+            handler: null,
             response: null,
         };
     }
-    if (mockedResponse.once) {
-        // When responded with a one-time response, match the relevant request handler
-        // as skipped, so it cannot affect the captured requests anymore.
-        relevantHandler.shouldSkip = true;
-    }
     return {
-        handler: relevantHandler,
+        handler: requestHandler,
         response: mockedResponse,
         publicRequest,
         parsedRequest,
@@ -302,7 +336,7 @@ function parseRequestBody(body, headers) {
 }
 
 function getAllCookies() {
-    return cookie.parse(document.cookie);
+    return parse_1(document.cookie);
 }
 /**
  * Returns relevant document cookies based on the request `credentials` option.

package/lib/esm/index2.js

@@ -1,3 +1,3 @@
 export { d as delay, f as fetch, j as json, a as set, s as status } from './fetch-deps.js';
-export { b as body, a as cookie, t as text, x as xml } from './xml-deps.js';
+export { b as body, c as cookie, t as text, x as xml } from './xml-deps.js';
 export { d as data, e as errors } from './errors-deps.js';

package/lib/esm/matchRequest-deps.js

@@ -0,0 +1,168 @@
+import { l as lib, c as createCommonjsModule } from './fetch-deps.js';
+
+/**
+ * Parses a given string into a JSON.
+ * Does not throw an exception on an invalid JSON string.
+ */
+function jsonParse(str) {
+    try {
+        return JSON.parse(str);
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+
+/**
+ * Returns a parsed JSON from a given valid body string,
+ * otherwise returns a given body string as-is.
+ */
+function getJsonBody(body) {
+    return jsonParse(body) || body;
+}
+
+/**
+ * Formats a mocked request for introspection in browser's console.
+ */
+function prepareRequest(req) {
+    return Object.assign(Object.assign({}, req), { headers: req.headers.getAllHeaders() });
+}
+
+/**
+ * Formats a mocked response for introspection in browser's console.
+ */
+function prepareResponse(res) {
+    var _a;
+    const resHeaders = lib.listToHeaders(res.headers);
+    return Object.assign(Object.assign({}, res), { 
+        // Parse a response JSON body for preview in the logs
+        body: ((_a = resHeaders.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('json')) ? getJsonBody(res.body)
+            : res.body });
+}
+
+function getTimestamp() {
+    const now = new Date();
+    return [now.getHours(), now.getMinutes(), now.getSeconds()]
+        .map(String)
+        .map((chunk) => chunk.slice(0, 2))
+        .map((chunk) => chunk.padStart(2, '0'))
+        .join(':');
+}
+
+/**
+ * Returns a HEX color for a given response status code number.
+ */
+function getStatusCodeColor(status) {
+    if (status < 300) {
+        return '#69AB32';
+    }
+    if (status < 400) {
+        return '#F0BB4B';
+    }
+    return '#E95F5D';
+}
+
+/**
+ * Converts a string path to a Regular Expression.
+ * Transforms path parameters into named RegExp groups.
+ */
+const pathToRegExp = (path) => {
+    const pattern = path
+        // Escape literal dots
+        .replace(/\./g, '\\.')
+        // Escape literal slashes
+        .replace(/\//g, '/')
+        // Escape literal question marks
+        .replace(/\?/g, '\\?')
+        // Ignore trailing slashes
+        .replace(/\/+$/, '')
+        // Replace wildcard with any single character sequence
+        .replace(/\*+/g, '.+')
+        // Replace parameters with named capturing groups
+        .replace(/:([^\d|^\/][a-zA-Z0-9]*(?=(?:\/|\\.)|$))/g, (_, match) => `(?<${match}>.+?)`)
+        // Allow optional trailing slash
+        .concat('(\\/|$)');
+    return new RegExp(pattern, 'g');
+};
+
+/**
+ * Matches a given url against a path.
+ */
+const match = (path, url) => {
+    const expression = path instanceof RegExp ? path : pathToRegExp(path);
+    const match = expression.exec(url) || false;
+    // Matches in strict mode: match string should equal to input (url)
+    // Otherwise loose matches will be considered truthy:
+    // match('/messages/:id', '/messages/123/users') // true
+    const matches = path instanceof RegExp ? !!match : !!match && match[0] === match.input;
+    return {
+        matches,
+        params: match && matches ? match.groups || null : null,
+    };
+};
+
+var getCleanUrl_1 = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Removes query parameters and hashes from a given URL.
+ */
+function getCleanUrl(url, isAbsolute) {
+    if (isAbsolute === void 0) { isAbsolute = true; }
+    return [isAbsolute && url.origin, url.pathname].filter(Boolean).join('');
+}
+exports.getCleanUrl = getCleanUrl;
+});
+
+/**
+ * Resolves a relative URL to the absolute URL with the same hostname.
+ * Ignores regular expressions.
+ */
+const resolveRelativeUrl = (mask) => {
+    // Global `location` object doesn't exist in Node.
+    // Relative request predicate URL cannot become absolute.
+    const hasLocation = typeof location !== 'undefined';
+    return typeof mask === 'string' && mask.startsWith('/')
+        ? `${hasLocation ? location.origin : ''}${mask}`
+        : mask;
+};
+
+/**
+ * Converts a given request handler mask into a URL, if given a valid URL string.
+ * Otherwise, returns the mask as-is.
+ */
+function resolveMask(mask) {
+    if (mask instanceof RegExp) {
+        return mask;
+    }
+    try {
+        // Attempt to create a URL instance out of the mask string.
+        // Resolve mask to an absolute URL, because even a valid relative URL
+        // cannot be converted into the URL instance (required absolute URL only).
+        return new URL(resolveRelativeUrl(mask));
+    }
+    catch (error) {
+        // Otherwise, the mask is a path string.
+        return mask;
+    }
+}
+
+function getCleanMask(resolvedMask) {
+    return resolvedMask instanceof URL
+        ? getCleanUrl_1.getCleanUrl(resolvedMask)
+        : resolvedMask instanceof RegExp
+            ? resolvedMask
+            : resolveRelativeUrl(resolvedMask);
+}
+
+/**
+ * Returns the result of matching given request URL
+ * against a mask.
+ */
+function matchRequestUrl(url, mask) {
+    const resolvedMask = resolveMask(mask);
+    const cleanMask = getCleanMask(resolvedMask);
+    const cleanRequestUrl = getCleanUrl_1.getCleanUrl(url);
+    return match(cleanMask, cleanRequestUrl);
+}
+
+export { prepareResponse as a, getTimestamp as b, getStatusCodeColor as c, getJsonBody as g, jsonParse as j, matchRequestUrl as m, prepareRequest as p, resolveMask as r };

package/lib/esm/rest-deps.js

@@ -1,6 +1,6 @@
 import { c as createCommonjsModule, b as commonjsGlobal, a as set, s as status, j as json, d as delay, f as fetch } from './fetch-deps.js';
-import { a as cookie, b as body, t as text, x as xml } from './xml-deps.js';
-import { p as prepareRequest, a as prepareResponse, b as getTimestamp, c as getStatusCodeColor } from './getStatusCodeColor-deps.js';
+import { c as cookie, b as body, t as text, x as xml } from './xml-deps.js';
+import { r as resolveMask, m as matchRequestUrl, p as prepareRequest, a as prepareResponse, b as getTimestamp, c as getStatusCodeColor } from './matchRequest-deps.js';
 
 /**
  * Performs a case-insensitive comparison of two given strings.
@@ -1350,90 +1350,6 @@ Url.prototype.parseHost = function() {
   if (host) this.hostname = host;
 };
 
-/**
- * Converts a string path to a Regular Expression.
- * Transforms path parameters into named RegExp groups.
- */
-const pathToRegExp = (path) => {
-    const pattern = path
-        // Escape literal dots
-        .replace(/\./g, '\\.')
-        // Escape literal slashes
-        .replace(/\//g, '/')
-        // Escape literal question marks
-        .replace(/\?/g, '\\?')
-        // Ignore trailing slashes
-        .replace(/\/+$/, '')
-        // Replace wildcard with any single character sequence
-        .replace(/\*+/g, '.+')
-        // Replace parameters with named capturing groups
-        .replace(/:([^\d|^\/][a-zA-Z0-9]*(?=(?:\/|\\.)|$))/g, (_, match) => `(?<${match}>.+?)`)
-        // Allow optional trailing slash
-        .concat('(\\/|$)');
-    return new RegExp(pattern, 'g');
-};
-
-/**
- * Matches a given url against a path.
- */
-const match = (path, url) => {
-    const expression = path instanceof RegExp ? path : pathToRegExp(path);
-    const match = expression.exec(url) || false;
-    // Matches in strict mode: match string should equal to input (url)
-    // Otherwise loose matches will be considered truthy:
-    // match('/messages/:id', '/messages/123/users') // true
-    const matches = path instanceof RegExp ? !!match : !!match && match[0] === match.input;
-    return {
-        matches,
-        params: match && matches ? match.groups || null : null,
-    };
-};
-
-var getCleanUrl_1 = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Removes query parameters and hashes from a given URL.
- */
-function getCleanUrl(url, isAbsolute) {
-    if (isAbsolute === void 0) { isAbsolute = true; }
-    return [isAbsolute && url.origin, url.pathname].filter(Boolean).join('');
-}
-exports.getCleanUrl = getCleanUrl;
-});
-
-/**
- * Resolves a relative URL to the absolute URL with the same hostname.
- * Ignores regular expressions.
- */
-const resolveRelativeUrl = (mask) => {
-    // Global `location` object doesn't exist in Node.
-    // Relative request predicate URL cannot become absolute.
-    const hasLocation = typeof location !== 'undefined';
-    return typeof mask === 'string' && mask.startsWith('/')
-        ? `${hasLocation ? location.origin : ''}${mask}`
-        : mask;
-};
-
-/**
- * Converts a given request handler mask into a URL, if given a valid URL string.
- * Otherwise, returns the mask as-is.
- */
-function resolveMask(mask) {
-    if (mask instanceof RegExp) {
-        return mask;
-    }
-    try {
-        // Attempt to create a URL instance out of the mask string.
-        // Resolve mask to an absolute URL, because even a valid relative URL
-        // cannot be converted into the URL instance (required absolute URL only).
-        return new URL(resolveRelativeUrl(mask));
-    }
-    catch (error) {
-        // Otherwise, the mask is a path string.
-        return mask;
-    }
-}
-
 var RESTMethods;
 (function (RESTMethods) {
     RESTMethods["GET"] = "GET";
@@ -1457,24 +1373,21 @@ const restContext = {
 const createRestHandler = (method) => {
     return (mask, resolver) => {
         const resolvedMask = resolveMask(mask);
-        const cleanMask = resolvedMask instanceof URL
-            ? getCleanUrl_1.getCleanUrl(resolvedMask)
-            : resolvedMask instanceof RegExp
-                ? resolvedMask
-                : resolveRelativeUrl(resolvedMask);
         return {
-            predicate(req) {
-                // Ignore query parameters and hash when matching requests URI
-                const cleanUrl = getCleanUrl_1.getCleanUrl(req.url);
-                const hasSameMethod = isStringEqual(method, req.method);
-                const urlMatch = match(cleanMask, cleanUrl);
-                return hasSameMethod && urlMatch.matches;
+            parse(req) {
+                // Match the request during parsing to prevent matching it twice
+                // in order to get the request URL parameters.
+                const match = matchRequestUrl(req.url, mask);
+                return {
+                    match,
+                };
+            },
+            predicate(req, parsedRequest) {
+                return isStringEqual(method, req.method) && parsedRequest.match.matches;
             },
-            getPublicRequest(req) {
+            getPublicRequest(req, parsedRequest) {
                 // Get request path parameters based on the given mask
-                const params = (mask &&
-                    match(resolveRelativeUrl(mask), getCleanUrl_1.getCleanUrl(req.url)).params) ||
-                    {};
+                const params = (mask && parsedRequest.match.params) || {};
                 return Object.assign(Object.assign({}, req), { params });
             },
             resolver,

package/lib/esm/rest.js

@@ -1,4 +1,4 @@
 import './fetch-deps.js';
 import './xml-deps.js';
-import './getStatusCodeColor-deps.js';
+import './matchRequest-deps.js';
 export { R as RESTMethods, r as rest, a as restContext } from './rest-deps.js';

package/lib/esm/xml-deps.js

@@ -199,21 +199,18 @@ function tryDecode(str, decode) {
   }
 }
 
-var cookie = {
-	parse: parse_1,
-	serialize: serialize_1
-};
-
 /**
  * Sets a given cookie on the response.
  * @example
  * res(cookie('name', 'value'))
  */
-const cookie$1 = (name, value, options) => {
+const cookie = (name, value, options) => {
     return (res) => {
-        const serializedCookie = cookie.serialize(name, value, options);
+        const serializedCookie = serialize_1(name, value, options);
         res.headers.set('Set-Cookie', serializedCookie);
-        document.cookie = serializedCookie;
+        if (typeof document !== 'undefined') {
+            document.cookie = serializedCookie;
+        }
         return res;
     };
 };
@@ -256,4 +253,4 @@ const xml = (body) => {
     };
 };
 
-export { cookie$1 as a, body as b, cookie as c, text as t, xml as x };
+export { body as b, cookie as c, parse_1 as p, text as t, xml as x };

package/lib/types/context/cookie.d.ts

@@ -1,4 +1,4 @@
-import cookieUtils from 'cookie';
+import * as cookieUtils from 'cookie';
 import { ResponseTransformer } from '../response';
 /**
  * Sets a given cookie on the response.