@graphitation/supermassive 2.6.1 → 3.0.0-alpha.3

package/lib/executeWithoutSchema.js

@@ -1,8 +1,25 @@
 "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 });
@@ -16,10 +33,29 @@ var __copyProps = (to, from, except, desc) => {
   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 executeWithoutSchema_exports = {};
 __export(executeWithoutSchema_exports, {
   assertValidExecutionArguments: () => assertValidExecutionArguments,
-  buildExecutionContext: () => buildExecutionContext,
   buildResolveInfo: () => buildResolveInfo,
   defaultFieldResolver: () => defaultFieldResolver,
   defaultTypeResolver: () => defaultTypeResolver,
@@ -38,51 +74,26 @@ var import_isPromise = require("./jsutils/isPromise");
 var import_Path = require("./jsutils/Path");
 var import_promiseForObject = require("./jsutils/promiseForObject");
 var import_promiseReduce = require("./jsutils/promiseReduce");
-var import_definition = require("./definition");
-var import_mergeResolvers = require("./utilities/mergeResolvers");
-var import_typeNameFromAST = require("./utilities/typeNameFromAST");
 var import_values = require("./values");
 var import_array = require("./utilities/array");
+var import_isAsyncIterable = require("./jsutils/isAsyncIterable");
+var import_mapAsyncIterator = require("./utilities/mapAsyncIterator");
+var import_directives = require("./schema/directives");
+var import_memoize3 = require("./jsutils/memoize3");
+var import_fragment = require("./schema/fragment");
+var import_reference = require("./schema/reference");
+var import_getSchemaFragment = require("./utilities/getSchemaFragment");
+var import_mergeDefinitions = require("./utilities/mergeDefinitions");
+const collectSubfields = (0, import_memoize3.memoize3)(
+  (exeContext, returnTypeName, fieldGroup) => (0, import_collectFields.collectSubfields)(exeContext, returnTypeName.name, fieldGroup)
+);
 function executeWithoutSchema(args) {
-  const {
-    resolvers,
-    schemaResolvers,
-    document,
-    rootValue,
-    contextValue,
-    variableValues,
-    operationName,
-    fieldResolver,
-    typeResolver,
-    fieldExecutionHooks
-  } = args;
-  const combinedResolvers = schemaResolvers ? (0, import_mergeResolvers.mergeResolvers)(resolvers, schemaResolvers) : resolvers;
-  assertValidExecutionArguments(document, variableValues);
-  const exeContext = buildExecutionContext(
-    combinedResolvers,
-    document,
-    rootValue,
-    contextValue,
-    variableValues,
-    operationName,
-    fieldResolver,
-    typeResolver,
-    fieldExecutionHooks
-  );
-  if (!("resolvers" in exeContext)) {
+  const exeContext = buildExecutionContext(args);
+  if (!("schemaTypes" in exeContext)) {
     return { errors: exeContext };
   } else {
-    const data = executeOperation(exeContext, exeContext.operation, rootValue);
-    return buildResponse(exeContext, data);
-  }
-}
-function buildResponse(exeContext, data) {
-  if ((0, import_isPromise.isPromise)(data)) {
-    return data.then(
-      (resolved) => buildResponse(exeContext, resolved)
-    );
+    return executeOperation(exeContext);
   }
-  return exeContext.errors.length === 0 ? { data } : { errors: exeContext.errors, data };
 }
 function assertValidExecutionArguments(document, rawVariableValues) {
   (0, import_devAssert.devAssert)(document, "Must provide document.");
@@ -91,8 +102,23 @@ function assertValidExecutionArguments(document, rawVariableValues) {
     "Variables must be provided as an Object where each property is a variable value. Perhaps look to see if an unparsed JSON string was provided."
   );
 }
-function buildExecutionContext(resolvers, document, rootValue, contextValue, rawVariableValues, operationName, fieldResolver, typeResolver, fieldExecutionHooks) {
+function buildExecutionContext(args) {
   var _a, _b;
+  const {
+    resolvers,
+    schemaFragment: explicitSchemaFragment,
+    document,
+    rootValue,
+    contextValue,
+    buildContextValue,
+    variableValues,
+    operationName,
+    fieldResolver,
+    typeResolver,
+    subscribeFieldResolver,
+    fieldExecutionHooks
+  } = args;
+  assertValidExecutionArguments(document, variableValues);
   let operation;
   const fragments = /* @__PURE__ */ Object.create(null);
   for (const definition of document.definitions) {
@@ -122,66 +148,146 @@ function buildExecutionContext(resolvers, document, rootValue, contextValue, raw
     }
     return [new import_graphql.GraphQLError("Must provide an operation.")];
   }
+  let schemaFragment = explicitSchemaFragment;
+  if (!schemaFragment) {
+    schemaFragment = (0, import_getSchemaFragment.getSchemaFragment)(operation);
+    if (schemaFragment && !schemaFragment.__merged) {
+      (0, import_mergeDefinitions.mergeSchemaDefinitions)(
+        schemaFragment,
+        Object.values(fragments).map((fragmentDef) => (0, import_getSchemaFragment.getSchemaFragment)(fragmentDef)).filter((f) => Boolean(f))
+      );
+      schemaFragment.__merged = true;
+    }
+  }
+  if (!schemaFragment) {
+    return [new import_graphql.GraphQLError("Must provide schema fragment.")];
+  }
   const variableDefinitions = (_b = operation.variableDefinitions) != null ? _b : [];
+  const schemaTypes = new import_fragment.SchemaFragment(schemaFragment, resolvers);
   const coercedVariableValues = (0, import_values.getVariableValues)(
-    resolvers,
+    schemaTypes,
     variableDefinitions,
-    rawVariableValues != null ? rawVariableValues : {},
+    variableValues != null ? variableValues : {},
     { maxErrors: 50 }
   );
   if (coercedVariableValues.errors) {
     return coercedVariableValues.errors;
   }
   return {
-    resolvers,
+    schemaTypes,
     fragments,
     rootValue,
-    contextValue,
+    contextValue: buildContextValue ? buildContextValue(contextValue) : contextValue,
+    buildContextValue,
     operation,
     variableValues: coercedVariableValues.coerced,
     fieldResolver: fieldResolver != null ? fieldResolver : defaultFieldResolver,
     typeResolver: typeResolver != null ? typeResolver : defaultTypeResolver,
+    subscribeFieldResolver: subscribeFieldResolver != null ? subscribeFieldResolver : defaultFieldResolver,
     errors: [],
-    fieldExecutionHooks
+    fieldExecutionHooks,
+    subsequentPayloads: /* @__PURE__ */ new Set()
   };
 }
-function executeOperation(exeContext, operation, rootValue) {
-  const typeName = getOperationRootTypeName(operation);
-  const fields = (0, import_collectFields.collectFields)(
-    exeContext.resolvers,
-    exeContext.fragments,
-    exeContext.variableValues,
-    typeName,
-    operation.selectionSet,
-    /* @__PURE__ */ new Map(),
-    /* @__PURE__ */ new Set()
-  );
+function buildPerEventExecutionContext(exeContext, payload) {
+  return __spreadProps(__spreadValues({}, exeContext), {
+    contextValue: exeContext.buildContextValue ? exeContext.buildContextValue(exeContext.contextValue) : exeContext.contextValue,
+    rootValue: payload,
+    subsequentPayloads: /* @__PURE__ */ new Set(),
+    errors: []
+  });
+}
+function executeOperation(exeContext) {
+  const { operation, rootValue } = exeContext;
+  const rootTypeName = getOperationRootTypeName(operation);
+  const { groupedFieldSet, patches } = (0, import_collectFields.collectFields)(exeContext, rootTypeName);
   const path = void 0;
-  try {
-    const result = operation.operation === "mutation" ? executeFieldsSerially(exeContext, typeName, rootValue, path, fields) : executeFields(exeContext, typeName, rootValue, path, fields);
-    if ((0, import_isPromise.isPromise)(result)) {
-      return result.then(void 0, (error) => {
+  let result;
+  switch (operation.operation) {
+    case import_graphql.OperationTypeNode.QUERY:
+      result = executeFields(
+        exeContext,
+        rootTypeName,
+        rootValue,
+        path,
+        groupedFieldSet,
+        void 0
+      );
+      result = buildResponse(exeContext, result);
+      break;
+    case import_graphql.OperationTypeNode.MUTATION:
+      result = executeFieldsSerially(
+        exeContext,
+        rootTypeName,
+        rootValue,
+        path,
+        groupedFieldSet
+      );
+      result = buildResponse(exeContext, result);
+      break;
+    case import_graphql.OperationTypeNode.SUBSCRIPTION: {
+      const resultOrStreamOrPromise = createSourceEventStream(exeContext);
+      result = mapResultOrEventStreamOrPromise(
+        resultOrStreamOrPromise,
+        exeContext,
+        rootTypeName,
+        path,
+        groupedFieldSet
+      );
+    }
+  }
+  for (const patch of patches) {
+    const { label, groupedFieldSet: patchGroupedFieldSet } = patch;
+    executeDeferredFragment(
+      exeContext,
+      rootTypeName,
+      rootValue,
+      patchGroupedFieldSet,
+      label,
+      path
+    );
+  }
+  return result;
+}
+function buildResponse(exeContext, data) {
+  if ((0, import_isPromise.isPromise)(data)) {
+    return data.then(
+      (resolved) => buildResponse(exeContext, resolved),
+      (error) => {
         exeContext.errors.push(error);
-        return Promise.resolve(null);
-      });
+        return buildResponse(exeContext, null);
+      }
+    );
+  }
+  try {
+    const initialResult = exeContext.errors.length === 0 ? { data } : { errors: exeContext.errors, data };
+    if (exeContext.subsequentPayloads.size > 0) {
+      return {
+        initialResult: __spreadProps(__spreadValues({}, initialResult), {
+          hasNext: true
+        }),
+        subsequentResults: yieldSubsequentPayloads(exeContext)
+      };
+    } else {
+      return initialResult;
     }
-    return result;
   } catch (error) {
     exeContext.errors.push(error);
-    return null;
+    return buildResponse(exeContext, null);
   }
 }
-function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, fields) {
+function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, groupedFieldSet) {
   return (0, import_promiseReduce.promiseReduce)(
-    fields.entries(),
-    (results, [responseName, fieldNodes]) => {
+    groupedFieldSet,
+    (results, [responseName, fieldGroup]) => {
       const fieldPath = (0, import_Path.addPath)(path, responseName, parentTypeName);
       const result = executeField(
         exeContext,
         parentTypeName,
         sourceValue,
-        fieldNodes,
-        fieldPath
+        fieldGroup,
+        fieldPath,
+        void 0
       );
       if (result === void 0) {
         return results;
@@ -198,17 +304,18 @@ function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, fi
     /* @__PURE__ */ Object.create(null)
   );
 }
-function executeFields(exeContext, parentTypeName, sourceValue, path, fields) {
+function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFieldSet, incrementalDataRecord) {
   const results = /* @__PURE__ */ Object.create(null);
   let containsPromise = false;
-  for (const [responseName, fieldNodes] of fields.entries()) {
+  for (const [responseName, fieldGroup] of groupedFieldSet) {
     const fieldPath = (0, import_Path.addPath)(path, responseName, parentTypeName);
     const result = executeField(
       exeContext,
       parentTypeName,
       sourceValue,
-      fieldNodes,
-      fieldPath
+      fieldGroup,
+      fieldPath,
+      incrementalDataRecord
     );
     if (result !== void 0) {
       results[responseName] = result;
@@ -222,54 +329,164 @@ function executeFields(exeContext, parentTypeName, sourceValue, path, fields) {
   }
   return (0, import_promiseForObject.promiseForObject)(results);
 }
-function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
-  const fieldName = fieldNodes[0].name.value;
-  const hooks = exeContext.fieldExecutionHooks;
-  let resolveFn;
-  let returnTypeName;
-  let returnTypeNode;
-  if (fieldName === "__typename" && !resolveFn) {
-    resolveFn = () => parentTypeName;
-    returnTypeName = "String";
-    returnTypeNode = {
-      kind: import_graphql.Kind.NAMED_TYPE,
-      name: {
-        kind: import_graphql.Kind.NAME,
-        value: "String"
-      }
-    };
-  } else {
-    returnTypeNode = fieldNodes[0].__type;
-    returnTypeName = (0, import_typeNameFromAST.typeNameFromAST)(returnTypeNode);
-    const typeResolvers = exeContext.resolvers[parentTypeName];
-    resolveFn = typeResolvers == null ? void 0 : typeResolvers[fieldName];
-    if (typeof resolveFn !== "function" && resolveFn != null) {
-      resolveFn = resolveFn.resolve;
+function executeField(exeContext, parentTypeName, source, fieldGroup, path, incrementalDataRecord) {
+  var _a;
+  const schemaTypes = exeContext.schemaTypes;
+  const fieldName = fieldGroup[0].name.value;
+  const fieldDef = schemaTypes.getField(parentTypeName, fieldName);
+  if (fieldDef === void 0) {
+    return;
+  }
+  const returnTypeRef = schemaTypes.getTypeReference(fieldDef);
+  const resolveFn = (_a = schemaTypes.getFieldResolver(parentTypeName, fieldName)) != null ? _a : exeContext.fieldResolver;
+  const info = buildResolveInfo(
+    exeContext,
+    fieldName,
+    fieldGroup,
+    parentTypeName,
+    (0, import_reference.typeNameFromReference)(returnTypeRef),
+    path
+  );
+  return resolveAndCompleteField(
+    exeContext,
+    parentTypeName,
+    returnTypeRef,
+    fieldDef,
+    fieldGroup,
+    info,
+    path,
+    resolveFn,
+    source,
+    incrementalDataRecord
+  );
+}
+function createSourceEventStream(exeContext) {
+  try {
+    const eventStream = executeSubscriptionImpl(exeContext);
+    if ((0, import_isPromise.isPromise)(eventStream)) {
+      return eventStream.then(void 0, (error) => ({ errors: [error] }));
     }
+    return eventStream;
+  } catch (error) {
+    return { errors: [error] };
   }
-  const isDefaultResolverUsed = !resolveFn;
-  if (!resolveFn) {
-    resolveFn = exeContext.fieldResolver;
+}
+function executeSubscriptionImpl(exeContext) {
+  var _a;
+  const { operation, rootValue, schemaTypes } = exeContext;
+  const rootTypeName = getOperationRootTypeName(operation);
+  const { groupedFieldSet } = (0, import_collectFields.collectFields)(exeContext, rootTypeName);
+  const firstRootField = groupedFieldSet.entries().next().value;
+  const [responseName, fieldGroup] = firstRootField;
+  const fieldName = fieldGroup[0].name.value;
+  const fieldDef = schemaTypes.getField(rootTypeName, fieldName);
+  if (!fieldDef) {
+    throw new import_graphql.GraphQLError(
+      `The subscription field "${fieldName}" is not defined.`,
+      { nodes: fieldGroup }
+    );
   }
+  const returnTypeRef = schemaTypes.getTypeReference(fieldDef);
+  const resolveFn = (_a = schemaTypes.getSubscriptionFieldResolver(rootTypeName, fieldName)) != null ? _a : exeContext.subscribeFieldResolver;
+  const path = (0, import_Path.addPath)(void 0, responseName, rootTypeName);
   const info = buildResolveInfo(
     exeContext,
     fieldName,
-    fieldNodes,
-    parentTypeName,
-    returnTypeName,
-    returnTypeNode,
+    fieldGroup,
+    rootTypeName,
+    (0, import_reference.typeNameFromReference)(returnTypeRef),
     path
   );
   try {
-    const args = (0, import_values.getArgumentValues)(
-      exeContext.resolvers,
-      fieldNodes[0],
-      exeContext.variableValues
+    const args = (0, import_values.getArgumentValues)(exeContext, fieldDef, fieldGroup[0]);
+    const contextValue = exeContext.contextValue;
+    const result = resolveFn(rootValue, args, contextValue, info);
+    if ((0, import_isPromise.isPromise)(result)) {
+      return result.then(assertEventStream).then(void 0, (error) => {
+        throw (0, import_graphql.locatedError)(error, fieldGroup, (0, import_Path.pathToArray)(path));
+      });
+    }
+    return assertEventStream(result);
+  } catch (error) {
+    throw (0, import_graphql.locatedError)(error, fieldGroup, (0, import_Path.pathToArray)(path));
+  }
+}
+function assertEventStream(result) {
+  if (result instanceof Error) {
+    throw result;
+  }
+  if (!(0, import_isAsyncIterable.isAsyncIterable)(result)) {
+    throw new import_graphql.GraphQLError(
+      `Subscription field must return Async Iterable. Received: ${(0, import_inspect.inspect)(result)}.`
+    );
+  }
+  return result;
+}
+function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, parentTypeName, path, groupedFieldSet) {
+  if ((0, import_isPromise.isPromise)(resultOrStreamOrPromise)) {
+    return resultOrStreamOrPromise.then(
+      (resultOrStream) => mapResultOrEventStreamOrPromise(
+        resultOrStream,
+        exeContext,
+        parentTypeName,
+        path,
+        groupedFieldSet
+      )
     );
+  } else {
+    if (!(0, import_isAsyncIterable.isAsyncIterable)(resultOrStreamOrPromise)) {
+      return resultOrStreamOrPromise;
+    } else {
+      const mapSourceToResponse = (payload) => {
+        const perEventContext = buildPerEventExecutionContext(
+          exeContext,
+          payload
+        );
+        const data = executeFields(
+          exeContext,
+          parentTypeName,
+          payload,
+          path,
+          groupedFieldSet,
+          void 0
+        );
+        return buildResponse(perEventContext, data);
+      };
+      return (0, import_mapAsyncIterator.mapAsyncIterator)(resultOrStreamOrPromise, mapSourceToResponse);
+    }
+  }
+}
+function buildResolveInfo(exeContext, fieldName, fieldGroup, parentTypeName, returnTypeName, path) {
+  return {
+    fieldName,
+    fieldGroup,
+    returnTypeName,
+    parentTypeName,
+    path,
+    fragments: exeContext.fragments,
+    rootValue: exeContext.rootValue,
+    operation: exeContext.operation,
+    variableValues: exeContext.variableValues
+  };
+}
+function handleFieldError(rawError, exeContext, returnTypeRef, fieldGroup, path, incrementalDataRecord) {
+  var _a;
+  const error = (0, import_graphql.locatedError)(rawError, fieldGroup, (0, import_Path.pathToArray)(path));
+  if ((0, import_reference.isNonNullType)(returnTypeRef)) {
+    throw error;
+  }
+  const errors = (_a = incrementalDataRecord == null ? void 0 : incrementalDataRecord.errors) != null ? _a : exeContext.errors;
+  errors.push(error);
+}
+function resolveAndCompleteField(exeContext, parentTypeName, returnTypeRef, fieldDefinition, fieldGroup, info, path, resolveFn, source, incrementalDataRecord) {
+  const isDefaultResolverUsed = resolveFn === exeContext.fieldResolver;
+  const hooks = exeContext.fieldExecutionHooks;
+  try {
+    const args = (0, import_values.getArgumentValues)(exeContext, fieldDefinition, fieldGroup[0]);
+    const contextValue = exeContext.contextValue;
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.beforeFieldResolve)) {
       invokeBeforeFieldResolveHook(info, exeContext);
     }
-    const contextValue = exeContext.contextValue;
     const result = resolveFn(source, args, contextValue, info);
     let completed;
     if ((0, import_isPromise.isPromise)(result)) {
@@ -280,11 +497,12 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
           }
           return completeValue(
             exeContext,
-            returnTypeNode,
-            fieldNodes,
+            returnTypeRef,
+            fieldGroup,
             info,
             path,
-            resolved
+            resolved,
+            incrementalDataRecord
           );
         },
         (rawError) => {
@@ -300,11 +518,12 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
       }
       completed = completeValue(
         exeContext,
-        returnTypeNode,
-        fieldNodes,
+        returnTypeRef,
+        fieldGroup,
         info,
         path,
-        result
+        result,
+        incrementalDataRecord
       );
     }
     if ((0, import_isPromise.isPromise)(completed)) {
@@ -316,15 +535,19 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
           return resolved;
         },
         (rawError) => {
-          const error = (0, import_graphql.locatedError)(
-            rawError,
-            fieldNodes,
-            (0, import_Path.pathToArray)(path)
-          );
+          const error = (0, import_graphql.locatedError)(rawError, fieldGroup, (0, import_Path.pathToArray)(path));
           if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
             invokeAfterFieldCompleteHook(info, exeContext, void 0, error);
           }
-          return handleFieldError(error, returnTypeNode, exeContext);
+          handleFieldError(
+            rawError,
+            exeContext,
+            returnTypeRef,
+            fieldGroup,
+            path,
+            incrementalDataRecord
+          );
+          return null;
         }
       );
     }
@@ -334,53 +557,37 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
     return completed;
   } catch (rawError) {
     const pathArray = (0, import_Path.pathToArray)(path);
-    const error = (0, import_graphql.locatedError)(
-      rawError,
-      fieldNodes,
-      pathArray
-    );
+    const error = (0, import_graphql.locatedError)(rawError, fieldGroup, pathArray);
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve) && error.path && (0, import_array.arraysAreEqual)(pathArray, error.path)) {
       invokeAfterFieldResolveHook(info, exeContext, void 0, error);
     }
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
       invokeAfterFieldCompleteHook(info, exeContext, void 0, error);
     }
-    return handleFieldError(error, returnTypeNode, exeContext);
-  }
-}
-function buildResolveInfo(exeContext, fieldName, fieldNodes, parentTypeName, returnTypeName, returnTypeNode, path) {
-  return {
-    fieldName,
-    fieldNodes,
-    returnTypeName,
-    parentTypeName,
-    returnTypeNode,
-    path,
-    fragments: exeContext.fragments,
-    rootValue: exeContext.rootValue,
-    operation: exeContext.operation,
-    variableValues: exeContext.variableValues
-  };
-}
-function handleFieldError(error, returnTypeNode, exeContext) {
-  if (returnTypeNode.kind === import_graphql.Kind.NON_NULL_TYPE) {
-    throw error;
+    handleFieldError(
+      rawError,
+      exeContext,
+      returnTypeRef,
+      fieldGroup,
+      path,
+      incrementalDataRecord
+    );
+    return null;
   }
-  exeContext.errors.push(error);
-  return null;
 }
-function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, result) {
+function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
   if (result instanceof Error) {
     throw result;
   }
-  if (returnTypeNode.kind === import_graphql.Kind.NON_NULL_TYPE) {
+  if ((0, import_reference.isNonNullType)(returnTypeRef)) {
     const completed = completeValue(
       exeContext,
-      returnTypeNode.type,
-      fieldNodes,
+      (0, import_reference.unwrap)(returnTypeRef),
+      fieldGroup,
       info,
       path,
-      result
+      result,
+      incrementalDataRecord
     );
     if (completed === null) {
       throw new Error(
@@ -392,105 +599,273 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
   if (result == null) {
     return null;
   }
-  if (returnTypeNode.kind === import_graphql.Kind.LIST_TYPE) {
+  if ((0, import_reference.isListType)(returnTypeRef)) {
     return completeListValue(
       exeContext,
-      returnTypeNode.type,
-      fieldNodes,
+      returnTypeRef,
+      fieldGroup,
       info,
       path,
-      result
+      result,
+      incrementalDataRecord
     );
   }
-  const returnTypeName = returnTypeNode.name.value;
-  let returnType = exeContext.resolvers[returnTypeName];
-  if (!returnType) {
-    returnType = import_values.specifiedScalars[returnTypeName];
-  }
-  if ((0, import_graphql.isLeafType)(returnType)) {
-    return completeLeafValue(returnType, result);
-  }
-  if (returnType instanceof import_graphql.GraphQLInputObjectType) {
+  const schemaTypes = exeContext.schemaTypes;
+  const returnTypeName = (0, import_reference.typeNameFromReference)(returnTypeRef);
+  const leafType = schemaTypes.getLeafTypeResolver(returnTypeRef);
+  if (leafType) {
+    return completeLeafValue(leafType, result);
   }
-  if ((0, import_definition.isUnionResolverType)(returnType) || (0, import_definition.isInterfaceResolverType)(returnType)) {
+  if (schemaTypes.isAbstractType(returnTypeRef)) {
     return completeAbstractValue(
       exeContext,
-      returnType,
-      fieldNodes,
+      returnTypeName,
+      fieldGroup,
       info,
       path,
-      result
+      result,
+      incrementalDataRecord
     );
   }
-  if (typeof returnType === "object") {
+  if (schemaTypes.isObjectType(returnTypeRef)) {
     return completeObjectValue(
       exeContext,
       returnTypeName,
-      fieldNodes,
-      info,
+      fieldGroup,
       path,
-      result
+      result,
+      incrementalDataRecord
     );
   }
   (0, import_invariant.invariant)(
     false,
-    "Cannot complete value of unexpected output type: " + (0, import_inspect.inspect)(returnType)
+    "Cannot complete value of unexpected output type: " + (0, import_reference.inspectTypeReference)(returnTypeRef)
   );
 }
-function completeListValue(exeContext, returnTypeNode, fieldNodes, info, path, result) {
+function completePromisedValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
+  return __async(this, null, function* () {
+    try {
+      const resolved = yield result;
+      let completed = completeValue(
+        exeContext,
+        returnTypeRef,
+        fieldGroup,
+        info,
+        path,
+        resolved,
+        incrementalDataRecord
+      );
+      if ((0, import_isPromise.isPromise)(completed)) {
+        completed = yield completed;
+      }
+      return completed;
+    } catch (rawError) {
+      handleFieldError(
+        rawError,
+        exeContext,
+        returnTypeRef,
+        fieldGroup,
+        path,
+        incrementalDataRecord
+      );
+      filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+      return null;
+    }
+  });
+}
+function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
+  const itemTypeRef = (0, import_reference.unwrap)(returnTypeRef);
+  if ((0, import_isAsyncIterable.isAsyncIterable)(result)) {
+    const asyncIterator = result[Symbol.asyncIterator]();
+    return completeAsyncIteratorValue(
+      exeContext,
+      itemTypeRef,
+      fieldGroup,
+      info,
+      path,
+      asyncIterator,
+      incrementalDataRecord
+    );
+  }
   if (!(0, import_isIterableObject.isIterableObject)(result)) {
     throw new import_graphql.GraphQLError(
       `Expected Iterable, but did not find one for field "${info.parentTypeName}.${info.fieldName}".`
     );
   }
+  const stream = getStreamValues(exeContext, fieldGroup, path);
   let containsPromise = false;
-  const completedResults = Array.from(result, (item, index) => {
+  let previousIncrementalDataRecord = incrementalDataRecord;
+  const completedResults = [];
+  let index = 0;
+  for (const item of result) {
     const itemPath = (0, import_Path.addPath)(path, index, void 0);
-    try {
-      let completedItem;
-      if ((0, import_isPromise.isPromise)(item)) {
-        completedItem = item.then(
-          (resolved) => completeValue(
+    if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
+      previousIncrementalDataRecord = executeStreamField(
+        path,
+        itemPath,
+        item,
+        exeContext,
+        fieldGroup,
+        info,
+        itemTypeRef,
+        stream.label,
+        previousIncrementalDataRecord
+      );
+      index++;
+      continue;
+    }
+    if (completeListItemValue(
+      item,
+      completedResults,
+      exeContext,
+      itemTypeRef,
+      fieldGroup,
+      info,
+      itemPath,
+      incrementalDataRecord
+    )) {
+      containsPromise = true;
+    }
+    index++;
+  }
+  return containsPromise ? Promise.all(completedResults) : completedResults;
+}
+function completeListItemValue(item, completedResults, exeContext, itemTypeRef, fieldGroup, info, itemPath, incrementalDataRecord) {
+  if ((0, import_isPromise.isPromise)(item)) {
+    completedResults.push(
+      completePromisedValue(
+        exeContext,
+        itemTypeRef,
+        fieldGroup,
+        info,
+        itemPath,
+        item,
+        incrementalDataRecord
+      )
+    );
+    return true;
+  }
+  try {
+    const completedItem = completeValue(
+      exeContext,
+      itemTypeRef,
+      fieldGroup,
+      info,
+      itemPath,
+      item,
+      incrementalDataRecord
+    );
+    if ((0, import_isPromise.isPromise)(completedItem)) {
+      completedResults.push(
+        completedItem.then(void 0, (rawError) => {
+          handleFieldError(
+            rawError,
             exeContext,
-            returnTypeNode,
-            fieldNodes,
-            info,
+            itemTypeRef,
+            fieldGroup,
             itemPath,
-            resolved
-          )
-        );
-      } else {
-        completedItem = completeValue(
+            incrementalDataRecord
+          );
+          filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+          return null;
+        })
+      );
+      return true;
+    }
+    completedResults.push(completedItem);
+  } catch (rawError) {
+    handleFieldError(
+      rawError,
+      exeContext,
+      itemTypeRef,
+      fieldGroup,
+      itemPath,
+      incrementalDataRecord
+    );
+    filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+    completedResults.push(null);
+  }
+  return false;
+}
+function getStreamValues(exeContext, fieldGroup, path) {
+  if (typeof path.key === "number") {
+    return;
+  }
+  const stream = (0, import_values.getDirectiveValues)(
+    exeContext,
+    import_directives.GraphQLStreamDirective,
+    fieldGroup[0]
+  );
+  if (!stream) {
+    return;
+  }
+  if (stream.if === false) {
+    return;
+  }
+  (0, import_invariant.invariant)(
+    typeof stream.initialCount === "number",
+    "initialCount must be a number"
+  );
+  (0, import_invariant.invariant)(
+    stream.initialCount >= 0,
+    "initialCount must be a positive integer"
+  );
+  (0, import_invariant.invariant)(
+    exeContext.operation.operation !== import_graphql.OperationTypeNode.SUBSCRIPTION,
+    "`@stream` directive not supported on subscription operations. Disable `@stream` by setting the `if` argument to `false`."
+  );
+  return {
+    initialCount: stream.initialCount,
+    label: typeof stream.label === "string" ? stream.label : void 0
+  };
+}
+function completeAsyncIteratorValue(exeContext, itemTypeRef, fieldGroup, info, path, asyncIterator, incrementalDataRecord) {
+  return __async(this, null, function* () {
+    const stream = getStreamValues(exeContext, fieldGroup, path);
+    let containsPromise = false;
+    const completedResults = [];
+    let index = 0;
+    while (true) {
+      if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
+        executeStreamAsyncIterator(
+          index,
+          asyncIterator,
           exeContext,
-          returnTypeNode,
-          fieldNodes,
+          fieldGroup,
           info,
-          itemPath,
-          item
+          itemTypeRef,
+          path,
+          stream.label,
+          incrementalDataRecord
         );
+        break;
       }
-      if ((0, import_isPromise.isPromise)(completedItem)) {
+      const itemPath = (0, import_Path.addPath)(path, index, void 0);
+      let iteration;
+      try {
+        iteration = yield asyncIterator.next();
+        if (iteration.done) {
+          break;
+        }
+      } catch (rawError) {
+        throw (0, import_graphql.locatedError)(rawError, fieldGroup, (0, import_Path.pathToArray)(path));
+      }
+      if (completeListItemValue(
+        iteration.value,
+        completedResults,
+        exeContext,
+        itemTypeRef,
+        fieldGroup,
+        info,
+        itemPath,
+        incrementalDataRecord
+      )) {
         containsPromise = true;
-        return completedItem.then(void 0, (rawError) => {
-          const error = (0, import_graphql.locatedError)(
-            rawError,
-            fieldNodes,
-            (0, import_Path.pathToArray)(itemPath)
-          );
-          return handleFieldError(error, returnTypeNode, exeContext);
-        });
       }
-      return completedItem;
-    } catch (rawError) {
-      const error = (0, import_graphql.locatedError)(
-        rawError,
-        fieldNodes,
-        (0, import_Path.pathToArray)(itemPath)
-      );
-      return handleFieldError(error, returnTypeNode, exeContext);
+      index += 1;
     }
+    return containsPromise ? Promise.all(completedResults) : completedResults;
   });
-  return containsPromise ? Promise.all(completedResults) : completedResults;
 }
 function completeLeafValue(returnType, result) {
   const serializedResult = returnType.serialize(result);
@@ -501,93 +876,123 @@ function completeLeafValue(returnType, result) {
   }
   return serializedResult;
 }
-function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result) {
+function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, path, result, incrementalDataRecord) {
   var _a;
-  const resolveTypeFn = (_a = returnType.__resolveType) != null ? _a : exeContext.typeResolver;
+  const resolveTypeFn = (_a = exeContext.schemaTypes.getAbstractTypeResolver(returnTypeName)) != null ? _a : exeContext.typeResolver;
   const contextValue = exeContext.contextValue;
   const runtimeTypeName = resolveTypeFn(result, contextValue, info);
   if ((0, import_isPromise.isPromise)(runtimeTypeName)) {
     return runtimeTypeName.then(
       (resolvedRuntimeTypeName) => completeObjectValue(
         exeContext,
-        ensureValidRuntimeType(resolvedRuntimeTypeName, exeContext),
-        fieldNodes,
-        info,
+        ensureValidRuntimeType(
+          resolvedRuntimeTypeName,
+          exeContext,
+          returnTypeName,
+          fieldGroup,
+          info,
+          result
+        ),
+        fieldGroup,
         path,
-        result
+        result,
+        incrementalDataRecord
       )
     );
   }
   return completeObjectValue(
     exeContext,
-    ensureValidRuntimeType(runtimeTypeName, exeContext),
-    fieldNodes,
-    info,
+    ensureValidRuntimeType(
+      runtimeTypeName,
+      exeContext,
+      returnTypeName,
+      fieldGroup,
+      info,
+      result
+    ),
+    fieldGroup,
     path,
-    result
+    result,
+    incrementalDataRecord
   );
 }
-function ensureValidRuntimeType(runtimeTypeName, exeContext) {
-  if (typeof runtimeTypeName !== "string") {
+function ensureValidRuntimeType(runtimeTypeName, exeContext, returnTypeName, fieldGroup, info, result) {
+  if (runtimeTypeName == null) {
     throw new import_graphql.GraphQLError(
-      `Could not determine runtime type for abstract type ${runtimeTypeName}`
+      `Abstract type "${returnTypeName}" must resolve to an Object type at runtime for field "${info.parentTypeName}.${info.fieldName}". Either the "${returnTypeName}" should provide a "__resolveType" resolver function or "${info.parentTypeName}.${info.fieldName}" should be an object with "__typename" property.`,
+      { nodes: fieldGroup }
     );
   }
-  const runtimeType = exeContext.resolvers[runtimeTypeName];
-  if (!runtimeType) {
-    throw new import_graphql.GraphQLError(
-      `Type "${runtimeTypeName}" does not exist inside the schema.`
-    );
-  } else if (runtimeType instanceof import_graphql.GraphQLScalarType || runtimeType instanceof import_graphql.GraphQLEnumType || runtimeType instanceof import_graphql.GraphQLInputObjectType || runtimeType.__resolveType) {
+  if (typeof runtimeTypeName !== "string") {
     throw new import_graphql.GraphQLError(
-      `Given runtime object "${getRuntimeTypeInstanceName(
-        runtimeType
-      )}" type is not a possible type for "${runtimeTypeName}".`
+      `Abstract type "${returnTypeName}" must resolve to an Object type at runtime for field "${info.returnTypeName}.${info.fieldName}" with value ${(0, import_inspect.inspect)(result)}, received "${(0, import_inspect.inspect)(runtimeTypeName)}".`
     );
+  }
+  const schemaTypes = exeContext.schemaTypes;
+  const iface = schemaTypes.getInterfaceType(returnTypeName);
+  if (iface) {
+    if (schemaTypes.isDefined(runtimeTypeName) && !schemaTypes.isObjectType(runtimeTypeName)) {
+      throw new import_graphql.GraphQLError(
+        `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
+        { nodes: fieldGroup }
+      );
+    }
+    schemaTypes.addInterfaceImplementation(returnTypeName, runtimeTypeName);
   } else {
-    return runtimeTypeName;
-  }
-}
-function getRuntimeTypeInstanceName(runtimeType) {
-  if (runtimeType instanceof import_graphql.GraphQLScalarType) {
-    return "GraphQLScalarType";
-  } else if (runtimeType instanceof import_graphql.GraphQLEnumType) {
-    return "GraphQLEnumType";
-  } else if (runtimeType instanceof import_graphql.GraphQLInputObjectType) {
-    return "GraphQLInputObjectType";
-  } else if ("__types" in runtimeType) {
-    return "GraphQLUnionType";
-  } else if ("__implementedBy" in runtimeType) {
-    return "GraphQLInterfaceType";
-  } else {
-    return "Unknown";
+    if (!schemaTypes.isDefined(runtimeTypeName)) {
+      throw new import_graphql.GraphQLError(
+        `Abstract type "${returnTypeName}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`,
+        { nodes: fieldGroup }
+      );
+    }
+    if (!schemaTypes.isObjectType(runtimeTypeName)) {
+      throw new import_graphql.GraphQLError(
+        `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
+        { nodes: fieldGroup }
+      );
+    }
+    if (!exeContext.schemaTypes.isSubType(returnTypeName, runtimeTypeName)) {
+      throw new import_graphql.GraphQLError(
+        `Runtime Object type "${runtimeTypeName}" is not a possible type for "${returnTypeName}".`,
+        { nodes: fieldGroup }
+      );
+    }
   }
+  return runtimeTypeName;
+}
+function completeObjectValue(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord) {
+  return collectAndExecuteSubfields(
+    exeContext,
+    returnTypeName,
+    fieldGroup,
+    path,
+    result,
+    incrementalDataRecord
+  );
 }
-function completeObjectValue(exeContext, returnTypeName, fieldNodes, _info, path, result) {
-  const subFieldNodes = collectSubfields(
+function collectAndExecuteSubfields(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord) {
+  const { groupedFieldSet: subGroupedFieldSet, patches: subPatches } = collectSubfields(exeContext, { name: returnTypeName }, fieldGroup);
+  const subFields = executeFields(
     exeContext,
     returnTypeName,
-    fieldNodes
+    result,
+    path,
+    subGroupedFieldSet,
+    incrementalDataRecord
   );
-  return executeFields(exeContext, returnTypeName, result, path, subFieldNodes);
-}
-function collectSubfields(exeContext, returnTypeName, fieldNodes) {
-  let subFieldNodes = /* @__PURE__ */ new Map();
-  const visitedFragmentNames = /* @__PURE__ */ new Set();
-  for (const node of fieldNodes) {
-    if (node.selectionSet) {
-      subFieldNodes = (0, import_collectFields.collectFields)(
-        exeContext.resolvers,
-        exeContext.fragments,
-        exeContext.variableValues,
-        returnTypeName,
-        node.selectionSet,
-        subFieldNodes,
-        visitedFragmentNames
-      );
-    }
+  for (const subPatch of subPatches) {
+    const { label, groupedFieldSet: subPatchGroupedFieldSet } = subPatch;
+    executeDeferredFragment(
+      exeContext,
+      returnTypeName,
+      result,
+      subPatchGroupedFieldSet,
+      label,
+      path,
+      incrementalDataRecord
+    );
   }
-  return subFieldNodes;
+  return subFields;
 }
 function invokeBeforeFieldResolveHook(resolveInfo, exeContext) {
   var _a;
@@ -698,11 +1103,408 @@ const defaultFieldResolver = (
 );
 function getOperationRootTypeName(operation) {
   switch (operation.operation) {
-    case "query":
+    case import_graphql.OperationTypeNode.QUERY:
       return "Query";
-    case "mutation":
+    case import_graphql.OperationTypeNode.MUTATION:
       return "Mutation";
-    case "subscription":
+    case import_graphql.OperationTypeNode.SUBSCRIPTION:
       return "Subscription";
   }
 }
+function executeDeferredFragment(exeContext, parentTypeName, sourceValue, fields, label, path, parentContext) {
+  const incrementalDataRecord = new DeferredFragmentRecord({
+    label,
+    path,
+    parentContext,
+    exeContext
+  });
+  let promiseOrData;
+  try {
+    promiseOrData = executeFields(
+      exeContext,
+      parentTypeName,
+      sourceValue,
+      path,
+      fields,
+      incrementalDataRecord
+    );
+    if ((0, import_isPromise.isPromise)(promiseOrData)) {
+      promiseOrData = promiseOrData.then(null, (e) => {
+        incrementalDataRecord.errors.push(e);
+        return null;
+      });
+    }
+  } catch (e) {
+    incrementalDataRecord.errors.push(e);
+    promiseOrData = null;
+  }
+  incrementalDataRecord.addData(promiseOrData);
+}
+function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info, itemTypeRef, label, parentContext) {
+  const incrementalDataRecord = new StreamItemsRecord({
+    label,
+    path: itemPath,
+    parentContext,
+    exeContext
+  });
+  if ((0, import_isPromise.isPromise)(item)) {
+    const completedItems = completePromisedValue(
+      exeContext,
+      itemTypeRef,
+      fieldGroup,
+      info,
+      itemPath,
+      item,
+      incrementalDataRecord
+    ).then(
+      (value) => [value],
+      (error) => {
+        incrementalDataRecord.errors.push(error);
+        filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+        return null;
+      }
+    );
+    incrementalDataRecord.addItems(completedItems);
+    return incrementalDataRecord;
+  }
+  let completedItem;
+  try {
+    try {
+      completedItem = completeValue(
+        exeContext,
+        itemTypeRef,
+        fieldGroup,
+        info,
+        itemPath,
+        item,
+        incrementalDataRecord
+      );
+    } catch (rawError) {
+      handleFieldError(
+        rawError,
+        exeContext,
+        itemTypeRef,
+        fieldGroup,
+        itemPath,
+        incrementalDataRecord
+      );
+      completedItem = null;
+      filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+    }
+  } catch (error) {
+    incrementalDataRecord.errors.push(error);
+    filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+    incrementalDataRecord.addItems(null);
+    return incrementalDataRecord;
+  }
+  if ((0, import_isPromise.isPromise)(completedItem)) {
+    const completedItems = completedItem.then(void 0, (rawError) => {
+      handleFieldError(
+        rawError,
+        exeContext,
+        itemTypeRef,
+        fieldGroup,
+        itemPath,
+        incrementalDataRecord
+      );
+      filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+      return null;
+    }).then(
+      (value) => [value],
+      (error) => {
+        incrementalDataRecord.errors.push(error);
+        filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+        return null;
+      }
+    );
+    incrementalDataRecord.addItems(completedItems);
+    return incrementalDataRecord;
+  }
+  incrementalDataRecord.addItems([completedItem]);
+  return incrementalDataRecord;
+}
+function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, info, itemTypeRef, incrementalDataRecord, path, itemPath) {
+  return __async(this, null, function* () {
+    let item;
+    try {
+      const { value, done } = yield asyncIterator.next();
+      if (done) {
+        incrementalDataRecord.setIsCompletedAsyncIterator();
+        return { done, value: void 0 };
+      }
+      item = value;
+    } catch (rawError) {
+      throw (0, import_graphql.locatedError)(rawError, fieldGroup, (0, import_Path.pathToArray)(path));
+    }
+    let completedItem;
+    try {
+      completedItem = completeValue(
+        exeContext,
+        itemTypeRef,
+        fieldGroup,
+        info,
+        itemPath,
+        item,
+        incrementalDataRecord
+      );
+      if ((0, import_isPromise.isPromise)(completedItem)) {
+        completedItem = completedItem.then(void 0, (rawError) => {
+          handleFieldError(
+            rawError,
+            exeContext,
+            itemTypeRef,
+            fieldGroup,
+            itemPath,
+            incrementalDataRecord
+          );
+          filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+          return null;
+        });
+      }
+      return { done: false, value: completedItem };
+    } catch (rawError) {
+      handleFieldError(
+        rawError,
+        exeContext,
+        itemTypeRef,
+        fieldGroup,
+        itemPath,
+        incrementalDataRecord
+      );
+      filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+      return { done: false, value: null };
+    }
+  });
+}
+function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fieldGroup, info, itemTypeRef, path, label, parentContext) {
+  return __async(this, null, function* () {
+    let index = initialIndex;
+    let previousIncrementalDataRecord = parentContext != null ? parentContext : void 0;
+    while (true) {
+      const itemPath = (0, import_Path.addPath)(path, index, void 0);
+      const incrementalDataRecord = new StreamItemsRecord({
+        label,
+        path: itemPath,
+        parentContext: previousIncrementalDataRecord,
+        asyncIterator,
+        exeContext
+      });
+      let iteration;
+      try {
+        iteration = yield executeStreamAsyncIteratorItem(
+          asyncIterator,
+          exeContext,
+          fieldGroup,
+          info,
+          itemTypeRef,
+          incrementalDataRecord,
+          path,
+          itemPath
+        );
+      } catch (error) {
+        incrementalDataRecord.errors.push(error);
+        filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+        incrementalDataRecord.addItems(null);
+        if (asyncIterator == null ? void 0 : asyncIterator.return) {
+          asyncIterator.return().catch(() => {
+          });
+        }
+        return;
+      }
+      const { done, value: completedItem } = iteration;
+      let completedItems;
+      if ((0, import_isPromise.isPromise)(completedItem)) {
+        completedItems = completedItem.then(
+          (value) => [value],
+          (error) => {
+            incrementalDataRecord.errors.push(error);
+            filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+            return null;
+          }
+        );
+      } else {
+        completedItems = [completedItem];
+      }
+      incrementalDataRecord.addItems(completedItems);
+      if (done) {
+        break;
+      }
+      previousIncrementalDataRecord = incrementalDataRecord;
+      index++;
+    }
+  });
+}
+function filterSubsequentPayloads(exeContext, nullPath, currentIncrementalDataRecord) {
+  const nullPathArray = (0, import_Path.pathToArray)(nullPath);
+  exeContext.subsequentPayloads.forEach((incrementalDataRecord) => {
+    var _a;
+    if (incrementalDataRecord === currentIncrementalDataRecord) {
+      return;
+    }
+    for (let i = 0; i < nullPathArray.length; i++) {
+      if (incrementalDataRecord.path[i] !== nullPathArray[i]) {
+        return;
+      }
+    }
+    if (isStreamItemsRecord(incrementalDataRecord) && ((_a = incrementalDataRecord.asyncIterator) == null ? void 0 : _a.return)) {
+      incrementalDataRecord.asyncIterator.return().catch(() => {
+      });
+    }
+    exeContext.subsequentPayloads.delete(incrementalDataRecord);
+  });
+}
+function getCompletedIncrementalResults(exeContext) {
+  const incrementalResults = [];
+  for (const incrementalDataRecord of exeContext.subsequentPayloads) {
+    const incrementalResult = {};
+    if (!incrementalDataRecord.isCompleted) {
+      continue;
+    }
+    exeContext.subsequentPayloads.delete(incrementalDataRecord);
+    if (isStreamItemsRecord(incrementalDataRecord)) {
+      const items = incrementalDataRecord.items;
+      if (incrementalDataRecord.isCompletedAsyncIterator) {
+        continue;
+      }
+      incrementalResult.items = items;
+    } else {
+      const data = incrementalDataRecord.data;
+      incrementalResult.data = data != null ? data : null;
+    }
+    incrementalResult.path = incrementalDataRecord.path;
+    if (incrementalDataRecord.label != null) {
+      incrementalResult.label = incrementalDataRecord.label;
+    }
+    if (incrementalDataRecord.errors.length > 0) {
+      incrementalResult.errors = incrementalDataRecord.errors;
+    }
+    incrementalResults.push(incrementalResult);
+  }
+  return incrementalResults;
+}
+function yieldSubsequentPayloads(exeContext) {
+  let isDone = false;
+  function next() {
+    return __async(this, null, function* () {
+      if (isDone) {
+        return { value: void 0, done: true };
+      }
+      yield Promise.race(
+        Array.from(exeContext.subsequentPayloads).map((p) => p.promise)
+      );
+      if (isDone) {
+        return { value: void 0, done: true };
+      }
+      const incremental = getCompletedIncrementalResults(exeContext);
+      const hasNext = exeContext.subsequentPayloads.size > 0;
+      if (!incremental.length && hasNext) {
+        return next();
+      }
+      if (!hasNext) {
+        isDone = true;
+      }
+      return {
+        value: incremental.length ? { incremental, hasNext } : { hasNext },
+        done: false
+      };
+    });
+  }
+  function returnStreamIterators() {
+    const promises = [];
+    exeContext.subsequentPayloads.forEach((incrementalDataRecord) => {
+      var _a2;
+      if (isStreamItemsRecord(incrementalDataRecord) && ((_a2 = incrementalDataRecord.asyncIterator) == null ? void 0 : _a2.return)) {
+        promises.push(incrementalDataRecord.asyncIterator.return());
+      }
+    });
+    return Promise.all(promises);
+  }
+  return {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next,
+    return() {
+      return __async(this, null, function* () {
+        yield returnStreamIterators();
+        isDone = true;
+        return { value: void 0, done: true };
+      });
+    },
+    throw(error) {
+      return __async(this, null, function* () {
+        yield returnStreamIterators();
+        isDone = true;
+        return Promise.reject(error);
+      });
+    }
+  };
+}
+function isStreamItemsRecord(incrementalDataRecord) {
+  return incrementalDataRecord.type === "stream";
+}
+class DeferredFragmentRecord {
+  constructor(opts) {
+    this.type = "defer";
+    this.label = opts.label;
+    this.path = (0, import_Path.pathToArray)(opts.path);
+    this.parentContext = opts.parentContext;
+    this.errors = [];
+    this._exeContext = opts.exeContext;
+    this._exeContext.subsequentPayloads.add(this);
+    this.isCompleted = false;
+    this.data = null;
+    this.promise = new Promise((resolve) => {
+      this._resolve = (promiseOrValue) => {
+        resolve(promiseOrValue);
+      };
+    }).then((data) => {
+      this.data = data;
+      this.isCompleted = true;
+    });
+  }
+  addData(data) {
+    var _a, _b, _c;
+    const parentData = (_a = this.parentContext) == null ? void 0 : _a.promise;
+    if (parentData) {
+      (_b = this._resolve) == null ? void 0 : _b.call(this, parentData.then(() => data));
+      return;
+    }
+    (_c = this._resolve) == null ? void 0 : _c.call(this, data);
+  }
+}
+class StreamItemsRecord {
+  constructor(opts) {
+    this.type = "stream";
+    this.items = null;
+    this.label = opts.label;
+    this.path = (0, import_Path.pathToArray)(opts.path);
+    this.parentContext = opts.parentContext;
+    this.asyncIterator = opts.asyncIterator;
+    this.errors = [];
+    this._exeContext = opts.exeContext;
+    this._exeContext.subsequentPayloads.add(this);
+    this.isCompleted = false;
+    this.items = null;
+    this.promise = new Promise((resolve) => {
+      this._resolve = (promiseOrValue) => {
+        resolve(promiseOrValue);
+      };
+    }).then((items) => {
+      this.items = items;
+      this.isCompleted = true;
+    });
+  }
+  addItems(items) {
+    var _a, _b, _c;
+    const parentData = (_a = this.parentContext) == null ? void 0 : _a.promise;
+    if (parentData) {
+      (_b = this._resolve) == null ? void 0 : _b.call(this, parentData.then(() => items));
+      return;
+    }
+    (_c = this._resolve) == null ? void 0 : _c.call(this, items);
+  }
+  setIsCompletedAsyncIterator() {
+    this.isCompletedAsyncIterator = true;
+  }
+}