msw 0.20.5 → 0.21.3

package/lib/esm/{matchRequest-deps.js → matchRequestUrl-deps.js}

@@ -14,11 +14,21 @@ function jsonParse(str) {
 }
 
 /**
- * Returns a parsed JSON from a given valid body string,
- * otherwise returns a given body string as-is.
+ * Parses a given request/response body based on the `Content-Type` header.
  */
-function getJsonBody(body) {
-    return jsonParse(body) || body;
+function parseBody(body, headers) {
+    var _a;
+    if (body) {
+        // If the intercepted request's body has a JSON Content-Type
+        // parse it into an object, otherwise leave as-is.
+        const hasJsonContent = (_a = headers === null || headers === void 0 ? void 0 : headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('json');
+        if (hasJsonContent && typeof body !== 'object') {
+            return jsonParse(body) || body;
+        }
+        return body;
+    }
+    // Return whatever falsey body value is given.
+    return body;
 }
 
 /**
@@ -32,12 +42,10 @@ function prepareRequest(req) {
  * Formats a mocked response for introspection in browser's console.
  */
 function prepareResponse(res) {
-    var _a;
-    const resHeaders = lib.listToHeaders(res.headers);
+    const responseHeaders = 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 });
+        body: parseBody(res.body, responseHeaders) });
 }
 
 function getTimestamp() {
@@ -114,10 +122,10 @@ exports.getCleanUrl = getCleanUrl;
 });
 
 /**
- * Resolves a relative URL to the absolute URL with the same hostname.
+ * Returns an absolute URL based on the given relative URL, if possible.
  * Ignores regular expressions.
  */
-const resolveRelativeUrl = (mask) => {
+const getAbsoluteUrl = (mask) => {
     // Global `location` object doesn't exist in Node.
     // Relative request predicate URL cannot become absolute.
     const hasLocation = typeof location !== 'undefined';
@@ -128,17 +136,21 @@ const resolveRelativeUrl = (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) {
+function getUrlByMask(mask) {
+    /**
+     * If a string mask contains an asterisk (wildcard), return it as-is.
+     * Converting a URL-like path string into an actual URL is misleading.
+     * @see https://github.com/mswjs/msw/issues/357
+     */
+    if (mask instanceof RegExp || mask.includes('*')) {
         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));
+        return new URL(getAbsoluteUrl(mask));
     }
     catch (error) {
         // Otherwise, the mask is a path string.
@@ -151,7 +163,7 @@ function getCleanMask(resolvedMask) {
         ? getCleanUrl_1.getCleanUrl(resolvedMask)
         : resolvedMask instanceof RegExp
             ? resolvedMask
-            : resolveRelativeUrl(resolvedMask);
+            : getAbsoluteUrl(resolvedMask);
 }
 
 /**
@@ -159,10 +171,10 @@ function getCleanMask(resolvedMask) {
  * against a mask.
  */
 function matchRequestUrl(url, mask) {
-    const resolvedMask = resolveMask(mask);
+    const resolvedMask = getUrlByMask(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 };
+export { prepareRequest as a, prepareResponse as b, getTimestamp as c, getStatusCodeColor as d, getUrlByMask as g, jsonParse as j, matchRequestUrl as m, parseBody as p };

package/lib/esm/mockServiceWorker.js

@@ -7,7 +7,7 @@
 /* eslint-disable */
 /* tslint:disable */
 
-const INTEGRITY_CHECKSUM = 'ca2c3cd7453d8c614e2c19db63ede1a1'
+const INTEGRITY_CHECKSUM = 'd1e0e502f550d40a34bee90822e4bf98'
 const bypassHeaderName = 'x-msw-bypass'
 
 let clients = {}
@@ -27,6 +27,13 @@ self.addEventListener('message', async function (event) {
   const allClientIds = allClients.map((client) => client.id)
 
   switch (event.data) {
+    case 'KEEPALIVE_REQUEST': {
+      sendToClient(client, {
+        type: 'KEEPALIVE_RESPONSE',
+      })
+      break
+    }
+
     case 'INTEGRITY_CHECK_REQUEST': {
       sendToClient(client, {
         type: 'INTEGRITY_CHECK_RESPONSE',

package/lib/esm/rest-deps.js

@@ -1,13 +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 { 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.
- */
-function isStringEqual(actual, expected) {
-    return actual.toLowerCase() === expected.toLowerCase();
-}
+import { g as getUrlByMask, m as matchRequestUrl, a as prepareRequest, b as prepareResponse, c as getTimestamp, d as getStatusCodeColor } from './matchRequestUrl-deps.js';
 
 var punycode = createCommonjsModule(function (module, exports) {
 (function(root) {
@@ -1350,8 +1343,30 @@ Url.prototype.parseHost = function() {
   if (host) this.hostname = host;
 };
 
+/**
+ * Returns a relative URL if the given request URL is relative to the current origin.
+ * Otherwise returns an absolute URL.
+ */
+const getPublicUrlFromRequest = (request) => {
+    return request.referrer.startsWith(request.url.origin)
+        ? request.url.pathname
+        : format({
+            protocol: request.url.protocol,
+            host: request.url.host,
+            pathname: request.url.pathname,
+        });
+};
+
+/**
+ * Performs a case-insensitive comparison of two given strings.
+ */
+function isStringEqual(actual, expected) {
+    return actual.toLowerCase() === expected.toLowerCase();
+}
+
 var RESTMethods;
 (function (RESTMethods) {
+    RESTMethods["HEAD"] = "HEAD";
     RESTMethods["GET"] = "GET";
     RESTMethods["POST"] = "POST";
     RESTMethods["PUT"] = "PUT";
@@ -1372,7 +1387,7 @@ const restContext = {
 };
 const createRestHandler = (method) => {
     return (mask, resolver) => {
-        const resolvedMask = resolveMask(mask);
+        const resolvedMask = getUrlByMask(mask);
         return {
             parse(req) {
                 // Match the request during parsing to prevent matching it twice
@@ -1411,14 +1426,7 @@ ${queryParams
 })\
 `);
                 }
-                const isRelativeRequest = req.referrer.startsWith(req.url.origin);
-                const publicUrl = isRelativeRequest
-                    ? req.url.pathname
-                    : format({
-                        protocol: req.url.protocol,
-                        host: req.url.host,
-                        pathname: req.url.pathname,
-                    });
+                const publicUrl = getPublicUrlFromRequest(req);
                 const loggedRequest = prepareRequest(req);
                 const loggedResponse = prepareResponse(res);
                 console.groupCollapsed('[MSW] %s %s %s (%c%s%c)', getTimestamp(), req.method, publicUrl, `color:${getStatusCodeColor(res.status)}`, res.status, 'color:inherit');
@@ -1434,6 +1442,7 @@ ${queryParams
     };
 };
 const rest = {
+    head: createRestHandler(RESTMethods.HEAD),
     get: createRestHandler(RESTMethods.GET),
     post: createRestHandler(RESTMethods.POST),
     put: createRestHandler(RESTMethods.PUT),
@@ -1442,4 +1451,4 @@ const rest = {
     options: createRestHandler(RESTMethods.OPTIONS),
 };
 
-export { RESTMethods as R, restContext as a, isStringEqual as i, rest as r };
+export { RESTMethods as R, restContext as a, getPublicUrlFromRequest as g, isStringEqual as i, rest as r };

package/lib/esm/rest.js

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

package/lib/esm/xml-deps.js

@@ -218,7 +218,7 @@ const cookie = (name, value, options) => {
 /**
  * Sets the body of the response without any `Content-Type` header.
  * @example
- * res(body('foo'))
+ * res(body('message'))
  */
 const body = (value) => {
     return (res) => {
@@ -230,7 +230,7 @@ const body = (value) => {
 /**
  * Sets a given text as a "Cotent-Type: text/plain" body of the response.
  * @example
- * res(text('Message'))
+ * res(text('message'))
  */
 const text = (body) => {
     return (res) => {
@@ -243,7 +243,7 @@ const text = (body) => {
 /**
  * Sets the given XML as the body of the response.
  * @example
- * res(xml('<message>Foo</message>'))
+ * res(xml('<key>value</key>'))
  */
 const xml = (body) => {
     return (res) => {

package/lib/types/LiveStorage.d.ts

@@ -0,0 +1,17 @@
+export declare class LiveStorage<Value> {
+    name: string;
+    value: Value;
+    channel: BroadcastChannel;
+    constructor(name: string, initialValue: Value);
+    getValue: () => Value;
+    update: (applyUpdate: (prevValue: Value) => Value) => void;
+    private broadcastValue;
+    /**
+     * Flush the value into the presistency layer.
+     */
+    private persist;
+    /**
+     * Hydrate the value from the persistency layer.
+     */
+    private hydrate;
+}

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

@@ -2,6 +2,6 @@ import { ResponseTransformer } from '../response';
 /**
  * Sets the body of the response without any `Content-Type` header.
  * @example
- * res(body('foo'))
+ * res(body('message'))
  */
-export declare const body: <T>(value: T) => ResponseTransformer;
+export declare const body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => ResponseTransformer<BodyType>;

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

@@ -3,4 +3,6 @@ import { ResponseTransformer } from '../response';
 /**
  * Returns a list of GraphQL errors.
  */
-export declare const errors: (errorsList: Partial<GraphQLError>[]) => ResponseTransformer;
+export declare const errors: (errorsList: Partial<GraphQLError>[]) => ResponseTransformer<{
+    errors: Partial<GraphQLError>[];
+}>;

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

@@ -1,8 +1,8 @@
-import { MockedRequest } from '../handlers/requestHandler';
+import { MockedRequest } from '../utils/handlers/requestHandler';
 export declare const augmentRequestInit: (requestInit: RequestInit) => RequestInit;
 /**
  * Wrapper around the native `window.fetch()` function that performs
  * a request bypassing MSW. Requests performed using
  * this function will never be mocked.
  */
-export declare const fetch: <ResponseType_1 = any>(input: string | MockedRequest, requestInit?: RequestInit) => Promise<ResponseType_1>;
+export declare const fetch: (input: string | MockedRequest, requestInit?: RequestInit) => any;

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

@@ -1,7 +1,9 @@
 import { ResponseTransformer } from '../response';
 /**
- * Sets the given Object as the JSON body of the response.
+ * Sets the given value as the JSON body of the response.
  * @example
- * res(json({ foo: 'bar' }))
+ * res(json({ key: 'value' }))
+ * res(json('Some string'))
+ * res(json([1, '2', false, { ok: true }]))
  */
-export declare const json: (body: Record<string, any>) => ResponseTransformer;
+export declare const json: <BodyType>(body: BodyType) => ResponseTransformer<BodyType>;

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

@@ -2,6 +2,6 @@ import { ResponseTransformer } from '../response';
 /**
  * Sets a given text as a "Cotent-Type: text/plain" body of the response.
  * @example
- * res(text('Message'))
+ * res(text('message'))
  */
-export declare const text: (body: string) => ResponseTransformer;
+export declare const text: <BodyType extends string>(body: BodyType) => ResponseTransformer<BodyType>;

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

@@ -2,6 +2,6 @@ import { ResponseTransformer } from '../response';
 /**
  * Sets the given XML as the body of the response.
  * @example
- * res(xml('<message>Foo</message>'))
+ * res(xml('<key>value</key>'))
  */
-export declare const xml: (body: string) => ResponseTransformer;
+export declare const xml: <BodyType extends string>(body: BodyType) => ResponseTransformer<BodyType>;

package/lib/types/graphql.d.ts

@@ -1,5 +1,5 @@
 import { OperationTypeNode } from 'graphql';
-import { RequestHandler, MockedRequest, AsyncResponseResolverReturnType } from './handlers/requestHandler';
+import { RequestHandler, MockedRequest, AsyncResponseResolverReturnType } from './utils/handlers/requestHandler';
 import { MockedResponse, ResponseComposition } from './response';
 import { Mask } from './setupWorker/glossary';
 import { set } from './context/set';
@@ -27,23 +27,21 @@ export interface GraphQLRequestPayload<VariablesType> {
     query: string;
     variables?: VariablesType;
 }
-interface GraphQLRequestParsedResult<VariablesType> {
+export interface GraphQLRequestParsedResult<VariablesType> {
     operationType: OperationTypeNode;
     operationName: string | undefined;
     variables: VariablesType | undefined;
 }
-interface ParsedQueryPayload {
-    operationName: string | undefined;
-}
-export declare function parseQuery(query: string, definitionOperation?: OperationTypeNode): ParsedQueryPayload;
 declare const graphqlStandardHandlers: {
-    query: <QueryType, VariablesType = Record<string, any>>(expectedOperation: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType, VariablesType>) => RequestHandler<GraphQLMockedRequest<VariablesType>, GraphQLMockedContext<QueryType>, GraphQLRequestParsedResult<VariablesType>, GraphQLMockedRequest<VariablesType>>;
-    mutation: <QueryType, VariablesType = Record<string, any>>(expectedOperation: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType, VariablesType>) => RequestHandler<GraphQLMockedRequest<VariablesType>, GraphQLMockedContext<QueryType>, GraphQLRequestParsedResult<VariablesType>, GraphQLMockedRequest<VariablesType>>;
+    operation: <QueryType, VariablesType = Record<string, any>>(resolver: GraphQLResponseResolver<QueryType, VariablesType>) => RequestHandler<GraphQLMockedRequest<VariablesType>, GraphQLMockedContext<QueryType>, GraphQLRequestParsedResult<VariablesType>, GraphQLMockedRequest<VariablesType>, any>;
+    query: <QueryType_1, VariablesType_1 = Record<string, any>>(expectedOperationName: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType_1, VariablesType_1>) => RequestHandler<GraphQLMockedRequest<VariablesType_1>, GraphQLMockedContext<QueryType_1>, GraphQLRequestParsedResult<VariablesType_1>, GraphQLMockedRequest<VariablesType_1>, any>;
+    mutation: <QueryType_1, VariablesType_1 = Record<string, any>>(expectedOperationName: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType_1, VariablesType_1>) => RequestHandler<GraphQLMockedRequest<VariablesType_1>, GraphQLMockedContext<QueryType_1>, GraphQLRequestParsedResult<VariablesType_1>, GraphQLMockedRequest<VariablesType_1>, any>;
 };
 declare function createGraphQLLink(uri: Mask): typeof graphqlStandardHandlers;
 export declare const graphql: {
     link: typeof createGraphQLLink;
-    query: <QueryType, VariablesType = Record<string, any>>(expectedOperation: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType, VariablesType>) => RequestHandler<GraphQLMockedRequest<VariablesType>, GraphQLMockedContext<QueryType>, GraphQLRequestParsedResult<VariablesType>, GraphQLMockedRequest<VariablesType>>;
-    mutation: <QueryType, VariablesType = Record<string, any>>(expectedOperation: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType, VariablesType>) => RequestHandler<GraphQLMockedRequest<VariablesType>, GraphQLMockedContext<QueryType>, GraphQLRequestParsedResult<VariablesType>, GraphQLMockedRequest<VariablesType>>;
+    operation: <QueryType, VariablesType = Record<string, any>>(resolver: GraphQLResponseResolver<QueryType, VariablesType>) => RequestHandler<GraphQLMockedRequest<VariablesType>, GraphQLMockedContext<QueryType>, GraphQLRequestParsedResult<VariablesType>, GraphQLMockedRequest<VariablesType>, any>;
+    query: <QueryType_1, VariablesType_1 = Record<string, any>>(expectedOperationName: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType_1, VariablesType_1>) => RequestHandler<GraphQLMockedRequest<VariablesType_1>, GraphQLMockedContext<QueryType_1>, GraphQLRequestParsedResult<VariablesType_1>, GraphQLMockedRequest<VariablesType_1>, any>;
+    mutation: <QueryType_1, VariablesType_1 = Record<string, any>>(expectedOperationName: GraphQLRequestHandlerSelector, resolver: GraphQLResponseResolver<QueryType_1, VariablesType_1>) => RequestHandler<GraphQLMockedRequest<VariablesType_1>, GraphQLMockedContext<QueryType_1>, GraphQLRequestParsedResult<VariablesType_1>, GraphQLMockedRequest<VariablesType_1>, any>;
 };
 export {};

package/lib/types/index.d.ts

@@ -2,7 +2,7 @@ import * as context from './context';
 export { setupWorker } from './setupWorker/setupWorker';
 export { MockedResponse, ResponseTransformer, response } from './response';
 export { context };
-export { MockedRequest, RequestHandler, RequestParams, RequestQuery, ResponseResolver, ResponseResolverReturnType, AsyncResponseResolverReturnType, defaultContext, } from './handlers/requestHandler';
+export { MockedRequest, RequestHandler, RequestParams, RequestQuery, ResponseResolver, ResponseResolverReturnType, AsyncResponseResolverReturnType, defaultContext, } from './utils/handlers/requestHandler';
 export { rest, restContext, RESTMethods, ParsedRestRequest } from './rest';
-export { graphql, graphqlContext, GraphQLMockedRequest, GraphQLMockedContext, GraphQLRequestPayload, GraphQLResponseResolver, } from './graphql';
-export { matchRequestUrl } from './utils/matching/matchRequest';
+export { graphql, graphqlContext, GraphQLMockedRequest, GraphQLMockedContext, GraphQLRequestPayload, GraphQLResponseResolver, GraphQLRequestParsedResult, } from './graphql';
+export { matchRequestUrl } from './utils/matching/matchRequestUrl';

package/lib/types/native/index.d.ts

@@ -1 +1,7 @@
-export * from '../node';
+export declare const setupServer: (...requestHandlers: import("../setupWorker/glossary").RequestHandlersList) => {
+    listen(options?: import("../sharedOptions").SharedOptions | undefined): void;
+    use(...handlers: import("../setupWorker/glossary").RequestHandlersList): void;
+    restoreHandlers(): void;
+    resetHandlers(...nextHandlers: import("../setupWorker/glossary").RequestHandlersList): void;
+    close(): void;
+};

package/lib/types/node/createSetupServer.d.ts

@@ -0,0 +1,29 @@
+import { Interceptor } from 'node-request-interceptor';
+import { RequestHandlersList } from '../setupWorker/glossary';
+import { SharedOptions } from '../sharedOptions';
+/**
+ * Creates a `setupServer` API using given request interceptors.
+ * Useful to generate identical API using different patches to request issuing modules.
+ */
+export declare function createSetupServer(...interceptors: Interceptor[]): (...requestHandlers: RequestHandlersList) => {
+    /**
+     * Enables requests interception based on the previously provided mock definition.
+     */
+    listen(options?: SharedOptions | undefined): void;
+    /**
+     * Prepends given request handlers to the list of existing handlers.
+     */
+    use(...handlers: RequestHandlersList): void;
+    /**
+     * Marks all request handlers that respond using `res.once()` as unused.
+     */
+    restoreHandlers(): void;
+    /**
+     * Resets request handlers to the initial list given to the `setupServer` call, or to the explicit next request handlers list, if given.
+     */
+    resetHandlers(...nextHandlers: RequestHandlersList): void;
+    /**
+     * Stops requests interception by restoring all augmented modules.
+     */
+    close(): void;
+};

package/lib/types/node/setupServer.d.ts

@@ -1,27 +1,7 @@
-import { RequestHandlersList } from '../setupWorker/glossary';
-import { SharedOptions } from '../sharedOptions';
-/**
- * Sets up a server-side requests interception with the given mock definition.
- */
-export declare const setupServer: (...requestHandlers: RequestHandlersList) => {
-    /**
-     * Enables requests interception based on the previously provided mock definition.
-     */
-    listen(options?: SharedOptions | undefined): void;
-    /**
-     * Prepends given request handlers to the list of existing handlers.
-     */
-    use(...handlers: RequestHandlersList): void;
-    /**
-     * Marks all request handlers that respond using `res.once()` as unused.
-     */
+export declare const setupServer: (...requestHandlers: import("../setupWorker/glossary").RequestHandlersList) => {
+    listen(options?: import("../sharedOptions").SharedOptions | undefined): void;
+    use(...handlers: import("../setupWorker/glossary").RequestHandlersList): void;
     restoreHandlers(): void;
-    /**
-     * Resets request handlers to the initial list given to the `setupServer` call, or to the explicit next request handlers list, if given.
-     */
-    resetHandlers(...nextHandlers: RequestHandlersList): void;
-    /**
-     * Stops requests interception by restoring all augmented modules.
-     */
+    resetHandlers(...nextHandlers: import("../setupWorker/glossary").RequestHandlersList): void;
     close(): void;
 };

package/lib/types/response.d.ts

@@ -1,22 +1,25 @@
 import { Headers } from 'headers-utils';
-export interface MockedResponse {
-    body: any;
+export interface MockedResponse<BodyType = any> {
+    body: BodyType;
     status: number;
     statusText: string;
     headers: Headers;
     once: boolean;
     delay?: number;
 }
-export declare type ResponseTransformer = (res: MockedResponse) => MockedResponse;
-declare type ResponseFunction = (...transformers: ResponseTransformer[]) => MockedResponse;
-export declare type ResponseComposition = ResponseFunction & {
+export declare type ResponseTransformer<BodyType = any> = (res: MockedResponse<BodyType>) => MockedResponse<BodyType>;
+declare type ResponseFunction<BodyType = any> = (...transformers: ResponseTransformer<BodyType>[]) => MockedResponse<BodyType>;
+export declare type ResponseComposition<BodyType = any> = ResponseFunction<BodyType> & {
     /**
      * Respond using a given mocked response to the first captured request.
      * Does not affect any subsequent captured requests.
      */
-    once: ResponseFunction;
+    once: ResponseFunction<BodyType>;
     networkError: (message: string) => void;
 };
 export declare const defaultResponse: Omit<MockedResponse, 'headers'>;
-export declare const response: ResponseComposition;
+export declare const response: ResponseFunction<any> & {
+    once: ResponseFunction<any>;
+    networkError(message: string): never;
+};
 export {};