msw 1.3.2 → 2.0.0

package/lib/core/handlers/GraphQLHandler.mjs

@@ -0,0 +1,130 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import {
+  RequestHandler
+} from './RequestHandler.mjs';
+import { getTimestamp } from '../utils/logging/getTimestamp.mjs';
+import { getStatusCodeColor } from '../utils/logging/getStatusCodeColor.mjs';
+import { serializeRequest } from '../utils/logging/serializeRequest.mjs';
+import { serializeResponse } from '../utils/logging/serializeResponse.mjs';
+import { matchRequestUrl } from '../utils/matching/matchRequestUrl.mjs';
+import {
+  parseGraphQLRequest,
+  parseDocumentNode
+} from '../utils/internal/parseGraphQLRequest.mjs';
+import { getPublicUrlFromRequest } from '../utils/request/getPublicUrlFromRequest.mjs';
+import { devUtils } from '../utils/internal/devUtils.mjs';
+function isDocumentNode(value) {
+  if (value == null) {
+    return false;
+  }
+  return typeof value === "object" && "kind" in value && "definitions" in value;
+}
+class GraphQLHandler extends RequestHandler {
+  constructor(operationType, operationName, endpoint, resolver, options) {
+    let resolvedOperationName = operationName;
+    if (isDocumentNode(operationName)) {
+      const parsedNode = parseDocumentNode(operationName);
+      if (parsedNode.operationType !== operationType) {
+        throw new Error(
+          `Failed to create a GraphQL handler: provided a DocumentNode with a mismatched operation type (expected "${operationType}", but got "${parsedNode.operationType}").`
+        );
+      }
+      if (!parsedNode.operationName) {
+        throw new Error(
+          `Failed to create a GraphQL handler: provided a DocumentNode with no operation name.`
+        );
+      }
+      resolvedOperationName = parsedNode.operationName;
+    }
+    const header = operationType === "all" ? `${operationType} (origin: ${endpoint.toString()})` : `${operationType} ${resolvedOperationName} (origin: ${endpoint.toString()})`;
+    super({
+      info: {
+        header,
+        operationType,
+        operationName: resolvedOperationName
+      },
+      resolver,
+      options
+    });
+    this.endpoint = endpoint;
+  }
+  parse(args) {
+    return __async(this, null, function* () {
+      return parseGraphQLRequest(args.request).catch((error) => {
+        console.error(error);
+        return void 0;
+      });
+    });
+  }
+  predicate(args) {
+    if (!args.parsedResult) {
+      return false;
+    }
+    if (!args.parsedResult.operationName && this.info.operationType !== "all") {
+      const publicUrl = getPublicUrlFromRequest(args.request);
+      devUtils.warn(`Failed to intercept a GraphQL request at "${args.request.method} ${publicUrl}": anonymous GraphQL operations are not supported.
+
+Consider naming this operation or using "graphql.operation()" request handler to intercept GraphQL requests regardless of their operation name/type. Read more: https://mswjs.io/docs/api/graphql/operation`);
+      return false;
+    }
+    const hasMatchingUrl = matchRequestUrl(
+      new URL(args.request.url),
+      this.endpoint
+    );
+    const hasMatchingOperationType = this.info.operationType === "all" || args.parsedResult.operationType === this.info.operationType;
+    const hasMatchingOperationName = this.info.operationName instanceof RegExp ? this.info.operationName.test(args.parsedResult.operationName || "") : args.parsedResult.operationName === this.info.operationName;
+    return hasMatchingUrl.matches && hasMatchingOperationType && hasMatchingOperationName;
+  }
+  extendResolverArgs(args) {
+    var _a, _b, _c;
+    return {
+      query: ((_a = args.parsedResult) == null ? void 0 : _a.query) || "",
+      operationName: ((_b = args.parsedResult) == null ? void 0 : _b.operationName) || "",
+      variables: ((_c = args.parsedResult) == null ? void 0 : _c.variables) || {}
+    };
+  }
+  log(args) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      const loggedRequest = yield serializeRequest(args.request);
+      const loggedResponse = yield serializeResponse(args.response);
+      const statusColor = getStatusCodeColor(loggedResponse.status);
+      const requestInfo = ((_a = args.parsedResult) == null ? void 0 : _a.operationName) ? `${(_b = args.parsedResult) == null ? void 0 : _b.operationType} ${(_c = args.parsedResult) == null ? void 0 : _c.operationName}` : `anonymous ${(_d = args.parsedResult) == null ? void 0 : _d.operationType}`;
+      console.groupCollapsed(
+        devUtils.formatMessage("%s %s (%c%s%c)"),
+        getTimestamp(),
+        `${requestInfo}`,
+        `color:${statusColor}`,
+        `${loggedResponse.status} ${loggedResponse.statusText}`,
+        "color:inherit"
+      );
+      console.log("Request:", loggedRequest);
+      console.log("Handler:", this);
+      console.log("Response:", loggedResponse);
+      console.groupEnd();
+    });
+  }
+}
+export {
+  GraphQLHandler,
+  isDocumentNode
+};

package/lib/core/handlers/HttpHandler.d.ts

@@ -0,0 +1,62 @@
+import { g as RequestHandlerDefaultInfo, R as RequestHandler, a as ResponseResolver, c as RequestHandlerOptions, i as ResponseResolutionContext } from '../RequestHandler-1a5dbdc7.js';
+import { Path, Match, PathParams } from '../utils/matching/matchRequestUrl.js';
+import '../typeUtils.js';
+
+type HttpHandlerMethod = string | RegExp;
+interface HttpHandlerInfo extends RequestHandlerDefaultInfo {
+    method: HttpHandlerMethod;
+    path: Path;
+}
+declare enum HttpMethods {
+    HEAD = "HEAD",
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    OPTIONS = "OPTIONS",
+    DELETE = "DELETE"
+}
+type RequestQuery = {
+    [queryName: string]: string;
+};
+type HttpRequestParsedResult = {
+    match: Match;
+    cookies: Record<string, string>;
+};
+type HttpRequestResolverExtras<Params extends PathParams> = {
+    params: Params;
+    cookies: Record<string, string | Array<string>>;
+};
+/**
+ * Request handler for HTTP requests.
+ * Provides request matching based on method and URL.
+ */
+declare class HttpHandler extends RequestHandler<HttpHandlerInfo, HttpRequestParsedResult, HttpRequestResolverExtras<any>> {
+    constructor(method: HttpHandlerMethod, path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
+    private checkRedundantQueryParameters;
+    parse(args: {
+        request: Request;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<{
+        match: Match;
+        cookies: Record<string, string>;
+    }>;
+    predicate(args: {
+        request: Request;
+        parsedResult: HttpRequestParsedResult;
+    }): boolean;
+    private matchMethod;
+    protected extendResolverArgs(args: {
+        request: Request;
+        parsedResult: HttpRequestParsedResult;
+    }): {
+        params: PathParams<string>;
+        cookies: Record<string, string>;
+    };
+    log(args: {
+        request: Request;
+        response: Response;
+    }): Promise<void>;
+}
+
+export { HttpHandler, HttpHandlerInfo, HttpMethods, HttpRequestParsedResult, HttpRequestResolverExtras, RequestQuery };

package/lib/core/handlers/HttpHandler.js

@@ -0,0 +1,149 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var HttpHandler_exports = {};
+__export(HttpHandler_exports, {
+  HttpHandler: () => HttpHandler,
+  HttpMethods: () => HttpMethods
+});
+module.exports = __toCommonJS(HttpHandler_exports);
+var import_devUtils = require("../utils/internal/devUtils.js");
+var import_isStringEqual = require("../utils/internal/isStringEqual.js");
+var import_getStatusCodeColor = require("../utils/logging/getStatusCodeColor.js");
+var import_getTimestamp = require("../utils/logging/getTimestamp.js");
+var import_serializeRequest = require("../utils/logging/serializeRequest.js");
+var import_serializeResponse = require("../utils/logging/serializeResponse.js");
+var import_matchRequestUrl = require("../utils/matching/matchRequestUrl.js");
+var import_getPublicUrlFromRequest = require("../utils/request/getPublicUrlFromRequest.js");
+var import_getRequestCookies = require("../utils/request/getRequestCookies.js");
+var import_cleanUrl = require("../utils/url/cleanUrl.js");
+var import_RequestHandler = require("./RequestHandler.js");
+var HttpMethods = /* @__PURE__ */ ((HttpMethods2) => {
+  HttpMethods2["HEAD"] = "HEAD";
+  HttpMethods2["GET"] = "GET";
+  HttpMethods2["POST"] = "POST";
+  HttpMethods2["PUT"] = "PUT";
+  HttpMethods2["PATCH"] = "PATCH";
+  HttpMethods2["OPTIONS"] = "OPTIONS";
+  HttpMethods2["DELETE"] = "DELETE";
+  return HttpMethods2;
+})(HttpMethods || {});
+class HttpHandler extends import_RequestHandler.RequestHandler {
+  constructor(method, path, resolver, options) {
+    super({
+      info: {
+        header: `${method} ${path}`,
+        path,
+        method
+      },
+      resolver,
+      options
+    });
+    this.checkRedundantQueryParameters();
+  }
+  checkRedundantQueryParameters() {
+    const { method, path } = this.info;
+    if (path instanceof RegExp) {
+      return;
+    }
+    const url = (0, import_cleanUrl.cleanUrl)(path);
+    if (url === path) {
+      return;
+    }
+    const searchParams = (0, import_cleanUrl.getSearchParams)(path);
+    const queryParams = [];
+    searchParams.forEach((_, paramName) => {
+      queryParams.push(paramName);
+    });
+    import_devUtils.devUtils.warn(
+      `Found a redundant usage of query parameters in the request handler URL for "${method} ${path}". Please match against a path instead and access query parameters in the response resolver function using "req.url.searchParams".`
+    );
+  }
+  parse(args) {
+    return __async(this, null, function* () {
+      var _a;
+      const url = new URL(args.request.url);
+      const match = (0, import_matchRequestUrl.matchRequestUrl)(
+        url,
+        this.info.path,
+        (_a = args.resolutionContext) == null ? void 0 : _a.baseUrl
+      );
+      const cookies = (0, import_getRequestCookies.getAllRequestCookies)(args.request);
+      return {
+        match,
+        cookies
+      };
+    });
+  }
+  predicate(args) {
+    const hasMatchingMethod = this.matchMethod(args.request.method);
+    const hasMatchingUrl = args.parsedResult.match.matches;
+    return hasMatchingMethod && hasMatchingUrl;
+  }
+  matchMethod(actualMethod) {
+    return this.info.method instanceof RegExp ? this.info.method.test(actualMethod) : (0, import_isStringEqual.isStringEqual)(this.info.method, actualMethod);
+  }
+  extendResolverArgs(args) {
+    var _a;
+    return {
+      params: ((_a = args.parsedResult.match) == null ? void 0 : _a.params) || {},
+      cookies: args.parsedResult.cookies
+    };
+  }
+  log(args) {
+    return __async(this, null, function* () {
+      const publicUrl = (0, import_getPublicUrlFromRequest.getPublicUrlFromRequest)(args.request);
+      const loggedRequest = yield (0, import_serializeRequest.serializeRequest)(args.request);
+      const loggedResponse = yield (0, import_serializeResponse.serializeResponse)(args.response);
+      const statusColor = (0, import_getStatusCodeColor.getStatusCodeColor)(loggedResponse.status);
+      console.groupCollapsed(
+        import_devUtils.devUtils.formatMessage("%s %s %s (%c%s%c)"),
+        (0, import_getTimestamp.getTimestamp)(),
+        args.request.method,
+        publicUrl,
+        `color:${statusColor}`,
+        `${loggedResponse.status} ${loggedResponse.statusText}`,
+        "color:inherit"
+      );
+      console.log("Request", loggedRequest);
+      console.log("Handler:", this);
+      console.log("Response", loggedResponse);
+      console.groupEnd();
+    });
+  }
+}

package/lib/core/handlers/HttpHandler.mjs

@@ -0,0 +1,133 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { devUtils } from '../utils/internal/devUtils.mjs';
+import { isStringEqual } from '../utils/internal/isStringEqual.mjs';
+import { getStatusCodeColor } from '../utils/logging/getStatusCodeColor.mjs';
+import { getTimestamp } from '../utils/logging/getTimestamp.mjs';
+import { serializeRequest } from '../utils/logging/serializeRequest.mjs';
+import { serializeResponse } from '../utils/logging/serializeResponse.mjs';
+import {
+  matchRequestUrl
+} from '../utils/matching/matchRequestUrl.mjs';
+import { getPublicUrlFromRequest } from '../utils/request/getPublicUrlFromRequest.mjs';
+import { getAllRequestCookies } from '../utils/request/getRequestCookies.mjs';
+import { cleanUrl, getSearchParams } from '../utils/url/cleanUrl.mjs';
+import {
+  RequestHandler
+} from './RequestHandler.mjs';
+var HttpMethods = /* @__PURE__ */ ((HttpMethods2) => {
+  HttpMethods2["HEAD"] = "HEAD";
+  HttpMethods2["GET"] = "GET";
+  HttpMethods2["POST"] = "POST";
+  HttpMethods2["PUT"] = "PUT";
+  HttpMethods2["PATCH"] = "PATCH";
+  HttpMethods2["OPTIONS"] = "OPTIONS";
+  HttpMethods2["DELETE"] = "DELETE";
+  return HttpMethods2;
+})(HttpMethods || {});
+class HttpHandler extends RequestHandler {
+  constructor(method, path, resolver, options) {
+    super({
+      info: {
+        header: `${method} ${path}`,
+        path,
+        method
+      },
+      resolver,
+      options
+    });
+    this.checkRedundantQueryParameters();
+  }
+  checkRedundantQueryParameters() {
+    const { method, path } = this.info;
+    if (path instanceof RegExp) {
+      return;
+    }
+    const url = cleanUrl(path);
+    if (url === path) {
+      return;
+    }
+    const searchParams = getSearchParams(path);
+    const queryParams = [];
+    searchParams.forEach((_, paramName) => {
+      queryParams.push(paramName);
+    });
+    devUtils.warn(
+      `Found a redundant usage of query parameters in the request handler URL for "${method} ${path}". Please match against a path instead and access query parameters in the response resolver function using "req.url.searchParams".`
+    );
+  }
+  parse(args) {
+    return __async(this, null, function* () {
+      var _a;
+      const url = new URL(args.request.url);
+      const match = matchRequestUrl(
+        url,
+        this.info.path,
+        (_a = args.resolutionContext) == null ? void 0 : _a.baseUrl
+      );
+      const cookies = getAllRequestCookies(args.request);
+      return {
+        match,
+        cookies
+      };
+    });
+  }
+  predicate(args) {
+    const hasMatchingMethod = this.matchMethod(args.request.method);
+    const hasMatchingUrl = args.parsedResult.match.matches;
+    return hasMatchingMethod && hasMatchingUrl;
+  }
+  matchMethod(actualMethod) {
+    return this.info.method instanceof RegExp ? this.info.method.test(actualMethod) : isStringEqual(this.info.method, actualMethod);
+  }
+  extendResolverArgs(args) {
+    var _a;
+    return {
+      params: ((_a = args.parsedResult.match) == null ? void 0 : _a.params) || {},
+      cookies: args.parsedResult.cookies
+    };
+  }
+  log(args) {
+    return __async(this, null, function* () {
+      const publicUrl = getPublicUrlFromRequest(args.request);
+      const loggedRequest = yield serializeRequest(args.request);
+      const loggedResponse = yield serializeResponse(args.response);
+      const statusColor = getStatusCodeColor(loggedResponse.status);
+      console.groupCollapsed(
+        devUtils.formatMessage("%s %s %s (%c%s%c)"),
+        getTimestamp(),
+        args.request.method,
+        publicUrl,
+        `color:${statusColor}`,
+        `${loggedResponse.status} ${loggedResponse.statusText}`,
+        "color:inherit"
+      );
+      console.log("Request", loggedRequest);
+      console.log("Handler:", this);
+      console.log("Response", loggedResponse);
+      console.groupEnd();
+    });
+  }
+}
+export {
+  HttpHandler,
+  HttpMethods
+};

package/lib/core/handlers/RequestHandler.d.ts

@@ -0,0 +1,2 @@
+export { A as AsyncResponseResolverReturnType, D as DefaultBodyType, d as DefaultRequestMultipartBody, M as MaybeAsyncResponseResolverReturnType, R as RequestHandler, m as RequestHandlerArgs, g as RequestHandlerDefaultInfo, n as RequestHandlerExecutionResult, k as RequestHandlerInternalInfo, c as RequestHandlerOptions, a as ResponseResolver, l as ResponseResolverInfo, b as ResponseResolverReturnType } from '../RequestHandler-1a5dbdc7.js';
+import '../typeUtils.js';

package/lib/core/handlers/RequestHandler.js

@@ -0,0 +1,180 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var RequestHandler_exports = {};
+__export(RequestHandler_exports, {
+  RequestHandler: () => RequestHandler
+});
+module.exports = __toCommonJS(RequestHandler_exports);
+var import_outvariant = require("outvariant");
+var import_getCallFrame = require("../utils/internal/getCallFrame.js");
+var import_isIterable = require("../utils/internal/isIterable.js");
+class RequestHandler {
+  constructor(args) {
+    this.resolver = args.resolver;
+    this.options = args.options;
+    const callFrame = (0, import_getCallFrame.getCallFrame)(new Error());
+    this.info = __spreadProps(__spreadValues({}, args.info), {
+      callFrame
+    });
+    this.isUsed = false;
+  }
+  /**
+   * Parse the intercepted request to extract additional information from it.
+   * Parsed result is then exposed to other methods of this request handler.
+   */
+  parse(_args) {
+    return __async(this, null, function* () {
+      return {};
+    });
+  }
+  /**
+   * Test if this handler matches the given request.
+   */
+  test(args) {
+    return __async(this, null, function* () {
+      const parsedResult = yield this.parse({
+        request: args.request,
+        resolutionContext: args.resolutionContext
+      });
+      return this.predicate({
+        request: args.request,
+        parsedResult,
+        resolutionContext: args.resolutionContext
+      });
+    });
+  }
+  extendResolverArgs(_args) {
+    return {};
+  }
+  /**
+   * Execute this request handler and produce a mocked response
+   * using the given resolver function.
+   */
+  run(args) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isUsed && ((_a = this.options) == null ? void 0 : _a.once)) {
+        return null;
+      }
+      const mainRequestRef = args.request.clone();
+      this.isUsed = true;
+      const parsedResult = yield this.parse({
+        request: args.request,
+        resolutionContext: args.resolutionContext
+      });
+      const shouldInterceptRequest = this.predicate({
+        request: args.request,
+        parsedResult,
+        resolutionContext: args.resolutionContext
+      });
+      if (!shouldInterceptRequest) {
+        return null;
+      }
+      const executeResolver = this.wrapResolver(this.resolver);
+      const resolverExtras = this.extendResolverArgs({
+        request: args.request,
+        parsedResult
+      });
+      const mockedResponse = yield executeResolver(__spreadProps(__spreadValues({}, resolverExtras), {
+        request: args.request
+      }));
+      const executionResult = this.createExecutionResult({
+        // Pass the cloned request to the result so that logging
+        // and other consumers could read its body once more.
+        request: mainRequestRef,
+        response: mockedResponse,
+        parsedResult
+      });
+      return executionResult;
+    });
+  }
+  wrapResolver(resolver) {
+    return (info) => __async(this, null, function* () {
+      const result = this.resolverGenerator || (yield resolver(info));
+      if ((0, import_isIterable.isIterable)(result)) {
+        this.isUsed = false;
+        const { value, done } = result[Symbol.iterator]().next();
+        const nextResponse = yield value;
+        if (done) {
+          this.isUsed = true;
+        }
+        if (!nextResponse && done) {
+          (0, import_outvariant.invariant)(
+            this.resolverGeneratorResult,
+            "Failed to returned a previously stored generator response: the value is not a valid Response."
+          );
+          return this.resolverGeneratorResult.clone();
+        }
+        if (!this.resolverGenerator) {
+          this.resolverGenerator = result;
+        }
+        if (nextResponse) {
+          this.resolverGeneratorResult = nextResponse == null ? void 0 : nextResponse.clone();
+        }
+        return nextResponse;
+      }
+      return result;
+    });
+  }
+  createExecutionResult(args) {
+    return {
+      handler: this,
+      request: args.request,
+      response: args.response,
+      parsedResult: args.parsedResult
+    };
+  }
+}