msw 0.20.1 → 0.20.5

package/lib/types/graphql.d.ts

@@ -1,6 +1,7 @@
 import { OperationTypeNode } from 'graphql';
-import { RequestHandler, MockedRequest } from './handlers/requestHandler';
+import { RequestHandler, MockedRequest, AsyncResponseResolverReturnType } from './handlers/requestHandler';
 import { MockedResponse, ResponseComposition } from './response';
+import { Mask } from './setupWorker/glossary';
 import { set } from './context/set';
 import { status } from './context/status';
 import { delay } from './context/delay';
@@ -21,7 +22,7 @@ export interface GraphQLMockedContext<QueryType> {
     errors: typeof errors;
 }
 export declare const graphqlContext: GraphQLMockedContext<any>;
-export declare type GraphQLResponseResolver<QueryType, VariablesType> = (req: GraphQLMockedRequest<VariablesType>, res: ResponseComposition, context: GraphQLMockedContext<QueryType>) => MockedResponse;
+export declare type GraphQLResponseResolver<QueryType, VariablesType> = (req: GraphQLMockedRequest<VariablesType>, res: ResponseComposition, context: GraphQLMockedContext<QueryType>) => AsyncResponseResolverReturnType<MockedResponse>;
 export interface GraphQLRequestPayload<VariablesType> {
     query: string;
     variables?: VariablesType;
@@ -35,7 +36,13 @@ 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>>;
+};
+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>>;
 };

package/lib/types/handlers/requestHandler.d.ts

@@ -32,14 +32,15 @@ export declare type RequestQuery = {
 export declare type RequestParams = {
     [paramName: string]: any;
 };
-declare type ResponseResolverReturnType = MockedResponse | undefined | void;
-export declare type ResponseResolver<RequestType = MockedRequest, ContextType = typeof defaultContext> = (req: RequestType, res: ResponseComposition, context: ContextType) => Promise<ResponseResolverReturnType> | ResponseResolverReturnType;
+export declare type ResponseResolverReturnType<R> = R | undefined | void;
+export declare type AsyncResponseResolverReturnType<R> = Promise<ResponseResolverReturnType<R>> | ResponseResolverReturnType<R>;
+export declare type ResponseResolver<RequestType = MockedRequest, ContextType = typeof defaultContext> = (req: RequestType, res: ResponseComposition, context: ContextType) => AsyncResponseResolverReturnType<MockedResponse>;
 export interface RequestHandler<RequestType = MockedRequest, ContextType = typeof defaultContext, ParsedRequest = any, PublicRequest = RequestType> {
     /**
      * Parses a captured request to retrieve additional
      * information meant for internal usage in the request handler.
      */
-    parse?: (req: MockedRequest) => ParsedRequest | null;
+    parse?: (req: RequestType) => ParsedRequest | null;
     /**
      * Returns a modified request with necessary public properties appended.
      */

package/lib/types/index.d.ts

@@ -2,6 +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, defaultContext, } from './handlers/requestHandler';
-export { rest, restContext, RESTMethods } from './rest';
+export { MockedRequest, RequestHandler, RequestParams, RequestQuery, ResponseResolver, ResponseResolverReturnType, AsyncResponseResolverReturnType, defaultContext, } from './handlers/requestHandler';
+export { rest, restContext, RESTMethods, ParsedRestRequest } from './rest';
 export { graphql, graphqlContext, GraphQLMockedRequest, GraphQLMockedContext, GraphQLRequestPayload, GraphQLResponseResolver, } from './graphql';
+export { matchRequestUrl } from './utils/matching/matchRequest';

package/lib/types/rest.d.ts

@@ -1,6 +1,7 @@
 import { RequestHandler, ResponseResolver, MockedRequest } from './handlers/requestHandler';
 import { Mask } from './setupWorker/glossary';
 import { set } from './context/set';
+import { matchRequestUrl } from './utils/matching/matchRequest';
 export declare enum RESTMethods {
     GET = "GET",
     POST = "POST",
@@ -20,11 +21,14 @@ export declare const restContext: {
     delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer;
     fetch: <ResponseType_1 = any>(input: string | MockedRequest, requestInit?: RequestInit) => Promise<ResponseType_1>;
 };
+export interface ParsedRestRequest {
+    match: ReturnType<typeof matchRequestUrl>;
+}
 export declare const rest: {
-    get: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext>;
-    post: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext>;
-    put: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext>;
-    delete: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext>;
-    patch: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext>;
-    options: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext>;
+    get: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext, ParsedRestRequest>;
+    post: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext, ParsedRestRequest>;
+    put: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext, ParsedRestRequest>;
+    delete: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext, ParsedRestRequest>;
+    patch: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext, ParsedRestRequest>;
+    options: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext, ParsedRestRequest>;
 };

package/lib/types/setupWorker/glossary.d.ts

@@ -4,6 +4,7 @@ import { MockedResponse } from '../response';
 import { SharedOptions } from '../sharedOptions';
 import { ServiceWorkerMessage } from '../utils/createBroadcastChannel';
 export declare type Mask = RegExp | string;
+export declare type ResolvedMask = Mask | URL;
 export interface SetupWorkerInternalContext {
     worker: ServiceWorker | null;
     registration: ServiceWorkerRegistration | null;

package/lib/types/setupWorker/start/utils/getWorkerByRegistration.d.ts

@@ -1,5 +1,5 @@
 /**
- * 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).
  */
-export declare const getWorkerByRegistration: (registration: ServiceWorkerRegistration) => ServiceWorker | null;
+export declare const getWorkerByRegistration: (registration: ServiceWorkerRegistration, absoluteWorkerUrl: string) => ServiceWorker | null;

package/lib/types/utils/matching/getCleanMask.d.ts

@@ -0,0 +1,2 @@
+import { Mask, ResolvedMask } from '../../setupWorker/glossary';
+export declare function getCleanMask(resolvedMask: ResolvedMask): Mask;

package/lib/types/utils/matching/matchRequest.d.ts

@@ -0,0 +1,7 @@
+import { match } from 'node-match-path';
+import { Mask } from '../../setupWorker/glossary';
+/**
+ * Returns the result of matching given request URL
+ * against a mask.
+ */
+export declare function matchRequestUrl(url: URL, mask: Mask): ReturnType<typeof match>;

package/lib/umd/index.js

@@ -4,7 +4,7 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.MockServiceWorker = {}));
 }(this, (function (exports) { 'use strict';
 
-  var statuses = {
+  var codes = {
   	"100": "Continue",
   	"101": "Switching Protocols",
   	"102": "Processing",
@@ -70,6 +70,11 @@
   	"511": "Network Authentication Required"
   };
 
+  var statuses = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    'default': codes
+  });
+
   const status = (statusCode, statusText) => {
       return (res) => {
           res.status = statusCode;
@@ -550,21 +555,18 @@
     }
   }
 
-  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;
       };
   };
@@ -711,7 +713,7 @@
     __proto__: null,
     status: status,
     set: set,
-    cookie: cookie$1,
+    cookie: cookie,
     body: body,
     data: data,
     delay: delay,
@@ -774,11 +776,20 @@
   });
 
   /**
-   * 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;
   };
 
   /**
@@ -799,9 +810,7 @@
       const [, mockRegistrations] = yield lib$1.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) {
@@ -813,21 +822,24 @@
           // at this point we are sure it's hard reload that falls into this clause.
           location.reload();
       }
-      const [, existingRegistration] = yield lib$1.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$1.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)');
@@ -934,49 +946,72 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
    * 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 {
-              handler: relevantHandler,
+              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: 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,
@@ -1038,7 +1073,7 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
   }
 
   function getAllCookies() {
-      return cookie.parse(document.cookie);
+      return parse_1(document.cookie);
   }
   /**
    * Returns relevant document cookies based on the request `credentials` option.
@@ -2698,6 +2733,47 @@ If this message still persists after updating, please report an issue: https://g
     if (host) this.hostname = host;
   };
 
+  /**
+   * 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.
@@ -2762,47 +2838,6 @@ If this message still persists after updating, please report an issue: https://g
           : mask;
   };
 
-  /**
-   * 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 given request handler mask into a URL, if given a valid URL string.
    * Otherwise, returns the mask as-is.
@@ -2823,6 +2858,25 @@ If this message still persists after updating, please report an issue: https://g
       }
   }
 
+  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);
+  }
+
   (function (RESTMethods) {
       RESTMethods["GET"] = "GET";
       RESTMethods["POST"] = "POST";
@@ -2834,7 +2888,7 @@ If this message still persists after updating, please report an issue: https://g
   const restContext = {
       set,
       status,
-      cookie: cookie$1,
+      cookie,
       body,
       text,
       json,
@@ -2845,24 +2899,21 @@ If this message still persists after updating, please report an issue: https://g
   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,
@@ -5930,11 +5981,12 @@ ${queryParams
           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) {
@@ -5955,7 +6007,7 @@ ${queryParams
                           };
                       }
                       case 'POST': {
-                          if (!req.body) {
+                          if (!((_a = req.body) === null || _a === void 0 ? void 0 : _a.query)) {
                               return null;
                           }
                           const { query, variables } = req.body;
@@ -5977,10 +6029,13 @@ ${queryParams
                   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;
@@ -6002,15 +6057,23 @@ ${queryParams
           };
       };
   };
-  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 });
 
   exports.context = index;
   exports.defaultContext = defaultContext;
   exports.graphql = graphql;
   exports.graphqlContext = graphqlContext;
+  exports.matchRequestUrl = matchRequestUrl;
   exports.response = response;
   exports.rest = rest;
   exports.restContext = restContext;