msw 0.39.1 → 0.40.1

package/lib/umd/index.js

@@ -2004,6 +2004,12 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
       console.groupCollapsed(`%c${devUtils.formatMessage(message)}`, 'color:orangered;font-weight:bold;');
       console.log('%cDocumentation: %chttps://mswjs.io/docs', 'font-weight:bold', 'font-weight:normal');
       console.log('Found an issue? https://github.com/mswjs/msw/issues');
+      if (args.workerUrl) {
+          console.log('Worker script URL:', args.workerUrl);
+      }
+      if (args.workerScope) {
+          console.log('Worker scope:', args.workerScope);
+      }
       console.groupEnd();
   }
 
@@ -2011,10 +2017,22 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
    * Signals the worker to enable the interception of requests.
    */
   function enableMocking(context, options) {
+      var _a, _b;
       return __awaiter$3(this, void 0, void 0, function* () {
           context.workerChannel.send('MOCK_ACTIVATE');
-          return context.events.once('MOCKING_ENABLED').then(() => {
-              printStartMessage({ quiet: options.quiet });
+          yield context.events.once('MOCKING_ENABLED');
+          // Warn the developer on multiple "worker.start()" calls.
+          // While this will not affect the worker in any way,
+          // it likely indicates an issue with the developer's code.
+          if (context.isMockingEnabled) {
+              devUtils.warn(`Found a redundant "worker.start()" call. Note that starting the worker while mocking is already enabled will have no effect. Consider removing this "worker.start()" call.`);
+              return;
+          }
+          context.isMockingEnabled = true;
+          printStartMessage({
+              quiet: options.quiet,
+              workerScope: (_a = context.registration) === null || _a === void 0 ? void 0 : _a.scope,
+              workerUrl: (_b = context.worker) === null || _b === void 0 ? void 0 : _b.scriptURL,
           });
       });
   }
@@ -2044,6 +2062,196 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
       }
   }
 
+  /**
+   * Composes a given list of functions into a new function that
+   * executes from right to left.
+   */
+  function compose(...fns) {
+      return (...args) => {
+          return fns.reduceRight((leftFn, rightFn) => {
+              return leftFn instanceof Promise
+                  ? Promise.resolve(leftFn).then(rightFn)
+                  : rightFn(leftFn);
+          }, args[0]);
+      };
+  }
+
+  const defaultResponse = {
+      status: 200,
+      statusText: 'OK',
+      body: null,
+      delay: 0,
+      once: false,
+      passthrough: false,
+  };
+  const defaultResponseTransformers = [];
+  function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
+      return (...transformers) => __awaiter$3(this, void 0, void 0, function* () {
+          const initialResponse = Object.assign({}, defaultResponse, {
+              headers: new lib$7.Headers({
+                  'x-powered-by': 'msw',
+              }),
+          }, responseOverrides);
+          const resolvedTransformers = [
+              ...defaultTransformers,
+              ...transformers,
+          ].filter(Boolean);
+          const resolvedResponse = resolvedTransformers.length > 0
+              ? compose(...resolvedTransformers)(initialResponse)
+              : initialResponse;
+          return resolvedResponse;
+      });
+  }
+  const response = Object.assign(createResponseComposition(), {
+      once: createResponseComposition({ once: true }),
+      networkError(message) {
+          throw new NetworkError(message);
+      },
+  });
+
+  const BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
+  /**
+   * Return the stack trace frame of a function's invocation.
+   */
+  function getCallFrame(error) {
+      // In <IE11, new Error may return an undefined stack
+      const stack = error.stack;
+      if (!stack) {
+          return;
+      }
+      const frames = stack.split('\n').slice(1);
+      // Get the first frame that doesn't reference the library's internal trace.
+      // Assume that frame is the invocation frame.
+      const declarationFrame = frames.find((frame) => {
+          return !BUILD_FRAME.test(frame);
+      });
+      if (!declarationFrame) {
+          return;
+      }
+      // Extract file reference from the stack frame.
+      const declarationPath = declarationFrame
+          .replace(/\s*at [^()]*\(([^)]+)\)/, '$1')
+          .replace(/^@/, '');
+      return declarationPath;
+  }
+
+  /**
+   * Determines if the given function is an iterator.
+   */
+  function isIterable(fn) {
+      if (!fn) {
+          return false;
+      }
+      return typeof fn[Symbol.iterator] == 'function';
+  }
+
+  const defaultContext = {
+      status,
+      set,
+      delay,
+      fetch: fetch$1,
+  };
+  class RequestHandler {
+      constructor(options) {
+          this.shouldSkip = false;
+          this.ctx = options.ctx || defaultContext;
+          this.resolver = options.resolver;
+          const callFrame = getCallFrame(new Error());
+          this.info = Object.assign(Object.assign({}, options.info), { callFrame });
+      }
+      /**
+       * Parse the captured request to extract additional information from it.
+       * Parsed result is then exposed to other methods of this request handler.
+       */
+      parse(_request, _resolutionContext) {
+          return null;
+      }
+      /**
+       * Test if this handler matches the given request.
+       */
+      test(request, resolutionContext) {
+          return this.predicate(request, this.parse(request, resolutionContext), resolutionContext);
+      }
+      /**
+       * Derive the publicly exposed request (`req`) instance of the response resolver
+       * from the captured request and its parsed result.
+       */
+      getPublicRequest(request, _parsedResult) {
+          return request;
+      }
+      markAsSkipped(shouldSkip = true) {
+          this.shouldSkip = shouldSkip;
+      }
+      /**
+       * Execute this request handler and produce a mocked response
+       * using the given resolver function.
+       */
+      run(request, resolutionContext) {
+          return __awaiter$3(this, void 0, void 0, function* () {
+              if (this.shouldSkip) {
+                  return null;
+              }
+              const parsedResult = this.parse(request, resolutionContext);
+              const shouldIntercept = this.predicate(request, parsedResult, resolutionContext);
+              if (!shouldIntercept) {
+                  return null;
+              }
+              const publicRequest = this.getPublicRequest(request, parsedResult);
+              // Create a response extraction wrapper around the resolver
+              // since it can be both an async function and a generator.
+              const executeResolver = this.wrapResolver(this.resolver);
+              const mockedResponse = yield executeResolver(publicRequest, response, this.ctx);
+              return this.createExecutionResult(parsedResult, publicRequest, mockedResponse);
+          });
+      }
+      wrapResolver(resolver) {
+          return (req, res, ctx) => __awaiter$3(this, void 0, void 0, function* () {
+              const result = this.resolverGenerator || (yield resolver(req, res, ctx));
+              if (isIterable(result)) {
+                  const { value, done } = result[Symbol.iterator]().next();
+                  const nextResponse = yield value;
+                  // If the generator is done and there is no next value,
+                  // return the previous generator's value.
+                  if (!nextResponse && done) {
+                      return this.resolverGeneratorResult;
+                  }
+                  if (!this.resolverGenerator) {
+                      this.resolverGenerator = result;
+                  }
+                  this.resolverGeneratorResult = nextResponse;
+                  return nextResponse;
+              }
+              return result;
+          });
+      }
+      createExecutionResult(parsedResult, request, response) {
+          return {
+              handler: this,
+              parsedResult: parsedResult || null,
+              request,
+              response: response || null,
+          };
+      }
+  }
+  /**
+   * Bypass this intercepted request.
+   * This will make a call to the actual endpoint requested.
+   */
+  function passthrough() {
+      // Constructing a dummy "101 Continue" mocked response
+      // to keep the return type of the resolver consistent.
+      return {
+          status: 101,
+          statusText: 'Continue',
+          headers: new lib$7.Headers(),
+          body: null,
+          // Setting "passthrough" to true will signal the response pipeline
+          // to perform this intercepted request as-is.
+          passthrough: true,
+          once: false,
+      };
+  }
+
   var lib$2 = {};
 
   var CookieStore = {};
@@ -2463,13 +2671,36 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
       }
   }
 
+  /**
+   * Sets relevant cookies on the request.
+   * Request cookies are taken from the following sources:
+   * - Immediate (own) request cookies (those in the "Cookie" request header);
+   * - From the `document.cookie` based on the request's `credentials` value;
+   * - From the internal cookie store that persists/hydrates cookies in Node.js
+   */
   function setRequestCookies(request) {
       var _a;
+      // Set mocked request cookies from the `cookie` header of the original request.
+      // No need to take `credentials` into account, because in Node.js requests are intercepted
+      // _after_ they happen. Request issuer should have already taken care of sending relevant cookies.
+      // Unlike browser, where interception is on the worker level, _before_ the request happens.
+      const requestCookiesString = request.headers.get('cookie');
       lib$2.store.hydrate();
-      request.cookies = Object.assign(Object.assign({}, getRequestCookies(request)), Array.from((_a = lib$2.store.get(Object.assign(Object.assign({}, request), { url: request.url.toString() }))) === null || _a === void 0 ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => Object.assign(cookies, { [name]: value }), {}));
-      request.headers.set('cookie', Object.entries(request.cookies)
-          .map(([name, value]) => `${name}=${value}`)
-          .join('; '));
+      const cookiesFromStore = Array.from((_a = lib$2.store.get(Object.assign(Object.assign({}, request), { url: request.url.toString() }))) === null || _a === void 0 ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => {
+          return Object.assign(cookies, { [name.trim()]: value });
+      }, {});
+      const cookiesFromDocument = getRequestCookies(request);
+      const forwardedCookies = Object.assign(Object.assign({}, cookiesFromDocument), cookiesFromStore);
+      // Ensure the persisted (document) cookies are propagated to the request.
+      // Propagated the cookies persisted in the Cookuie Store to the request headers.
+      // This forwards relevant request cookies based on the request's credentials.
+      for (const [name, value] of Object.entries(forwardedCookies)) {
+          request.headers.append('cookie', `${name}=${value}`);
+      }
+      const ownCookies = requestCookiesString
+          ? parse_1(requestCookiesString)
+          : {};
+      request.cookies = Object.assign(Object.assign(Object.assign({}, request.cookies), forwardedCookies), ownCookies);
   }
 
   function parseContentHeaders(headersString) {
@@ -2612,6 +2843,7 @@ Invalid value has been removed from localStorage to prevent subsequent failed pa
           body: pruneGetRequestBody(rawRequest),
           bodyUsed: rawRequest.bodyUsed,
           headers: new lib$7.Headers(rawRequest.headers),
+          passthrough,
       };
       // Set document cookies on the request.
       setRequestCookies(request);
@@ -25807,177 +26039,6 @@ spurious results.`);
       };
   }
 
-  /**
-   * Composes a given list of functions into a new function that
-   * executes from right to left.
-   */
-  function compose(...fns) {
-      return (...args) => {
-          return fns.reduceRight((leftFn, rightFn) => {
-              return leftFn instanceof Promise
-                  ? Promise.resolve(leftFn).then(rightFn)
-                  : rightFn(leftFn);
-          }, args[0]);
-      };
-  }
-
-  const defaultResponse = {
-      status: 200,
-      statusText: 'OK',
-      body: null,
-      delay: 0,
-      once: false,
-  };
-  const defaultResponseTransformers = [];
-  function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
-      return (...transformers) => __awaiter$3(this, void 0, void 0, function* () {
-          const initialResponse = Object.assign({}, defaultResponse, {
-              headers: new lib$7.Headers({
-                  'x-powered-by': 'msw',
-              }),
-          }, responseOverrides);
-          const resolvedTransformers = [
-              ...defaultTransformers,
-              ...transformers,
-          ].filter(Boolean);
-          const resolvedResponse = resolvedTransformers.length > 0
-              ? compose(...resolvedTransformers)(initialResponse)
-              : initialResponse;
-          return resolvedResponse;
-      });
-  }
-  const response = Object.assign(createResponseComposition(), {
-      once: createResponseComposition({ once: true }),
-      networkError(message) {
-          throw new NetworkError(message);
-      },
-  });
-
-  const BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
-  /**
-   * Return the stack trace frame of a function's invocation.
-   */
-  function getCallFrame(error) {
-      // In <IE11, new Error may return an undefined stack
-      const stack = error.stack;
-      if (!stack) {
-          return;
-      }
-      const frames = stack.split('\n').slice(1);
-      // Get the first frame that doesn't reference the library's internal trace.
-      // Assume that frame is the invocation frame.
-      const declarationFrame = frames.find((frame) => {
-          return !BUILD_FRAME.test(frame);
-      });
-      if (!declarationFrame) {
-          return;
-      }
-      // Extract file reference from the stack frame.
-      const declarationPath = declarationFrame
-          .replace(/\s*at [^()]*\(([^)]+)\)/, '$1')
-          .replace(/^@/, '');
-      return declarationPath;
-  }
-
-  /**
-   * Determines if the given function is an iterator.
-   */
-  function isIterable(fn) {
-      if (!fn) {
-          return false;
-      }
-      return typeof fn[Symbol.iterator] == 'function';
-  }
-
-  const defaultContext = {
-      status,
-      set,
-      delay,
-      fetch: fetch$1,
-  };
-  class RequestHandler {
-      constructor(options) {
-          this.shouldSkip = false;
-          this.ctx = options.ctx || defaultContext;
-          this.resolver = options.resolver;
-          const callFrame = getCallFrame(new Error());
-          this.info = Object.assign(Object.assign({}, options.info), { callFrame });
-      }
-      /**
-       * Parse the captured request to extract additional information from it.
-       * Parsed result is then exposed to other methods of this request handler.
-       */
-      parse(_request, _resolutionContext) {
-          return null;
-      }
-      /**
-       * Test if this handler matches the given request.
-       */
-      test(request, resolutionContext) {
-          return this.predicate(request, this.parse(request, resolutionContext), resolutionContext);
-      }
-      /**
-       * Derive the publicly exposed request (`req`) instance of the response resolver
-       * from the captured request and its parsed result.
-       */
-      getPublicRequest(request, _parsedResult) {
-          return request;
-      }
-      markAsSkipped(shouldSkip = true) {
-          this.shouldSkip = shouldSkip;
-      }
-      /**
-       * Execute this request handler and produce a mocked response
-       * using the given resolver function.
-       */
-      run(request, resolutionContext) {
-          return __awaiter$3(this, void 0, void 0, function* () {
-              if (this.shouldSkip) {
-                  return null;
-              }
-              const parsedResult = this.parse(request, resolutionContext);
-              const shouldIntercept = this.predicate(request, parsedResult, resolutionContext);
-              if (!shouldIntercept) {
-                  return null;
-              }
-              const publicRequest = this.getPublicRequest(request, parsedResult);
-              // Create a response extraction wrapper around the resolver
-              // since it can be both an async function and a generator.
-              const executeResolver = this.wrapResolver(this.resolver);
-              const mockedResponse = yield executeResolver(publicRequest, response, this.ctx);
-              return this.createExecutionResult(parsedResult, publicRequest, mockedResponse);
-          });
-      }
-      wrapResolver(resolver) {
-          return (req, res, ctx) => __awaiter$3(this, void 0, void 0, function* () {
-              const result = this.resolverGenerator || (yield resolver(req, res, ctx));
-              if (isIterable(result)) {
-                  const { value, done } = result[Symbol.iterator]().next();
-                  const nextResponse = yield value;
-                  // If the generator is done and there is no next value,
-                  // return the previous generator's value.
-                  if (!nextResponse && done) {
-                      return this.resolverGeneratorResult;
-                  }
-                  if (!this.resolverGenerator) {
-                      this.resolverGenerator = result;
-                  }
-                  this.resolverGeneratorResult = nextResponse;
-                  return nextResponse;
-              }
-              return result;
-          });
-      }
-      createExecutionResult(parsedResult, request, response) {
-          return {
-              handler: this,
-              parsedResult: parsedResult || null,
-              request,
-              response: response || null,
-          };
-      }
-  }
-
   exports.RESTMethods = void 0;
   (function (RESTMethods) {
       RESTMethods["HEAD"] = "HEAD";
@@ -25988,17 +26049,11 @@ spurious results.`);
       RESTMethods["OPTIONS"] = "OPTIONS";
       RESTMethods["DELETE"] = "DELETE";
   })(exports.RESTMethods || (exports.RESTMethods = {}));
-  const restContext = {
-      set,
-      status,
-      cookie,
+  const restContext = Object.assign(Object.assign({}, defaultContext), { cookie,
       body,
       text,
       json,
-      xml,
-      delay,
-      fetch: fetch$1,
-  };
+      xml });
   /**
    * Request handler for REST API requests.
    * Provides request matching based on method and URL.
@@ -26069,16 +26124,10 @@ spurious results.`);
       }
   }
 
-  const graphqlContext = {
-      set,
-      status,
-      delay,
-      fetch: fetch$1,
-      data,
+  const graphqlContext = Object.assign(Object.assign({}, defaultContext), { data,
       extensions,
       errors,
-      cookie,
-  };
+      cookie });
   function isDocumentNode(value) {
       if (value == null) {
           return false;
@@ -26298,17 +26347,24 @@ Read more: https://mswjs.io/docs/getting-started/mocks\
   }
 
   function handleRequest(request, handlers, options, emitter, handleRequestOptions) {
-      var _a, _b, _c;
+      var _a, _b, _c, _d;
       return __awaiter$3(this, void 0, void 0, function* () {
           emitter.emit('request:start', request);
           // Perform bypassed requests (i.e. issued via "ctx.fetch") as-is.
           if (request.headers.get('x-msw-bypass') === 'true') {
               emitter.emit('request:end', request);
-              (_a = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onBypassResponse) === null || _a === void 0 ? void 0 : _a.call(handleRequestOptions, request);
+              (_a = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _a === void 0 ? void 0 : _a.call(handleRequestOptions, request);
               return;
           }
           // Resolve a mocked response from the list of request handlers.
-          const lookupResult = yield getResponse(request, handlers, handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.resolutionContext);
+          const [lookupError, lookupResult] = yield until(() => {
+              return getResponse(request, handlers, handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.resolutionContext);
+          });
+          if (lookupError) {
+              // Allow developers to react to unhandled exceptions in request handlers.
+              emitter.emit('unhandledException', lookupError, request);
+              throw lookupError;
+          }
           const { handler, response } = lookupResult;
           // When there's no handler for the request, consider it unhandled.
           // Allow the developer to react to such cases.
@@ -26316,7 +26372,7 @@ Read more: https://mswjs.io/docs/getting-started/mocks\
               onUnhandledRequest(request, handlers, options.onUnhandledRequest);
               emitter.emit('request:unhandled', request);
               emitter.emit('request:end', request);
-              (_b = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onBypassResponse) === null || _b === void 0 ? void 0 : _b.call(handleRequestOptions, request);
+              (_b = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _b === void 0 ? void 0 : _b.call(handleRequestOptions, request);
               return;
           }
           // When the handled request returned no mocked response, warn the developer,
@@ -26329,7 +26385,14 @@ Expected response resolver to return a mocked response Object, but got %s. The o
     %s\
 `, response, handler.info.header, handler.info.callFrame);
               emitter.emit('request:end', request);
-              (_c = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onBypassResponse) === null || _c === void 0 ? void 0 : _c.call(handleRequestOptions, request);
+              (_c = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _c === void 0 ? void 0 : _c.call(handleRequestOptions, request);
+              return;
+          }
+          // When the developer explicitly returned "req.passthrough()" do not warn them.
+          // Perform the request as-is.
+          if (response.passthrough) {
+              emitter.emit('request:end', request);
+              (_d = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _d === void 0 ? void 0 : _d.call(handleRequestOptions, request);
               return;
           }
           // Store all the received response cookies in the virtual cookie store.
@@ -26360,7 +26423,7 @@ Expected response resolver to return a mocked response Object, but got %s. The o
                   transformResponse(response) {
                       return Object.assign(Object.assign({}, response), { headers: response.headers.all() });
                   },
-                  onBypassResponse() {
+                  onPassthroughResponse() {
                       return channel.send({
                           type: 'MOCK_NOT_FOUND',
                       });
@@ -26582,12 +26645,19 @@ If this message still persists after updating, please report an issue: https://g
   const createStop = (context) => {
       return function stop() {
           var _a;
+          // Warn developers calling "worker.stop()" more times than necessary.
+          // This likely indicates a mistake in their code.
+          if (!context.isMockingEnabled) {
+              devUtils.warn('Found a redundant "worker.stop()" call. Note that stopping the worker while mocking already stopped has no effect. Consider removing this "worker.stop()" call.');
+              return;
+          }
           /**
            * Signal the Service Worker to disable mocking for this client.
            * Use this an an explicit way to stop the mocking, while preserving
            * the worker-client relation. Does not affect the worker's lifecycle.
            */
           context.workerChannel.send('MOCK_DEACTIVATE');
+          context.isMockingEnabled = false;
           window.clearInterval(context.keepAliveInterval);
           printStopMessage({ quiet: (_a = context.startOptions) === null || _a === void 0 ? void 0 : _a.quiet });
       };
@@ -31233,6 +31303,7 @@ If this message still persists after updating, please report an issue: https://g
           url: request.url,
           method: request.method,
           body: parseBody(request.body, request.headers),
+          credentials: request.credentials || 'same-origin',
           headers: request.headers,
           cookies: {},
           redirect: 'manual',
@@ -31244,21 +31315,10 @@ If this message still persists after updating, please report an issue: https://g
           integrity: '',
           destination: 'document',
           bodyUsed: false,
-          credentials: 'same-origin',
+          passthrough,
       };
-      // Set mocked request cookies from the `cookie` header of the original request.
-      // No need to take `credentials` into account, because in Node.js requests are intercepted
-      // _after_ they happen. Request issuer should have already taken care of sending relevant cookies.
-      // Unlike browser, where interception is on the worker level, _before_ the request happens.
-      const requestCookiesString = request.headers.get('cookie');
       // Attach all the cookies from the virtual cookie store.
       setRequestCookies(mockedRequest);
-      const requestCookies = requestCookiesString
-          ? parse_1(requestCookiesString)
-          : {};
-      // Merge both direct request cookies and the cookies inherited
-      // from other same-origin requests in the cookie store.
-      mockedRequest.cookies = Object.assign(Object.assign({}, mockedRequest.cookies), requestCookies);
       return mockedRequest;
   }
 
@@ -31350,6 +31410,9 @@ If this message still persists after updating, please report an issue: https://g
       const publicEmitter = new lib$5.StrictEventEmitter();
       pipeEvents(emitter, publicEmitter);
       const context = {
+          // Mocking is not considered enabled until the worker
+          // signals back the successful activation event.
+          isMockingEnabled: false,
           startOptions: undefined,
           worker: null,
           registration: null,

package/lib/umd/mockServiceWorker.js

@@ -2,7 +2,7 @@
 /* tslint:disable */
 
 /**
- * Mock Service Worker (0.39.1).
+ * Mock Service Worker (0.40.1).
  * @see https://github.com/mswjs/msw
  * - Please do NOT modify this file.
  * - Please do NOT serve this file on production.