msw 0.44.1 → 0.46.0

package/lib/index.d.ts

@@ -1,5 +1,5 @@
-import { R as ResponseTransformer, s as status, a as set, d as delay, f as fetch, b as RequestHandler, S as SetupWorkerApi, D as DefaultContext, c as DefaultBodyType, M as MockedRequest, e as ResponseResolver, g as ResponseResolutionContext, h as SerializedResponse, i as RequestHandlerDefaultInfo, j as MockedResponse, k as ResponseLookupResult, l as SharedOptions, m as ServerLifecycleEventsMap } from './glossary-297d38ba.js';
-export { A as AsyncResponseResolverReturnType, c as DefaultBodyType, u as DefaultRequestMultipartBody, y as DelayMode, M as MockedRequest, H as MockedRequestInit, j as MockedResponse, z as RequestCache, E as RequestDestination, b as RequestHandler, B as RequestMode, F as RequestPriority, C as RequestRedirect, G as RequestReferrerPolicy, v as ResponseComposition, w as ResponseCompositionOptions, x as ResponseFunction, e as ResponseResolver, t as ResponseResolverReturnType, R as ResponseTransformer, S as SetupWorkerApi, l as SharedOptions, q as StartOptions, o as createResponseComposition, p as defaultContext, n as defaultResponse, r as response } from './glossary-297d38ba.js';
+import { R as ResponseTransformer, s as status, a as set, d as delay, f as fetch, b as RequestHandler, S as SetupWorkerApi, D as DefaultContext, c as DefaultBodyType, M as MockedRequest, e as ResponseResolver, g as ResponseResolutionContext, h as SerializedResponse, i as RequestHandlerDefaultInfo, j as MockedResponse, k as ResponseLookupResult, l as SharedOptions, m as ServerLifecycleEventsMap } from './glossary-c690f512.js';
+export { A as AsyncResponseResolverReturnType, c as DefaultBodyType, u as DefaultRequestMultipartBody, y as DelayMode, M as MockedRequest, H as MockedRequestInit, j as MockedResponse, z as RequestCache, E as RequestDestination, b as RequestHandler, B as RequestMode, F as RequestPriority, C as RequestRedirect, G as RequestReferrerPolicy, v as ResponseComposition, w as ResponseCompositionOptions, x as ResponseFunction, e as ResponseResolver, t as ResponseResolverReturnType, R as ResponseTransformer, S as SetupWorkerApi, l as SharedOptions, q as StartOptions, o as createResponseComposition, p as defaultContext, n as defaultResponse, r as response } from './glossary-c690f512.js';
 import * as cookieUtils from 'cookie';
 import { GraphQLError, OperationTypeNode, DocumentNode } from 'graphql';
 import { StrictEventEmitter } from 'strict-event-emitter';

package/lib/index.js

@@ -425,17 +425,15 @@ async function enableMocking(context, options) {
 }
 
 // src/setupWorker/start/utils/createMessageChannel.ts
-function createMessageChannel(event) {
-  const port = event.ports[0];
-  return {
-    send(message) {
-      if (!port) {
-        return;
-      }
-      port.postMessage(message);
-    }
-  };
-}
+var WorkerChannel = class {
+  constructor(port) {
+    this.port = port;
+  }
+  postMessage(event, ...rest2) {
+    const [data2, transfer] = rest2;
+    this.port.postMessage({ type: event, data: data2 }, { transfer });
+  }
+};
 
 // src/utils/NetworkError.ts
 var NetworkError = class extends Error {
@@ -677,9 +675,6 @@ var getResponse = async (request, handlers, resolutionContext) => {
 // src/utils/request/onUnhandledRequest.ts
 var import_js_levenshtein = __toESM(require("js-levenshtein"));
 
-// src/utils/internal/parseGraphQLRequest.ts
-var import_graphql = require("graphql");
-
 // src/utils/request/getPublicUrlFromRequest.ts
 var getPublicUrlFromRequest = (request) => {
   return request.referrer.startsWith(request.url.origin) ? request.url.pathname : new URL(request.url.pathname, `${request.url.protocol}//${request.url.host}`).href;
@@ -698,7 +693,8 @@ function parseDocumentNode(node) {
 }
 function parseQuery(query) {
   try {
-    const ast = (0, import_graphql.parse)(query);
+    const { parse: parse3 } = require("graphql");
+    const ast = parse3(query);
     return parseDocumentNode(ast);
   } catch (error2) {
     return error2;
@@ -1375,69 +1371,27 @@ async function handleRequest(request, handlers, options, emitter, handleRequestO
   return transformedResponse;
 }
 
-// src/setupWorker/start/utils/streamResponse.ts
-var import_outvariant3 = require("outvariant");
-async function streamResponse(operationChannel, messageChannel, mockedResponse) {
-  const response2 = new Response(mockedResponse.body, mockedResponse);
-  delete mockedResponse.body;
-  messageChannel.send({
-    type: "MOCK_RESPONSE_START",
-    payload: mockedResponse
-  });
-  (0, import_outvariant3.invariant)(response2.body, "Failed to stream mocked response with no body");
-  const reader = response2.body.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (!done) {
-      operationChannel.postMessage({
-        type: "MOCK_RESPONSE_CHUNK",
-        payload: value
-      });
-      continue;
-    }
-    operationChannel.postMessage({
-      type: "MOCK_RESPONSE_END"
-    });
-    operationChannel.close();
-    reader.releaseLock();
-    break;
-  }
-}
-
-// src/utils/internal/StrictBroadcastChannel.ts
-var ParentClass = typeof BroadcastChannel == "undefined" ? class UnsupportedEnvironment {
-  constructor() {
-    throw new Error("Cannot construct BroadcastChannel in a non-browser environment");
-  }
-} : BroadcastChannel;
-var StrictBroadcastChannel = class extends ParentClass {
-  postMessage(message) {
-    return super.postMessage(message);
-  }
-};
-
 // src/setupWorker/start/createRequestListener.ts
 var createRequestListener = (context, options) => {
   return async (event, message) => {
-    const messageChannel = createMessageChannel(event);
+    const messageChannel = new WorkerChannel(event.ports[0]);
+    const request = parseWorkerRequest(message.payload);
     try {
-      const request = parseWorkerRequest(message.payload);
-      const operationChannel = new StrictBroadcastChannel(`msw-response-stream-${request.id}`);
       await handleRequest(request, context.requestHandlers, options, context.emitter, {
         transformResponse,
         onPassthroughResponse() {
-          return messageChannel.send({
-            type: "MOCK_NOT_FOUND"
-          });
+          messageChannel.postMessage("NOT_FOUND");
         },
-        onMockedResponse(response2) {
-          if (response2.body == null) {
-            return messageChannel.send({
-              type: "MOCK_RESPONSE",
-              payload: response2
-            });
+        async onMockedResponse(response2) {
+          if (response2.body instanceof ReadableStream) {
+            throw new Error(devUtils.formatMessage('Failed to construct a mocked response with a "ReadableStream" body: mocked streams are not supported. Follow https://github.com/mswjs/msw/issues/1336 for more details.'));
           }
-          streamResponse(operationChannel, messageChannel, response2);
+          const responseInstance = new Response(response2.body, response2);
+          const responseBodyBuffer = await responseInstance.arrayBuffer();
+          const responseBody = response2.body == null ? null : responseBodyBuffer;
+          messageChannel.postMessage("MOCK_RESPONSE", __spreadProps(__spreadValues({}, response2), {
+            body: responseBody
+          }), [responseBodyBuffer]);
         },
         onMockedResponseSent(response2, { handler, publicRequest, parsedRequest }) {
           if (options.quiet) {
@@ -1448,25 +1402,29 @@ var createRequestListener = (context, options) => {
       });
     } catch (error2) {
       if (error2 instanceof NetworkError) {
-        return messageChannel.send({
-          type: "NETWORK_ERROR",
-          payload: {
-            name: error2.name,
-            message: error2.message
-          }
+        messageChannel.postMessage("NETWORK_ERROR", {
+          name: error2.name,
+          message: error2.message
         });
+        return;
       }
       if (error2 instanceof Error) {
-        messageChannel.send({
-          type: "INTERNAL_ERROR",
-          payload: {
-            status: 500,
-            body: JSON.stringify({
-              errorType: error2.constructor.name,
-              message: error2.message,
-              location: error2.stack
-            })
-          }
+        devUtils.error(`Uncaught exception in the request handler for "%s %s":
+
+%s
+
+This exception has been gracefully handled as a 500 response, however, it's strongly recommended to resolve this error, as it indicates a mistake in your code. If you wish to mock an error response, please see this guide: https://mswjs.io/docs/recipes/mocking-error-responses`, request.method, request.url, error2);
+        messageChannel.postMessage("MOCK_RESPONSE", {
+          status: 500,
+          statusText: "Request Handler Error",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            name: error2.name,
+            message: error2.message,
+            stack: error2.stack
+          })
         });
       }
     }
@@ -1486,8 +1444,8 @@ function transformResponse(response2) {
 async function requestIntegrityCheck(context, serviceWorker) {
   context.workerChannel.send("INTEGRITY_CHECK_REQUEST");
   const { payload: actualChecksum } = await context.events.once("INTEGRITY_CHECK_RESPONSE");
-  if (actualChecksum !== "df0d85222361310ecbe1792c606e08f2") {
-    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"df0d85222361310ecbe1792c606e08f2"}).`);
+  if (actualChecksum !== "b3066ef78c2f9090b4ce87e874965995") {
+    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"b3066ef78c2f9090b4ce87e874965995"}).`);
   }
   return serviceWorker;
 }
@@ -1735,6 +1693,13 @@ function pipeEvents(source, destination) {
   source.emit._isPiped = true;
 }
 
+// src/utils/internal/toReadonlyArray.ts
+function toReadonlyArray(source) {
+  const clone = [...source];
+  Object.freeze(clone);
+  return clone;
+}
+
 // src/setupWorker/setupWorker.ts
 var listeners = [];
 function setupWorker(...requestHandlers) {
@@ -1829,8 +1794,12 @@ function setupWorker(...requestHandlers) {
     resetHandlers(...nextHandlers) {
       context.requestHandlers = resetHandlers(requestHandlers, ...nextHandlers);
     },
+    listHandlers() {
+      return toReadonlyArray(context.requestHandlers);
+    },
     printHandlers() {
-      context.requestHandlers.forEach((handler) => {
+      const handlers = this.listHandlers();
+      handlers.forEach((handler) => {
         const { header, callFrame } = handler.info;
         const pragma = handler.info.hasOwnProperty("operationType") ? "[graphql]" : "[rest]";
         console.groupCollapsed(`${pragma} ${header}`);
@@ -1876,7 +1845,6 @@ var rest = {
 };
 
 // src/graphql.ts
-var import_graphql2 = require("graphql");
 function createScopedGraphQLHandler(operationType, url) {
   return (operationName, resolver) => {
     return new GraphQLHandler(operationType, operationName, url, resolver);
@@ -1889,14 +1857,14 @@ function createGraphQLOperationHandler(url) {
 }
 var standardGraphQLHandlers = {
   operation: createGraphQLOperationHandler("*"),
-  query: createScopedGraphQLHandler(import_graphql2.OperationTypeNode.QUERY, "*"),
-  mutation: createScopedGraphQLHandler(import_graphql2.OperationTypeNode.MUTATION, "*")
+  query: createScopedGraphQLHandler("query", "*"),
+  mutation: createScopedGraphQLHandler("mutation", "*")
 };
 function createGraphQLLink(url) {
   return {
     operation: createGraphQLOperationHandler(url),
-    query: createScopedGraphQLHandler(import_graphql2.OperationTypeNode.QUERY, url),
-    mutation: createScopedGraphQLHandler(import_graphql2.OperationTypeNode.MUTATION, url)
+    query: createScopedGraphQLHandler("query", url),
+    mutation: createScopedGraphQLHandler("mutation", url)
   };
 }
 var graphql = __spreadProps(__spreadValues({}, standardGraphQLHandlers), {