@graphitation/supermassive 2.5.0 → 3.0.0-alpha.1

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,
@@ -28,6 +64,7 @@ __export(executeWithoutSchema_exports, {
 });
 module.exports = __toCommonJS(executeWithoutSchema_exports);
 var import_graphql = require("graphql");
+var import_supermassive_ast = require("./supermassive-ast");
 var import_collectFields = require("./collectFields");
 var import_devAssert = require("./jsutils/devAssert");
 var import_inspect = require("./jsutils/inspect");
@@ -43,47 +80,28 @@ 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("./directives");
+var import_memoize3 = require("./jsutils/memoize3");
+const collectSubfields = (0, import_memoize3.memoize3)(
+  (exeContext, returnTypeName, fieldGroup) => (0, import_collectFields.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 ? (0, import_mergeResolvers.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);
+    return executeOperation(exeContext);
   }
 }
-function buildResponse(exeContext, data) {
-  if ((0, import_isPromise.isPromise)(data)) {
-    return data.then(
-      (resolved) => buildResponse(exeContext, resolved)
-    );
-  }
-  return exeContext.errors.length === 0 ? { data } : { errors: exeContext.errors, data };
-}
 function assertValidExecutionArguments(document, rawVariableValues) {
   (0, import_devAssert.devAssert)(document, "Must provide document.");
   (0, import_devAssert.devAssert)(
@@ -91,8 +109,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 ? (0, import_mergeResolvers.mergeResolvers)(resolvers, schemaResolvers) : resolvers;
   let operation;
   const fragments = /* @__PURE__ */ Object.create(null);
   for (const definition of document.definitions) {
@@ -124,64 +158,135 @@ function buildExecutionContext(resolvers, document, rootValue, contextValue, raw
   }
   const variableDefinitions = (_b = operation.variableDefinitions) != null ? _b : [];
   const coercedVariableValues = (0, import_values.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 = (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, resolvers, fragments, variableValues } = exeContext;
+  const rootTypeName = getOperationRootTypeName(operation);
+  const { groupedFieldSet, patches } = (0, import_collectFields.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 ((0, import_isPromise.isPromise)(result)) {
-      return result.then(void 0, (error) => {
+  let result;
+  switch (operation.operation) {
+    case import_supermassive_ast.OperationTypeNode.QUERY:
+      result = executeFields(
+        exeContext,
+        rootTypeName,
+        rootValue,
+        path,
+        groupedFieldSet,
+        void 0
+      );
+      result = buildResponse(exeContext, result);
+      break;
+    case import_supermassive_ast.OperationTypeNode.MUTATION:
+      result = executeFieldsSerially(
+        exeContext,
+        rootTypeName,
+        rootValue,
+        path,
+        groupedFieldSet
+      );
+      result = buildResponse(exeContext, result);
+      break;
+    case import_supermassive_ast.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 +303,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,9 +328,8 @@ 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;
+function executeField(exeContext, parentTypeName, source, fieldGroup, path, incrementalDataRecord) {
+  const fieldName = fieldGroup[0].name.value;
   let resolveFn;
   let returnTypeName;
   let returnTypeNode;
@@ -239,7 +344,7 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
       }
     };
   } else {
-    returnTypeNode = fieldNodes[0].__type;
+    returnTypeNode = fieldGroup[0].__type;
     returnTypeName = (0, import_typeNameFromAST.typeNameFromAST)(returnTypeNode);
     const typeResolvers = exeContext.resolvers[parentTypeName];
     resolveFn = typeResolvers == null ? void 0 : typeResolvers[fieldName];
@@ -254,22 +359,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 ((0, import_isPromise.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 } = (0, import_collectFields.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: import_graphql.Kind.NAMED_TYPE,
+      name: {
+        kind: import_graphql.Kind.NAME,
+        value: "String"
+      }
+    };
+  } else {
+    returnTypeNode = fieldGroup[0].__type;
+    returnTypeName = (0, import_typeNameFromAST.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 = (0, import_Path.addPath)(void 0, responseName, typeName);
+  const info = buildResolveInfo(
+    exeContext,
+    fieldName,
+    fieldGroup,
+    typeName,
+    returnTypeName,
+    returnTypeNode,
+    path
+  );
+  try {
+    const args = (0, import_values.getArgumentValues)(resolvers, fieldGroup[0], variableValues);
+    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, 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 = (0, import_graphql.locatedError)(
+    rawError,
+    fieldGroup,
+    (0, import_Path.pathToArray)(path)
+  );
+  if (returnTypeNode.kind === import_graphql.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 = (0, import_values.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 ((0, import_isPromise.isPromise)(result)) {
@@ -281,10 +551,11 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
           return completeValue(
             exeContext,
             returnTypeNode,
-            fieldNodes,
+            fieldGroup,
             info,
             path,
-            resolved
+            resolved,
+            incrementalDataRecord
           );
         },
         (rawError) => {
@@ -301,10 +572,11 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
       completed = completeValue(
         exeContext,
         returnTypeNode,
-        fieldNodes,
+        fieldGroup,
         info,
         path,
-        result
+        result,
+        incrementalDataRecord
       );
     }
     if ((0, import_isPromise.isPromise)(completed)) {
@@ -318,13 +590,21 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
         (rawError) => {
           const error = (0, import_graphql.locatedError)(
             rawError,
-            fieldNodes,
+            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,
+            returnTypeNode,
+            fieldGroup,
+            path,
+            incrementalDataRecord
+          );
+          return null;
         }
       );
     }
@@ -336,7 +616,7 @@ function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
     const pathArray = (0, import_Path.pathToArray)(path);
     const error = (0, import_graphql.locatedError)(
       rawError,
-      fieldNodes,
+      fieldGroup,
       pathArray
     );
     if (!isDefaultResolverUsed && (hooks == null ? void 0 : hooks.afterFieldResolve) && error.path && (0, import_array.arraysAreEqual)(pathArray, error.path)) {
@@ -345,31 +625,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 === import_graphql.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;
   }
@@ -377,10 +644,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(
@@ -395,11 +663,12 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
   if (returnTypeNode.kind === import_graphql.Kind.LIST_TYPE) {
     return completeListValue(
       exeContext,
-      returnTypeNode.type,
-      fieldNodes,
+      returnTypeNode,
+      fieldGroup,
       info,
       path,
-      result
+      result,
+      incrementalDataRecord
     );
   }
   const returnTypeName = returnTypeNode.name.value;
@@ -416,20 +685,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
     );
   }
   (0, import_invariant.invariant)(
@@ -437,60 +707,235 @@ function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resul
     "Cannot complete value of unexpected output type: " + (0, import_inspect.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 ((0, import_isPromise.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 ((0, import_isAsyncIterable.isAsyncIterable)(result)) {
+    const asyncIterator = result[Symbol.asyncIterator]();
+    return completeAsyncIteratorValue(
+      exeContext,
+      itemType,
+      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,
+        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 ((0, import_isPromise.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 ((0, import_isPromise.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 = (0, import_values.getDirectiveValues)(
+    import_directives.GraphQLStreamDirective,
+    fieldGroup[0],
+    exeContext.resolvers,
+    exeContext.variableValues
+  );
+  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_supermassive_ast.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 ((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,
+        itemType,
+        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,7 +946,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;
@@ -511,20 +956,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) {
@@ -563,31 +1008,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 = (0, import_collectFields.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;
@@ -698,11 +1151,412 @@ const defaultFieldResolver = (
 );
 function getOperationRootTypeName(operation) {
   switch (operation.operation) {
-    case "query":
+    case import_supermassive_ast.OperationTypeNode.QUERY:
       return "Query";
-    case "mutation":
+    case import_supermassive_ast.OperationTypeNode.MUTATION:
       return "Mutation";
-    case "subscription":
+    case import_supermassive_ast.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, itemTypeNode, label, parentContext) {
+  const incrementalDataRecord = new StreamItemsRecord({
+    label,
+    path: itemPath,
+    parentContext,
+    exeContext
+  });
+  if ((0, import_isPromise.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 ((0, import_isPromise.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 (0, import_graphql.locatedError)(
+        rawError,
+        fieldGroup,
+        (0, import_Path.pathToArray)(path)
+      );
+    }
+    let completedItem;
+    try {
+      completedItem = completeValue(
+        exeContext,
+        itemTypeNode,
+        fieldGroup,
+        info,
+        itemPath,
+        item,
+        incrementalDataRecord
+      );
+      if ((0, import_isPromise.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 = (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,
+          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 ((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;
+  }
+}