@graphitation/supermassive 2.5.0 → 3.0.0-alpha.1

package/lib/executeWithoutSchema.mjs

@@ -1,3 +1,43 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __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());
+  });
+};
+
 // src/executeWithoutSchema.ts
 import {
   GraphQLEnumType,
@@ -8,7 +48,13 @@ import {
   Kind,
   locatedError
 } from "graphql";
-import { collectFields } from "./collectFields.mjs";
+import {
+  OperationTypeNode
+} from "./supermassive-ast/index.mjs";
+import {
+  collectFields,
+  collectSubfields as _collectSubfields
+} from "./collectFields.mjs";
 import { devAssert } from "./jsutils/devAssert.mjs";
 import { inspect } from "./jsutils/inspect.mjs";
 import { invariant } from "./jsutils/invariant.mjs";
@@ -24,49 +70,31 @@ import { typeNameFromAST } from "./utilities/typeNameFromAST.mjs";
 import {
   getArgumentValues,
   getVariableValues,
-  specifiedScalars
+  specifiedScalars,
+  getDirectiveValues
 } from "./values.mjs";
 import { arraysAreEqual } from "./utilities/array.mjs";
+import { isAsyncIterable } from "./jsutils/isAsyncIterable.mjs";
+import { mapAsyncIterator } from "./utilities/mapAsyncIterator.mjs";
+import { GraphQLStreamDirective } from "./directives.mjs";
+import { memoize3 } from "./jsutils/memoize3.mjs";
+var collectSubfields = memoize3(
+  (exeContext, returnTypeName, fieldGroup) => _collectSubfields(
+    exeContext.resolvers,
+    exeContext.fragments,
+    exeContext.variableValues,
+    exeContext.operation,
+    returnTypeName.name,
+    fieldGroup
+  )
+);
 function executeWithoutSchema(args) {
-  const {
-    resolvers,
-    schemaResolvers,
-    document,
-    rootValue,
-    contextValue,
-    variableValues,
-    operationName,
-    fieldResolver,
-    typeResolver,
-    fieldExecutionHooks
-  } = args;
-  const combinedResolvers = schemaResolvers ? mergeResolvers(resolvers, schemaResolvers) : resolvers;
-  assertValidExecutionArguments(document, variableValues);
-  const exeContext = buildExecutionContext(
-    combinedResolvers,
-    document,
-    rootValue,
-    contextValue,
-    variableValues,
-    operationName,
-    fieldResolver,
-    typeResolver,
-    fieldExecutionHooks
-  );
+  const exeContext = buildExecutionContext(args);
   if (!("resolvers" in exeContext)) {
     return { errors: exeContext };
   } else {
-    const data = executeOperation(exeContext, exeContext.operation, rootValue);
-    return buildResponse(exeContext, data);
-  }
-}
-function buildResponse(exeContext, data) {
-  if (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) {
   devAssert(document, "Must provide document.");
@@ -75,8 +103,24 @@ 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,
+    schemaResolvers,
+    document,
+    rootValue,
+    contextValue,
+    buildContextValue,
+    variableValues,
+    operationName,
+    fieldResolver,
+    typeResolver,
+    subscribeFieldResolver,
+    fieldExecutionHooks
+  } = args;
+  assertValidExecutionArguments(document, variableValues);
+  const combinedResolvers = schemaResolvers ? mergeResolvers(resolvers, schemaResolvers) : resolvers;
   let operation;
   const fragments = /* @__PURE__ */ Object.create(null);
   for (const definition of document.definitions) {
@@ -108,64 +152,135 @@ function buildExecutionContext(resolvers, document, rootValue, contextValue, raw
   }
   const variableDefinitions = (_b = operation.variableDefinitions) != null ? _b : [];
   const coercedVariableValues = getVariableValues(
-    resolvers,
+    combinedResolvers,
     variableDefinitions,
-    rawVariableValues != null ? rawVariableValues : {},
+    variableValues != null ? variableValues : {},
     { maxErrors: 50 }
   );
   if (coercedVariableValues.errors) {
     return coercedVariableValues.errors;
   }
   return {
-    resolvers,
+    resolvers: combinedResolvers,
     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 = 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, resolvers, fragments, variableValues } = exeContext;
+  const rootTypeName = getOperationRootTypeName(operation);
+  const { groupedFieldSet, patches } = collectFields(
+    resolvers,
+    fragments,
+    variableValues,
+    rootTypeName,
+    operation
   );
   const path = void 0;
-  try {
-    const result = operation.operation === "mutation" ? executeFieldsSerially(exeContext, typeName, rootValue, path, fields) : executeFields(exeContext, typeName, rootValue, path, fields);
-    if (isPromise(result)) {
-      return result.then(void 0, (error) => {
+  let result;
+  switch (operation.operation) {
+    case OperationTypeNode.QUERY:
+      result = executeFields(
+        exeContext,
+        rootTypeName,
+        rootValue,
+        path,
+        groupedFieldSet,
+        void 0
+      );
+      result = buildResponse(exeContext, result);
+      break;
+    case OperationTypeNode.MUTATION:
+      result = executeFieldsSerially(
+        exeContext,
+        rootTypeName,
+        rootValue,
+        path,
+        groupedFieldSet
+      );
+      result = buildResponse(exeContext, result);
+      break;
+    case 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 (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 promiseReduce(
-    fields.entries(),
-    (results, [responseName, fieldNodes]) => {
+    groupedFieldSet,
+    (results, [responseName, fieldGroup]) => {
       const fieldPath = addPath(path, responseName, parentTypeName);
       const result = executeField(
         exeContext,
         parentTypeName,
         sourceValue,
-        fieldNodes,
-        fieldPath
+        fieldGroup,
+        fieldPath,
+        void 0
       );
       if (result === void 0) {
         return results;
@@ -182,17 +297,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 = addPath(path, responseName, parentTypeName);
     const result = executeField(
       exeContext,
       parentTypeName,
       sourceValue,
-      fieldNodes,
-      fieldPath
+      fieldGroup,
+      fieldPath,
+      incrementalDataRecord
     );
     if (result !== void 0) {
       results[responseName] = result;
@@ -206,9 +322,8 @@ function executeFields(exeContext, parentTypeName, sourceValue, path, fields) {
   }
   return promiseForObject(results);
 }
-function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
-  const fieldName = fieldNodes[0].name.value;
-  const hooks = exeContext.fieldExecutionHooks;
+function executeField(exeContext, parentTypeName, source, fieldGroup, path, incrementalDataRecord) {
+  const fieldName = fieldGroup[0].name.value;
   let resolveFn;
   let returnTypeName;
   let returnTypeNode;
@@ -223,7 +338,7 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
       }
     };
   } else {
-    returnTypeNode = fieldNodes[0].__type;
+    returnTypeNode = fieldGroup[0].__type;
     returnTypeName = typeNameFromAST(returnTypeNode);
     const typeResolvers = exeContext.resolvers[parentTypeName];
     resolveFn = typeResolvers == null ? void 0 : typeResolvers[fieldName];
@@ -238,22 +353,187 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
   const info = buildResolveInfo(
     exeContext,
     fieldName,
-    fieldNodes,
+    fieldGroup,
     parentTypeName,
     returnTypeName,
     returnTypeNode,
     path
   );
+  return resolveAndCompleteField(
+    exeContext,
+    returnTypeNode,
+    fieldGroup,
+    info,
+    path,
+    resolveFn,
+    source,
+    incrementalDataRecord,
+    isDefaultResolverUsed
+  );
+}
+function createSourceEventStream(exeContext) {
+  try {
+    const eventStream = executeSubscriptionImpl(exeContext);
+    if (isPromise(eventStream)) {
+      return eventStream.then(void 0, (error) => ({ errors: [error] }));
+    }
+    return eventStream;
+  } catch (error) {
+    return { errors: [error] };
+  }
+}
+function executeSubscriptionImpl(exeContext) {
+  const { resolvers, fragments, operation, variableValues, rootValue } = exeContext;
+  const typeName = getOperationRootTypeName(operation);
+  const { groupedFieldSet } = collectFields(
+    resolvers,
+    fragments,
+    variableValues,
+    typeName,
+    operation
+  );
+  const firstRootField = groupedFieldSet.entries().next().value;
+  const [responseName, fieldGroup] = firstRootField;
+  const fieldName = fieldGroup[0].name.value;
+  let resolveFn;
+  let returnTypeName;
+  let returnTypeNode;
+  if (fieldName === "__typename" && !resolveFn) {
+    resolveFn = () => typeName;
+    returnTypeName = "String";
+    returnTypeNode = {
+      kind: Kind.NAMED_TYPE,
+      name: {
+        kind: Kind.NAME,
+        value: "String"
+      }
+    };
+  } else {
+    returnTypeNode = fieldGroup[0].__type;
+    returnTypeName = typeNameFromAST(returnTypeNode);
+    const typeResolvers = exeContext.resolvers[typeName];
+    const fieldResolver = typeResolvers == null ? void 0 : typeResolvers[fieldName];
+    resolveFn = fieldResolver == null ? void 0 : fieldResolver.subscribe;
+  }
+  if (!resolveFn) {
+    resolveFn = exeContext.subscribeFieldResolver;
+  }
+  const path = addPath(void 0, responseName, typeName);
+  const info = buildResolveInfo(
+    exeContext,
+    fieldName,
+    fieldGroup,
+    typeName,
+    returnTypeName,
+    returnTypeNode,
+    path
+  );
+  try {
+    const args = getArgumentValues(resolvers, fieldGroup[0], variableValues);
+    const contextValue = exeContext.contextValue;
+    const result = resolveFn(rootValue, args, contextValue, info);
+    if (isPromise(result)) {
+      return result.then(assertEventStream).then(void 0, (error) => {
+        throw locatedError(
+          error,
+          fieldGroup,
+          pathToArray(path)
+        );
+      });
+    }
+    return assertEventStream(result);
+  } catch (error) {
+    throw locatedError(
+      error,
+      fieldGroup,
+      pathToArray(path)
+    );
+  }
+}
+function assertEventStream(result) {
+  if (result instanceof Error) {
+    throw result;
+  }
+  if (!isAsyncIterable(result)) {
+    throw new GraphQLError(
+      `Subscription field must return Async Iterable. Received: ${inspect(result)}.`
+    );
+  }
+  return result;
+}
+function mapResultOrEventStreamOrPromise(resultOrStreamOrPromise, exeContext, parentTypeName, path, groupedFieldSet) {
+  if (isPromise(resultOrStreamOrPromise)) {
+    return resultOrStreamOrPromise.then(
+      (resultOrStream) => mapResultOrEventStreamOrPromise(
+        resultOrStream,
+        exeContext,
+        parentTypeName,
+        path,
+        groupedFieldSet
+      )
+    );
+  } else {
+    if (!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 mapAsyncIterator(resultOrStreamOrPromise, mapSourceToResponse);
+    }
+  }
+}
+function buildResolveInfo(exeContext, fieldName, fieldGroup, parentTypeName, returnTypeName, returnTypeNode, path) {
+  return {
+    fieldName,
+    fieldGroup,
+    returnTypeName,
+    parentTypeName,
+    returnTypeNode,
+    path,
+    fragments: exeContext.fragments,
+    rootValue: exeContext.rootValue,
+    operation: exeContext.operation,
+    variableValues: exeContext.variableValues
+  };
+}
+function handleFieldError(rawError, exeContext, returnTypeNode, fieldGroup, path, incrementalDataRecord) {
+  var _a;
+  const error = locatedError(
+    rawError,
+    fieldGroup,
+    pathToArray(path)
+  );
+  if (returnTypeNode.kind === Kind.NON_NULL_TYPE) {
+    throw error;
+  }
+  const errors = (_a = incrementalDataRecord == null ? void 0 : incrementalDataRecord.errors) != null ? _a : exeContext.errors;
+  errors.push(error);
+}
+function resolveAndCompleteField(exeContext, returnTypeNode, fieldGroup, info, path, resolveFn, source, incrementalDataRecord, isDefaultResolverUsed) {
+  const hooks = exeContext.fieldExecutionHooks;
   try {
     const args = getArgumentValues(
       exeContext.resolvers,
-      fieldNodes[0],
+      fieldGroup[0],
       exeContext.variableValues
     );
+    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 (isPromise(result)) {
@@ -265,10 +545,11 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
           return completeValue(
             exeContext,
             returnTypeNode,
-            fieldNodes,
+            fieldGroup,
             info,
             path,
-            resolved
+            resolved,
+            incrementalDataRecord
           );
         },
         (rawError) => {
@@ -285,10 +566,11 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
       completed = completeValue(
         exeContext,
         returnTypeNode,
-        fieldNodes,
+        fieldGroup,
         info,
         path,
-        result
+        result,
+        incrementalDataRecord
       );
     }
     if (isPromise(completed)) {
@@ -302,13 +584,21 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
         (rawError) => {
           const error = locatedError(
             rawError,
-            fieldNodes,
+            fieldGroup,
             pathToArray(path)
           );
           if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldComplete)) {
             invokeAfterFieldCompleteHook(info, exeContext, void 0, error);
           }
-          return handleFieldError(error, returnTypeNode, exeContext);
+          handleFieldError(
+            rawError,
+            exeContext,
+            returnTypeNode,
+            fieldGroup,
+            path,
+            incrementalDataRecord
+          );
+          return null;
         }
       );
     }
@@ -320,7 +610,7 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
     const pathArray = pathToArray(path);
     const error = locatedError(
       rawError,
-      fieldNodes,
+      fieldGroup,
       pathArray
     );
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve) && error.path && arraysAreEqual(pathArray, error.path)) {
@@ -329,31 +619,18 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
     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 === Kind.NON_NULL_TYPE) {
-    throw error;
+    handleFieldError(
+      rawError,
+      exeContext,
+      returnTypeNode,
+      fieldGroup,
+      path,
+      incrementalDataRecord
+    );
+    return null;
   }
-  exeContext.errors.push(error);
-  return null;
 }
-function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, result) {
+function completeValue(exeContext, returnTypeNode, fieldGroup, info, path, result, incrementalDataRecord) {
   if (result instanceof Error) {
     throw result;
   }
@@ -361,10 +638,11 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
     const completed = completeValue(
       exeContext,
       returnTypeNode.type,
-      fieldNodes,
+      fieldGroup,
       info,
       path,
-      result
+      result,
+      incrementalDataRecord
     );
     if (completed === null) {
       throw new Error(
@@ -379,11 +657,12 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
   if (returnTypeNode.kind === Kind.LIST_TYPE) {
     return completeListValue(
       exeContext,
-      returnTypeNode.type,
-      fieldNodes,
+      returnTypeNode,
+      fieldGroup,
       info,
       path,
-      result
+      result,
+      incrementalDataRecord
     );
   }
   const returnTypeName = returnTypeNode.name.value;
@@ -400,20 +679,21 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
     return completeAbstractValue(
       exeContext,
       returnType,
-      fieldNodes,
+      fieldGroup,
       info,
       path,
-      result
+      result,
+      incrementalDataRecord
     );
   }
   if (typeof returnType === "object") {
     return completeObjectValue(
       exeContext,
       returnTypeName,
-      fieldNodes,
-      info,
+      fieldGroup,
       path,
-      result
+      result,
+      incrementalDataRecord
     );
   }
   invariant(
@@ -421,60 +701,235 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
     "Cannot complete value of unexpected output type: " + inspect(returnType)
   );
 }
-function completeListValue(exeContext, returnTypeNode, fieldNodes, info, path, result) {
+function completePromisedValue(exeContext, returnTypeNode, fieldGroup, info, path, result, incrementalDataRecord) {
+  return __async(this, null, function* () {
+    try {
+      const resolved = yield result;
+      let completed = completeValue(
+        exeContext,
+        returnTypeNode,
+        fieldGroup,
+        info,
+        path,
+        resolved,
+        incrementalDataRecord
+      );
+      if (isPromise(completed)) {
+        completed = yield completed;
+      }
+      return completed;
+    } catch (rawError) {
+      handleFieldError(
+        rawError,
+        exeContext,
+        returnTypeNode,
+        fieldGroup,
+        path,
+        incrementalDataRecord
+      );
+      filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+      return null;
+    }
+  });
+}
+function completeListValue(exeContext, returnTypeNode, fieldGroup, info, path, result, incrementalDataRecord) {
+  const itemType = returnTypeNode.type;
+  if (isAsyncIterable(result)) {
+    const asyncIterator = result[Symbol.asyncIterator]();
+    return completeAsyncIteratorValue(
+      exeContext,
+      itemType,
+      fieldGroup,
+      info,
+      path,
+      asyncIterator,
+      incrementalDataRecord
+    );
+  }
   if (!isIterableObject(result)) {
     throw new 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 = addPath(path, index, void 0);
-    try {
-      let completedItem;
-      if (isPromise(item)) {
-        completedItem = item.then(
-          (resolved) => completeValue(
+    if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
+      previousIncrementalDataRecord = executeStreamField(
+        path,
+        itemPath,
+        item,
+        exeContext,
+        fieldGroup,
+        info,
+        itemType,
+        stream.label,
+        previousIncrementalDataRecord
+      );
+      index++;
+      continue;
+    }
+    if (completeListItemValue(
+      item,
+      completedResults,
+      exeContext,
+      itemType,
+      fieldGroup,
+      info,
+      itemPath,
+      incrementalDataRecord
+    )) {
+      containsPromise = true;
+    }
+    index++;
+  }
+  return containsPromise ? Promise.all(completedResults) : completedResults;
+}
+function completeListItemValue(item, completedResults, exeContext, itemTypeNode, fieldGroup, info, itemPath, incrementalDataRecord) {
+  if (isPromise(item)) {
+    completedResults.push(
+      completePromisedValue(
+        exeContext,
+        itemTypeNode,
+        fieldGroup,
+        info,
+        itemPath,
+        item,
+        incrementalDataRecord
+      )
+    );
+    return true;
+  }
+  try {
+    const completedItem = completeValue(
+      exeContext,
+      itemTypeNode,
+      fieldGroup,
+      info,
+      itemPath,
+      item,
+      incrementalDataRecord
+    );
+    if (isPromise(completedItem)) {
+      completedResults.push(
+        completedItem.then(void 0, (rawError) => {
+          handleFieldError(
+            rawError,
             exeContext,
-            returnTypeNode,
-            fieldNodes,
-            info,
+            itemTypeNode,
+            fieldGroup,
             itemPath,
-            resolved
-          )
-        );
-      } else {
-        completedItem = completeValue(
+            incrementalDataRecord
+          );
+          filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+          return null;
+        })
+      );
+      return true;
+    }
+    completedResults.push(completedItem);
+  } catch (rawError) {
+    handleFieldError(
+      rawError,
+      exeContext,
+      itemTypeNode,
+      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 = getDirectiveValues(
+    GraphQLStreamDirective,
+    fieldGroup[0],
+    exeContext.resolvers,
+    exeContext.variableValues
+  );
+  if (!stream) {
+    return;
+  }
+  if (stream.if === false) {
+    return;
+  }
+  invariant(
+    typeof stream.initialCount === "number",
+    "initialCount must be a number"
+  );
+  invariant(
+    stream.initialCount >= 0,
+    "initialCount must be a positive integer"
+  );
+  invariant(
+    exeContext.operation.operation !== 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, itemType, 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
+          itemType,
+          path,
+          stream.label,
+          incrementalDataRecord
         );
+        break;
       }
-      if (isPromise(completedItem)) {
+      const itemPath = addPath(path, index, void 0);
+      let iteration;
+      try {
+        iteration = yield asyncIterator.next();
+        if (iteration.done) {
+          break;
+        }
+      } catch (rawError) {
+        throw locatedError(
+          rawError,
+          fieldGroup,
+          pathToArray(path)
+        );
+      }
+      if (completeListItemValue(
+        iteration.value,
+        completedResults,
+        exeContext,
+        itemType,
+        fieldGroup,
+        info,
+        itemPath,
+        incrementalDataRecord
+      )) {
         containsPromise = true;
-        return completedItem.then(void 0, (rawError) => {
-          const error = locatedError(
-            rawError,
-            fieldNodes,
-            pathToArray(itemPath)
-          );
-          return handleFieldError(error, returnTypeNode, exeContext);
-        });
       }
-      return completedItem;
-    } catch (rawError) {
-      const error = locatedError(
-        rawError,
-        fieldNodes,
-        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);
@@ -485,7 +940,7 @@ function completeLeafValue(returnType, result) {
   }
   return serializedResult;
 }
-function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result) {
+function completeAbstractValue(exeContext, returnType, fieldGroup, info, path, result, incrementalDataRecord) {
   var _a;
   const resolveTypeFn = (_a = returnType.__resolveType) != null ? _a : exeContext.typeResolver;
   const contextValue = exeContext.contextValue;
@@ -495,20 +950,20 @@ function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, r
       (resolvedRuntimeTypeName) => completeObjectValue(
         exeContext,
         ensureValidRuntimeType(resolvedRuntimeTypeName, exeContext),
-        fieldNodes,
-        info,
+        fieldGroup,
         path,
-        result
+        result,
+        incrementalDataRecord
       )
     );
   }
   return completeObjectValue(
     exeContext,
     ensureValidRuntimeType(runtimeTypeName, exeContext),
-    fieldNodes,
-    info,
+    fieldGroup,
     path,
-    result
+    result,
+    incrementalDataRecord
   );
 }
 function ensureValidRuntimeType(runtimeTypeName, exeContext) {
@@ -547,31 +1002,39 @@ function getRuntimeTypeInstanceName(runtimeType) {
     return "Unknown";
   }
 }
-function completeObjectValue(exeContext, returnTypeName, fieldNodes, _info, path, result) {
-  const subFieldNodes = collectSubfields(
+function completeObjectValue(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord) {
+  return collectAndExecuteSubfields(
     exeContext,
     returnTypeName,
-    fieldNodes
+    fieldGroup,
+    path,
+    result,
+    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 = collectFields(
-        exeContext.resolvers,
-        exeContext.fragments,
-        exeContext.variableValues,
-        returnTypeName,
-        node.selectionSet,
-        subFieldNodes,
-        visitedFragmentNames
-      );
-    }
+}
+function collectAndExecuteSubfields(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord) {
+  const { groupedFieldSet: subGroupedFieldSet, patches: subPatches } = collectSubfields(exeContext, { name: returnTypeName }, fieldGroup);
+  const subFields = executeFields(
+    exeContext,
+    returnTypeName,
+    result,
+    path,
+    subGroupedFieldSet,
+    incrementalDataRecord
+  );
+  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;
@@ -682,17 +1145,417 @@ var defaultFieldResolver = (
 );
 function getOperationRootTypeName(operation) {
   switch (operation.operation) {
-    case "query":
+    case OperationTypeNode.QUERY:
       return "Query";
-    case "mutation":
+    case OperationTypeNode.MUTATION:
       return "Mutation";
-    case "subscription":
+    case 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 (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, itemTypeNode, label, parentContext) {
+  const incrementalDataRecord = new StreamItemsRecord({
+    label,
+    path: itemPath,
+    parentContext,
+    exeContext
+  });
+  if (isPromise(item)) {
+    const completedItems = completePromisedValue(
+      exeContext,
+      itemTypeNode,
+      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,
+        itemTypeNode,
+        fieldGroup,
+        info,
+        itemPath,
+        item,
+        incrementalDataRecord
+      );
+    } catch (rawError) {
+      handleFieldError(
+        rawError,
+        exeContext,
+        itemTypeNode,
+        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 (isPromise(completedItem)) {
+    const completedItems = completedItem.then(void 0, (rawError) => {
+      handleFieldError(
+        rawError,
+        exeContext,
+        itemTypeNode,
+        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, itemTypeNode, 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 locatedError(
+        rawError,
+        fieldGroup,
+        pathToArray(path)
+      );
+    }
+    let completedItem;
+    try {
+      completedItem = completeValue(
+        exeContext,
+        itemTypeNode,
+        fieldGroup,
+        info,
+        itemPath,
+        item,
+        incrementalDataRecord
+      );
+      if (isPromise(completedItem)) {
+        completedItem = completedItem.then(void 0, (rawError) => {
+          handleFieldError(
+            rawError,
+            exeContext,
+            itemTypeNode,
+            fieldGroup,
+            itemPath,
+            incrementalDataRecord
+          );
+          filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+          return null;
+        });
+      }
+      return { done: false, value: completedItem };
+    } catch (rawError) {
+      handleFieldError(
+        rawError,
+        exeContext,
+        itemTypeNode,
+        fieldGroup,
+        itemPath,
+        incrementalDataRecord
+      );
+      filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+      return { done: false, value: null };
+    }
+  });
+}
+function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fieldGroup, info, itemTypeNode, path, label, parentContext) {
+  return __async(this, null, function* () {
+    let index = initialIndex;
+    let previousIncrementalDataRecord = parentContext != null ? parentContext : void 0;
+    while (true) {
+      const itemPath = 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,
+          itemTypeNode,
+          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 (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 = 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";
+}
+var DeferredFragmentRecord = class {
+  constructor(opts) {
+    this.type = "defer";
+    this.label = opts.label;
+    this.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);
+  }
+};
+var StreamItemsRecord = class {
+  constructor(opts) {
+    this.type = "stream";
+    this.items = null;
+    this.label = opts.label;
+    this.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;
+  }
+};
 export {
   assertValidExecutionArguments,
-  buildExecutionContext,
   buildResolveInfo,
   defaultFieldResolver,
   defaultTypeResolver,