msw 0.0.0-fetch.rc-14 → 0.0.0-fetch.rc-16

package/lib/core/{rest.js → http.js}

@@ -16,24 +16,24 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var rest_exports = {};
-__export(rest_exports, {
-  rest: () => rest
+var http_exports = {};
+__export(http_exports, {
+  http: () => http
 });
-module.exports = __toCommonJS(rest_exports);
-var import_RestHandler = require("./handlers/RestHandler.js");
-function createRestHandler(method) {
+module.exports = __toCommonJS(http_exports);
+var import_HttpHandler = require("./handlers/HttpHandler.js");
+function createHttpHandler(method) {
   return (path, resolver, options = {}) => {
-    return new import_RestHandler.RestHandler(method, path, resolver, options);
+    return new import_HttpHandler.HttpHandler(method, path, resolver, options);
   };
 }
-const rest = {
-  all: createRestHandler(/.+/),
-  head: createRestHandler(import_RestHandler.RESTMethods.HEAD),
-  get: createRestHandler(import_RestHandler.RESTMethods.GET),
-  post: createRestHandler(import_RestHandler.RESTMethods.POST),
-  put: createRestHandler(import_RestHandler.RESTMethods.PUT),
-  delete: createRestHandler(import_RestHandler.RESTMethods.DELETE),
-  patch: createRestHandler(import_RestHandler.RESTMethods.PATCH),
-  options: createRestHandler(import_RestHandler.RESTMethods.OPTIONS)
+const http = {
+  all: createHttpHandler(/.+/),
+  head: createHttpHandler(import_HttpHandler.HttpMethods.HEAD),
+  get: createHttpHandler(import_HttpHandler.HttpMethods.GET),
+  post: createHttpHandler(import_HttpHandler.HttpMethods.POST),
+  put: createHttpHandler(import_HttpHandler.HttpMethods.PUT),
+  delete: createHttpHandler(import_HttpHandler.HttpMethods.DELETE),
+  patch: createHttpHandler(import_HttpHandler.HttpMethods.PATCH),
+  options: createHttpHandler(import_HttpHandler.HttpMethods.OPTIONS)
 };

package/lib/core/http.mjs

@@ -0,0 +1,22 @@
+import {
+  HttpMethods,
+  HttpHandler
+} from './handlers/HttpHandler.mjs';
+function createHttpHandler(method) {
+  return (path, resolver, options = {}) => {
+    return new HttpHandler(method, path, resolver, options);
+  };
+}
+const http = {
+  all: createHttpHandler(/.+/),
+  head: createHttpHandler(HttpMethods.HEAD),
+  get: createHttpHandler(HttpMethods.GET),
+  post: createHttpHandler(HttpMethods.POST),
+  put: createHttpHandler(HttpMethods.PUT),
+  delete: createHttpHandler(HttpMethods.DELETE),
+  patch: createHttpHandler(HttpMethods.PATCH),
+  options: createHttpHandler(HttpMethods.OPTIONS)
+};
+export {
+  http
+};

package/lib/core/{rest.spec.js → http.spec.js}

@@ -1,8 +1,8 @@
 "use strict";
-var import_rest = require("./rest.js");
+var import_http = require("./http.js");
 test("exports all REST API methods", () => {
-  expect(import_rest.rest).toBeDefined();
-  expect(Object.keys(import_rest.rest)).toEqual([
+  expect(import_http.http).toBeDefined();
+  expect(Object.keys(import_http.http)).toEqual([
     "all",
     "head",
     "get",

package/lib/core/{rest.spec.mjs → http.spec.mjs}

@@ -1,7 +1,7 @@
-import { rest } from './rest.mjs';
+import { http } from './http.mjs';
 test("exports all REST API methods", () => {
-  expect(rest).toBeDefined();
-  expect(Object.keys(rest)).toEqual([
+  expect(http).toBeDefined();
+  expect(Object.keys(http)).toEqual([
     "all",
     "head",
     "get",

package/lib/core/index.d.ts

@@ -1,7 +1,7 @@
 export { SetupApi } from './SetupApi.js';
 export { A as AsyncResponseResolverReturnType, D as DefaultBodyType, c as DefaultRequestMultipartBody, e as HttpResponse, H as HttpResponseInit, R as RequestHandler, a as ResponseResolver, b as ResponseResolverReturnType, S as StrictRequest, d as StrictResponse } from './RequestHandler-e964183f.js';
-export { rest } from './rest.js';
-export { RESTMethods, RequestQuery, RestHandler, RestRequestParsedResult } from './handlers/RestHandler.js';
+export { http } from './http.js';
+export { HttpHandler, HttpMethods, HttpRequestParsedResult, RequestQuery } from './handlers/HttpHandler.js';
 export { graphql } from './graphql.js';
 export { G as GraphQLHandler, c as GraphQLJsonRequestBody, b as GraphQLRequestBody, a as GraphQLVariables, P as ParsedGraphQLRequest } from './GraphQLHandler-2e60cda6.js';
 export { Match, Path, PathParams, matchRequestUrl } from './utils/matching/matchRequestUrl.js';

package/lib/core/index.js

@@ -20,24 +20,24 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var core_exports = {};
 __export(core_exports, {
   GraphQLHandler: () => import_GraphQLHandler.GraphQLHandler,
+  HttpHandler: () => import_HttpHandler.HttpHandler,
+  HttpMethods: () => import_HttpHandler.HttpMethods,
   NetworkError: () => import_NetworkError.NetworkError,
-  RESTMethods: () => import_RestHandler.RESTMethods,
   RequestHandler: () => import_RequestHandler.RequestHandler,
-  RestHandler: () => import_RestHandler.RestHandler,
   SetupApi: () => import_SetupApi.SetupApi,
   bypass: () => import_bypass.bypass,
   cleanUrl: () => import_cleanUrl.cleanUrl,
   graphql: () => import_graphql.graphql,
+  http: () => import_http.http,
   matchRequestUrl: () => import_matchRequestUrl.matchRequestUrl,
-  passthrough: () => import_passthrough.passthrough,
-  rest: () => import_rest.rest
+  passthrough: () => import_passthrough.passthrough
 });
 module.exports = __toCommonJS(core_exports);
 var import_checkGlobals = require("./utils/internal/checkGlobals.js");
 var import_SetupApi = require("./SetupApi.js");
 var import_RequestHandler = require("./handlers/RequestHandler.js");
-var import_rest = require("./rest.js");
-var import_RestHandler = require("./handlers/RestHandler.js");
+var import_http = require("./http.js");
+var import_HttpHandler = require("./handlers/HttpHandler.js");
 var import_graphql = require("./graphql.js");
 var import_GraphQLHandler = require("./handlers/GraphQLHandler.js");
 var import_matchRequestUrl = require("./utils/matching/matchRequestUrl.js");

package/lib/core/index.mjs

@@ -1,8 +1,8 @@
 import { checkGlobals } from './utils/internal/checkGlobals.mjs';
 import { SetupApi } from './SetupApi.mjs';
 import { RequestHandler } from './handlers/RequestHandler.mjs';
-import { rest } from './rest.mjs';
-import { RestHandler, RESTMethods } from './handlers/RestHandler.mjs';
+import { http } from './http.mjs';
+import { HttpHandler, HttpMethods } from './handlers/HttpHandler.mjs';
 import { graphql } from './graphql.mjs';
 import { GraphQLHandler } from './handlers/GraphQLHandler.mjs';
 import { matchRequestUrl } from './utils/matching/matchRequestUrl.mjs';
@@ -16,15 +16,15 @@ import { NetworkError } from './NetworkError.mjs';
 checkGlobals();
 export {
   GraphQLHandler,
+  HttpHandler,
+  HttpMethods,
   NetworkError,
-  RESTMethods,
   RequestHandler,
-  RestHandler,
   SetupApi,
   bypass,
   cleanUrl,
   graphql,
+  http,
   matchRequestUrl,
-  passthrough,
-  rest
+  passthrough
 };

package/lib/core/passthrough.d.ts

@@ -1,9 +1,12 @@
 /**
- * Instruct Mock Service Worker to perform this request as-is.
+ * Performs the captured request as-is.
+ *
+ * This stops request handler lookup so no other handlers
+ * can affect this request past this point.
  * Unlike `bypass()`, this will not trigger an additional request.
  *
  * @example
- * rest.get('/user', () => {
+ * http.get('/resource', () => {
  *   return passthrough()
  * })
  */

package/lib/core/sharedOptions.d.ts

@@ -15,13 +15,51 @@ interface SharedOptions {
     onUnhandledRequest?: UnhandledRequestStrategy;
 }
 type LifeCycleEventsMap = {
-    'request:start': [request: Request, requestId: string];
-    'request:match': [request: Request, requestId: string];
-    'request:unhandled': [request: Request, requestId: string];
-    'request:end': [request: Request, requestId: string];
-    'response:mocked': [response: Response, request: Request, requestId: string];
-    'response:bypass': [response: Response, request: Request, requestId: string];
-    unhandledException: [error: Error, request: Request, requestId: string];
+    'request:start': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:match': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:unhandled': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:end': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'response:mocked': [
+        args: {
+            response: Response;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'response:bypass': [
+        args: {
+            response: Response;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    unhandledException: [
+        args: {
+            error: Error;
+            request: Request;
+            requestId: string;
+        }
+    ];
 };
 type LifeCycleEventEmitter<EventsMap extends Record<string | symbol, any>> = Pick<Emitter<EventsMap>, 'on' | 'removeListener' | 'removeAllListeners'>;
 

package/lib/core/utils/handleRequest.js

@@ -48,9 +48,9 @@ var import_readResponseCookies = require("./request/readResponseCookies.js");
 function handleRequest(request, requestId, handlers, options, emitter, handleRequestOptions) {
   return __async(this, null, function* () {
     var _a, _b, _c, _d, _e, _f;
-    emitter.emit("request:start", request, requestId);
+    emitter.emit("request:start", { request, requestId });
     if (request.headers.get("x-msw-intention") === "bypass") {
-      emitter.emit("request:end", request, requestId);
+      emitter.emit("request:end", { request, requestId });
       (_a = handleRequestOptions == null ? void 0 : handleRequestOptions.onPassthroughResponse) == null ? void 0 : _a.call(handleRequestOptions, request);
       return;
     }
@@ -62,30 +62,33 @@ function handleRequest(request, requestId, handlers, options, emitter, handleReq
       );
     });
     if (lookupResult.error) {
-      emitter.emit("unhandledException", lookupResult.error, request, requestId);
+      emitter.emit("unhandledException", {
+        error: lookupResult.error,
+        request,
+        requestId
+      });
       throw lookupResult.error;
     }
     if (!lookupResult.data) {
       yield (0, import_onUnhandledRequest.onUnhandledRequest)(request, handlers, options.onUnhandledRequest);
-      emitter.emit("request:unhandled", request, requestId);
-      emitter.emit("request:end", request, requestId);
+      emitter.emit("request:unhandled", { request, requestId });
+      emitter.emit("request:end", { request, requestId });
       (_b = handleRequestOptions == null ? void 0 : handleRequestOptions.onPassthroughResponse) == null ? void 0 : _b.call(handleRequestOptions, request);
       return;
     }
     const { response } = lookupResult.data;
     if (!response) {
-      emitter.emit("request:end", request, requestId);
+      emitter.emit("request:end", { request, requestId });
       (_c = handleRequestOptions == null ? void 0 : handleRequestOptions.onPassthroughResponse) == null ? void 0 : _c.call(handleRequestOptions, request);
       return;
     }
     if (response.status === 302 && response.headers.get("x-msw-intention") === "passthrough") {
-      emitter.emit("request:end", request, requestId);
+      emitter.emit("request:end", { request, requestId });
       (_d = handleRequestOptions == null ? void 0 : handleRequestOptions.onPassthroughResponse) == null ? void 0 : _d.call(handleRequestOptions, request);
       return;
     }
-    response.headers.set("x-powered-by", "msw");
     (0, import_readResponseCookies.readResponseCookies)(request, response);
-    emitter.emit("request:match", request, requestId);
+    emitter.emit("request:match", { request, requestId });
     const requiredLookupResult = lookupResult.data;
     const transformedResponse = ((_e = handleRequestOptions == null ? void 0 : handleRequestOptions.transformResponse) == null ? void 0 : _e.call(handleRequestOptions, response)) || response;
     (_f = handleRequestOptions == null ? void 0 : handleRequestOptions.onMockedResponse) == null ? void 0 : _f.call(
@@ -93,7 +96,7 @@ function handleRequest(request, requestId, handlers, options, emitter, handleReq
       transformedResponse,
       requiredLookupResult
     );
-    emitter.emit("request:end", request, requestId);
+    emitter.emit("request:end", { request, requestId });
     return transformedResponse;
   });
 }

package/lib/core/utils/handleRequest.mjs

@@ -25,9 +25,9 @@ import { readResponseCookies } from './request/readResponseCookies.mjs';
 function handleRequest(request, requestId, handlers, options, emitter, handleRequestOptions) {
   return __async(this, null, function* () {
     var _a, _b, _c, _d, _e, _f;
-    emitter.emit("request:start", request, requestId);
+    emitter.emit("request:start", { request, requestId });
     if (request.headers.get("x-msw-intention") === "bypass") {
-      emitter.emit("request:end", request, requestId);
+      emitter.emit("request:end", { request, requestId });
       (_a = handleRequestOptions == null ? void 0 : handleRequestOptions.onPassthroughResponse) == null ? void 0 : _a.call(handleRequestOptions, request);
       return;
     }
@@ -39,30 +39,33 @@ function handleRequest(request, requestId, handlers, options, emitter, handleReq
       );
     });
     if (lookupResult.error) {
-      emitter.emit("unhandledException", lookupResult.error, request, requestId);
+      emitter.emit("unhandledException", {
+        error: lookupResult.error,
+        request,
+        requestId
+      });
       throw lookupResult.error;
     }
     if (!lookupResult.data) {
       yield onUnhandledRequest(request, handlers, options.onUnhandledRequest);
-      emitter.emit("request:unhandled", request, requestId);
-      emitter.emit("request:end", request, requestId);
+      emitter.emit("request:unhandled", { request, requestId });
+      emitter.emit("request:end", { request, requestId });
       (_b = handleRequestOptions == null ? void 0 : handleRequestOptions.onPassthroughResponse) == null ? void 0 : _b.call(handleRequestOptions, request);
       return;
     }
     const { response } = lookupResult.data;
     if (!response) {
-      emitter.emit("request:end", request, requestId);
+      emitter.emit("request:end", { request, requestId });
       (_c = handleRequestOptions == null ? void 0 : handleRequestOptions.onPassthroughResponse) == null ? void 0 : _c.call(handleRequestOptions, request);
       return;
     }
     if (response.status === 302 && response.headers.get("x-msw-intention") === "passthrough") {
-      emitter.emit("request:end", request, requestId);
+      emitter.emit("request:end", { request, requestId });
       (_d = handleRequestOptions == null ? void 0 : handleRequestOptions.onPassthroughResponse) == null ? void 0 : _d.call(handleRequestOptions, request);
       return;
     }
-    response.headers.set("x-powered-by", "msw");
     readResponseCookies(request, response);
-    emitter.emit("request:match", request, requestId);
+    emitter.emit("request:match", { request, requestId });
     const requiredLookupResult = lookupResult.data;
     const transformedResponse = ((_e = handleRequestOptions == null ? void 0 : handleRequestOptions.transformResponse) == null ? void 0 : _e.call(handleRequestOptions, response)) || response;
     (_f = handleRequestOptions == null ? void 0 : handleRequestOptions.onMockedResponse) == null ? void 0 : _f.call(
@@ -70,7 +73,7 @@ function handleRequest(request, requestId, handlers, options, emitter, handleReq
       transformedResponse,
       requiredLookupResult
     );
-    emitter.emit("request:end", request, requestId);
+    emitter.emit("request:end", { request, requestId });
     return transformedResponse;
   });
 }

package/lib/core/utils/logging/serializeResponse.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -41,14 +51,18 @@ __export(serializeResponse_exports, {
   serializeResponse: () => serializeResponse
 });
 module.exports = __toCommonJS(serializeResponse_exports);
+var import_statuses = __toESM(require("@bundled-es-modules/statuses"));
 var import_headers_polyfill = require("headers-polyfill");
+const { message } = import_statuses.default;
 function serializeResponse(response) {
   return __async(this, null, function* () {
     const responseClone = response.clone();
     const responseText = yield responseClone.text();
+    const responseStatus = responseClone.status || 200;
+    const responseStatusText = responseClone.statusText || message[responseStatus] || "OK";
     return {
-      status: responseClone.status,
-      statusText: responseClone.statusText,
+      status: responseStatus,
+      statusText: responseStatusText,
       headers: (0, import_headers_polyfill.headersToObject)(responseClone.headers),
       body: responseText
     };

package/lib/core/utils/logging/serializeResponse.mjs

@@ -18,14 +18,18 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
+import statuses from "@bundled-es-modules/statuses";
 import { headersToObject } from "headers-polyfill";
+const { message } = statuses;
 function serializeResponse(response) {
   return __async(this, null, function* () {
     const responseClone = response.clone();
     const responseText = yield responseClone.text();
+    const responseStatus = responseClone.status || 200;
+    const responseStatusText = responseClone.statusText || message[responseStatus] || "OK";
     return {
-      status: responseClone.status,
-      statusText: responseClone.statusText,
+      status: responseStatus,
+      statusText: responseStatusText,
       headers: headersToObject(responseClone.headers),
       body: responseText
     };

package/lib/core/utils/request/onUnhandledRequest.js

@@ -64,8 +64,8 @@ const TYPE_MATCH_DELTA = 0.5;
 function groupHandlersByType(handlers) {
   return handlers.reduce(
     (groups, handler) => {
-      if (handler instanceof import__.RestHandler) {
-        groups.rest.push(handler);
+      if (handler instanceof import__.HttpHandler) {
+        groups.http.push(handler);
       }
       if (handler instanceof import__.GraphQLHandler) {
         groups.graphql.push(handler);
@@ -73,12 +73,12 @@ function groupHandlersByType(handlers) {
       return groups;
     },
     {
-      rest: [],
+      http: [],
       graphql: []
     }
   );
 }
-function getRestHandlerScore() {
+function getHttpHandlerScore() {
   return (request, handler) => {
     const { path, method } = handler.info;
     if (path instanceof RegExp || method instanceof RegExp) {
@@ -128,11 +128,11 @@ function onUnhandledRequest(request, handlers, strategy = "warn") {
     );
     function generateHandlerSuggestion() {
       const handlerGroups = groupHandlersByType(handlers);
-      const relevantHandlers = parsedGraphQLQuery ? handlerGroups.graphql : handlerGroups.rest;
+      const relevantHandlers = parsedGraphQLQuery ? handlerGroups.graphql : handlerGroups.http;
       const suggestedHandlers = getSuggestedHandler(
         request,
         relevantHandlers,
-        parsedGraphQLQuery ? getGraphQLHandlerScore(parsedGraphQLQuery) : getRestHandlerScore()
+        parsedGraphQLQuery ? getGraphQLHandlerScore(parsedGraphQLQuery) : getHttpHandlerScore()
       );
       return suggestedHandlers.length > 0 ? getSuggestedHandlersMessage(suggestedHandlers) : "";
     }

package/lib/core/utils/request/onUnhandledRequest.mjs

@@ -19,7 +19,7 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 import jsLevenshtein from "@bundled-es-modules/js-levenshtein";
-import { RestHandler, GraphQLHandler } from '../../index.mjs';
+import { HttpHandler, GraphQLHandler } from '../../index.mjs';
 import {
   parseGraphQLRequest
 } from '../internal/parseGraphQLRequest.mjs';
@@ -33,8 +33,8 @@ const TYPE_MATCH_DELTA = 0.5;
 function groupHandlersByType(handlers) {
   return handlers.reduce(
     (groups, handler) => {
-      if (handler instanceof RestHandler) {
-        groups.rest.push(handler);
+      if (handler instanceof HttpHandler) {
+        groups.http.push(handler);
       }
       if (handler instanceof GraphQLHandler) {
         groups.graphql.push(handler);
@@ -42,12 +42,12 @@ function groupHandlersByType(handlers) {
       return groups;
     },
     {
-      rest: [],
+      http: [],
       graphql: []
     }
   );
 }
-function getRestHandlerScore() {
+function getHttpHandlerScore() {
   return (request, handler) => {
     const { path, method } = handler.info;
     if (path instanceof RegExp || method instanceof RegExp) {
@@ -97,11 +97,11 @@ function onUnhandledRequest(request, handlers, strategy = "warn") {
     );
     function generateHandlerSuggestion() {
       const handlerGroups = groupHandlersByType(handlers);
-      const relevantHandlers = parsedGraphQLQuery ? handlerGroups.graphql : handlerGroups.rest;
+      const relevantHandlers = parsedGraphQLQuery ? handlerGroups.graphql : handlerGroups.http;
       const suggestedHandlers = getSuggestedHandler(
         request,
         relevantHandlers,
-        parsedGraphQLQuery ? getGraphQLHandlerScore(parsedGraphQLQuery) : getRestHandlerScore()
+        parsedGraphQLQuery ? getGraphQLHandlerScore(parsedGraphQLQuery) : getHttpHandlerScore()
       );
       return suggestedHandlers.length > 0 ? getSuggestedHandlersMessage(suggestedHandlers) : "";
     }