@graphql-tools/executor 0.0.3-alpha-20221031195032-ea7637a2 → 0.0.3-alpha-20221031225249-642ec6e9

package/cjs/execution/execute.js

@@ -1,19 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFieldDef = exports.createSourceEventStream = exports.experimentalSubscribeIncrementally = exports.subscribe = exports.defaultFieldResolver = exports.defaultTypeResolver = exports.buildResolveInfo = exports.buildExecutionContext = exports.assertValidExecutionArguments = exports.executeSync = exports.experimentalExecuteIncrementally = exports.execute = void 0;
+exports.getFieldDef = exports.createSourceEventStream = exports.subscribe = exports.defaultFieldResolver = exports.defaultTypeResolver = exports.buildResolveInfo = exports.buildExecutionContext = exports.assertValidExecutionArguments = exports.executeSync = exports.execute = void 0;
 const graphql_1 = require("graphql");
 const utils_1 = require("@graphql-tools/utils");
 const values_js_1 = require("./values.js");
-const promiseForObject_js_1 = require("./promiseForObject.js");
-const flattenAsyncIterable_js_1 = require("./flattenAsyncIterable.js");
-const invariant_js_1 = require("./invariant.js");
-/**
- * A memoized collection of relevant subfields with regard to the return
- * type. Memoizing ensures the subfields are not repeatedly calculated, which
- * saves overhead when resolving lists of values.
- */
-const collectSubfields = (0, utils_1.memoize3)((exeContext, returnType, fieldNodes) => (0, utils_1.collectSubFields)(exeContext.schema, exeContext.fragments, exeContext.variableValues, returnType, fieldNodes));
-const UNEXPECTED_MULTIPLE_PAYLOADS = 'Executing this GraphQL operation would unexpectedly produce multiple payloads (due to @defer or @stream directive)';
 /**
  * Implements the "Executing requests" section of the GraphQL specification.
  *
@@ -23,44 +13,8 @@ const UNEXPECTED_MULTIPLE_PAYLOADS = 'Executing this GraphQL operation would une
  *
  * If the arguments to this function do not result in a legal execution context,
  * a GraphQLError will be thrown immediately explaining the invalid input.
- *
- * This function does not support incremental delivery (`@defer` and `@stream`).
- * If an operation which would defer or stream data is executed with this
- * function, it will throw or resolve to an object containing an error instead.
- * Use `experimentalExecuteIncrementally` if you want to support incremental
- * delivery.
  */
 function execute(args) {
-    const result = experimentalExecuteIncrementally(args);
-    if (!(0, utils_1.isPromise)(result)) {
-        if ('initialResult' in result) {
-            throw new Error(UNEXPECTED_MULTIPLE_PAYLOADS);
-        }
-        return result;
-    }
-    return result.then(incrementalResult => {
-        if ('initialResult' in incrementalResult) {
-            return {
-                errors: [(0, utils_1.createGraphQLError)(UNEXPECTED_MULTIPLE_PAYLOADS)],
-            };
-        }
-        return incrementalResult;
-    });
-}
-exports.execute = execute;
-/**
- * Implements the "Executing requests" section of the GraphQL specification,
- * including `@defer` and `@stream` as proposed in
- * https://github.com/graphql/graphql-spec/pull/742
- *
- * This function returns a Promise of an ExperimentalIncrementalExecutionResults
- * object. This object either consists of a single ExecutionResult, or an
- * object containing an `initialResult` and a stream of `subsequentResults`.
- *
- * If the arguments to this function do not result in a legal execution context,
- * a GraphQLError will be thrown immediately explaining the invalid input.
- */
-function experimentalExecuteIncrementally(args) {
     // If a valid execution context cannot be created due to incorrect arguments,
     // a "Response" with only errors is returned.
     const exeContext = buildExecutionContext(args);
@@ -70,7 +24,7 @@ function experimentalExecuteIncrementally(args) {
     }
     return executeImpl(exeContext);
 }
-exports.experimentalExecuteIncrementally = experimentalExecuteIncrementally;
+exports.execute = execute;
 function executeImpl(exeContext) {
     // Return a Promise that will eventually resolve to the data described by
     // The "Response" section of the GraphQL specification.
@@ -86,34 +40,12 @@ function executeImpl(exeContext) {
     try {
         const result = executeOperation(exeContext);
         if ((0, utils_1.isPromise)(result)) {
-            return result.then(data => {
-                const initialResult = buildResponse(data, exeContext.errors);
-                if (exeContext.subsequentPayloads.size > 0) {
-                    return {
-                        initialResult: {
-                            ...initialResult,
-                            hasNext: true,
-                        },
-                        subsequentResults: yieldSubsequentPayloads(exeContext),
-                    };
-                }
-                return initialResult;
-            }, error => {
+            return result.then(data => buildResponse(data, exeContext.errors), error => {
                 exeContext.errors.push(error);
                 return buildResponse(null, exeContext.errors);
             });
         }
-        const initialResult = buildResponse(result, exeContext.errors);
-        if (exeContext.subsequentPayloads.size > 0) {
-            return {
-                initialResult: {
-                    ...initialResult,
-                    hasNext: true,
-                },
-                subsequentResults: yieldSubsequentPayloads(exeContext),
-            };
-        }
-        return initialResult;
+        return buildResponse(result, exeContext.errors);
     }
     catch (error) {
         exeContext.errors.push(error);
@@ -126,9 +58,9 @@ function executeImpl(exeContext) {
  * that all field resolvers are also synchronous.
  */
 function executeSync(args) {
-    const result = experimentalExecuteIncrementally(args);
+    const result = execute(args);
     // Assert that the execution was synchronous.
-    if ((0, utils_1.isPromise)(result) || 'initialResult' in result) {
+    if ((0, utils_1.isPromise)(result)) {
         throw new Error('GraphQL execution failed to complete synchronously.');
     }
     return result;
@@ -216,7 +148,6 @@ function buildExecutionContext(args) {
         fieldResolver: fieldResolver !== null && fieldResolver !== void 0 ? fieldResolver : exports.defaultFieldResolver,
         typeResolver: typeResolver !== null && typeResolver !== void 0 ? typeResolver : exports.defaultTypeResolver,
         subscribeFieldResolver: subscribeFieldResolver !== null && subscribeFieldResolver !== void 0 ? subscribeFieldResolver : exports.defaultFieldResolver,
-        subsequentPayloads: new Set(),
         errors: [],
     };
 }
@@ -225,7 +156,6 @@ function buildPerEventExecutionContext(exeContext, payload) {
     return {
         ...exeContext,
         rootValue: payload,
-        subsequentPayloads: new Set(),
         errors: [],
     };
 }
@@ -235,32 +165,26 @@ function buildPerEventExecutionContext(exeContext, payload) {
 function executeOperation(exeContext) {
     const { operation, schema, fragments, variableValues, rootValue } = exeContext;
     const rootType = (0, utils_1.getDefinedRootType)(schema, operation.operation, [operation]);
-    if (rootType == null) {
-        (0, utils_1.createGraphQLError)(`Schema is not configured to execute ${operation.operation} operation.`, {
-            nodes: operation,
-        });
-    }
-    const { fields: rootFields, patches } = (0, utils_1.collectFields)(schema, fragments, variableValues, rootType, operation.selectionSet);
+    const rootFields = (0, utils_1.collectFields)(schema, fragments, variableValues, rootType, operation.selectionSet);
     const path = undefined;
-    let result;
-    if (operation.operation === 'mutation') {
-        result = executeFieldsSerially(exeContext, rootType, rootValue, path, rootFields);
-    }
-    else {
-        result = executeFields(exeContext, rootType, rootValue, path, rootFields);
-    }
-    for (const patch of patches) {
-        const { label, fields: patchFields } = patch;
-        executeDeferredFragment(exeContext, rootType, rootValue, patchFields, label, path);
-    }
-    return result;
+    switch (operation.operation) {
+        case 'query':
+            return executeFields(exeContext, rootType, rootValue, path, rootFields);
+        case 'mutation':
+            return executeFieldsSerially(exeContext, rootType, rootValue, path, rootFields);
+        case 'subscription':
+            // TODO: deprecate `subscribe` and move all logic here
+            // Temporary solution until we finish merging execute and subscribe together
+            return executeFields(exeContext, rootType, rootValue, path, rootFields);
+    }
+    throw new Error(`Can only execute queries, mutations and subscriptions, got "${operation.operation}".`);
 }
 /**
  * Implements the "Executing selection sets" section of the spec
  * for fields that must be executed serially.
  */
 function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields) {
-    return (0, utils_1.promiseReduce)(fields, (results, [responseName, fieldNodes]) => {
+    return (0, utils_1.promiseReduce)(fields.entries(), (results, [responseName, fieldNodes]) => {
         const fieldPath = (0, utils_1.addPath)(path, responseName, parentType.name);
         const result = executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath);
         if (result === undefined) {
@@ -280,30 +204,19 @@ function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields
  * Implements the "Executing selection sets" section of the spec
  * for fields that may be executed in parallel.
  */
-function executeFields(exeContext, parentType, sourceValue, path, fields, asyncPayloadRecord) {
+function executeFields(exeContext, parentType, sourceValue, path, fields) {
     const results = Object.create(null);
     let containsPromise = false;
-    try {
-        for (const [responseName, fieldNodes] of fields) {
-            const fieldPath = (0, utils_1.addPath)(path, responseName, parentType.name);
-            const result = executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath, asyncPayloadRecord);
-            if (result !== undefined) {
-                results[responseName] = result;
-                if ((0, utils_1.isPromise)(result)) {
-                    containsPromise = true;
-                }
+    for (const [responseName, fieldNodes] of fields.entries()) {
+        const fieldPath = (0, utils_1.addPath)(path, responseName, parentType.name);
+        const result = executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath);
+        if (result !== undefined) {
+            results[responseName] = result;
+            if ((0, utils_1.isPromise)(result)) {
+                containsPromise = true;
             }
         }
     }
-    catch (error) {
-        if (containsPromise) {
-            // Ensure that any promises returned by other fields are handled, as they may also reject.
-            return (0, promiseForObject_js_1.promiseForObject)(results).finally(() => {
-                throw error;
-            });
-        }
-        throw error;
-    }
     // If there are no promises, we can just return the object
     if (!containsPromise) {
         return results;
@@ -311,7 +224,13 @@ function executeFields(exeContext, parentType, sourceValue, path, fields, asyncP
     // Otherwise, results is a map from field name to the result of resolving that
     // field, which is possibly a promise. Return a promise that will return this
     // same map, but with any promises replaced with the values they resolved to.
-    return (0, promiseForObject_js_1.promiseForObject)(results);
+    return Promise.all(Object.values(results)).then(resolvedValues => {
+        const resolvedObject = Object.create(null);
+        for (const [i, key] of Object.keys(results).entries()) {
+            resolvedObject[key] = resolvedValues[i];
+        }
+        return resolvedObject;
+    });
 }
 /**
  * Implements the "Executing fields" section of the spec
@@ -319,15 +238,14 @@ function executeFields(exeContext, parentType, sourceValue, path, fields, asyncP
  * calling its resolve function, then calls completeValue to complete promises,
  * serialize scalars, or execute the sub-selection-set for objects.
  */
-function executeField(exeContext, parentType, source, fieldNodes, path, asyncPayloadRecord) {
-    var _a, _b;
-    const errors = (_a = asyncPayloadRecord === null || asyncPayloadRecord === void 0 ? void 0 : asyncPayloadRecord.errors) !== null && _a !== void 0 ? _a : exeContext.errors;
+function executeField(exeContext, parentType, source, fieldNodes, path) {
+    var _a;
     const fieldDef = getFieldDef(exeContext.schema, parentType, fieldNodes[0]);
     if (!fieldDef) {
         return;
     }
     const returnType = fieldDef.type;
-    const resolveFn = (_b = fieldDef.resolve) !== null && _b !== void 0 ? _b : exeContext.fieldResolver;
+    const resolveFn = (_a = fieldDef.resolve) !== null && _a !== void 0 ? _a : exeContext.fieldResolver;
     const info = buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path);
     // Get the resolve function, regardless of if its result is normal or abrupt (error).
     try {
@@ -342,28 +260,24 @@ function executeField(exeContext, parentType, source, fieldNodes, path, asyncPay
         const result = resolveFn(source, args, contextValue, info);
         let completed;
         if ((0, utils_1.isPromise)(result)) {
-            completed = result.then(resolved => completeValue(exeContext, returnType, fieldNodes, info, path, resolved, asyncPayloadRecord));
+            completed = result.then(resolved => completeValue(exeContext, returnType, fieldNodes, info, path, resolved));
         }
         else {
-            completed = completeValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord);
+            completed = completeValue(exeContext, returnType, fieldNodes, info, path, result);
         }
         if ((0, utils_1.isPromise)(completed)) {
             // Note: we don't rely on a `catch` method, but we do expect "thenable"
             // to take a second callback for the error case.
             return completed.then(undefined, rawError => {
                 const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(path));
-                const handledError = handleFieldError(error, returnType, errors);
-                filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
-                return handledError;
+                return handleFieldError(error, returnType, exeContext);
             });
         }
         return completed;
     }
     catch (rawError) {
         const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(path));
-        const handledError = handleFieldError(error, returnType, errors);
-        filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
-        return handledError;
+        return handleFieldError(error, returnType, exeContext);
     }
 }
 /**
@@ -387,7 +301,7 @@ function buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path) {
     };
 }
 exports.buildResolveInfo = buildResolveInfo;
-function handleFieldError(error, returnType, errors) {
+function handleFieldError(error, returnType, exeContext) {
     // If the field type is non-nullable, then it is resolved without any
     // protection from errors, however it still properly locates the error.
     if ((0, graphql_1.isNonNullType)(returnType)) {
@@ -395,7 +309,7 @@ function handleFieldError(error, returnType, errors) {
     }
     // Otherwise, error protection is applied, logging the error and resolving
     // a null value for this field if one is encountered.
-    errors.push(error);
+    exeContext.errors.push(error);
     return null;
 }
 /**
@@ -419,7 +333,7 @@ function handleFieldError(error, returnType, errors) {
  * Otherwise, the field type expects a sub-selection set, and will complete the
  * value by executing all sub-selections.
  */
-function completeValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord) {
+function completeValue(exeContext, returnType, fieldNodes, info, path, result) {
     // If result is an Error, throw a located error.
     if (result instanceof Error) {
         throw result;
@@ -427,7 +341,7 @@ function completeValue(exeContext, returnType, fieldNodes, info, path, result, a
     // If field type is NonNull, complete for inner type, and throw field error
     // if result is null.
     if ((0, graphql_1.isNonNullType)(returnType)) {
-        const completed = completeValue(exeContext, returnType.ofType, fieldNodes, info, path, result, asyncPayloadRecord);
+        const completed = completeValue(exeContext, returnType.ofType, fieldNodes, info, path, result);
         if (completed === null) {
             throw new Error(`Cannot return null for non-nullable field ${info.parentType.name}.${info.fieldName}.`);
         }
@@ -439,7 +353,7 @@ function completeValue(exeContext, returnType, fieldNodes, info, path, result, a
     }
     // If field type is List, complete each item in the list with the inner type
     if ((0, graphql_1.isListType)(returnType)) {
-        return completeListValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord);
+        return completeListValue(exeContext, returnType, fieldNodes, info, path, result);
     }
     // If field type is a leaf type, Scalar or Enum, serialize to a valid value,
     // returning null if serialization is not possible.
@@ -449,74 +363,51 @@ function completeValue(exeContext, returnType, fieldNodes, info, path, result, a
     // If field type is an abstract type, Interface or Union, determine the
     // runtime Object type and complete for that type.
     if ((0, graphql_1.isAbstractType)(returnType)) {
-        return completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord);
+        return completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result);
     }
     // If field type is Object, execute and complete all sub-selections.
     if ((0, graphql_1.isObjectType)(returnType)) {
-        return completeObjectValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord);
+        return completeObjectValue(exeContext, returnType, fieldNodes, info, path, result);
     }
     /* c8 ignore next 6 */
     // Not reachable, all possible output types have been considered.
     console.assert(false, 'Cannot complete value of unexpected output type: ' + (0, utils_1.inspect)(returnType));
 }
-/**
- * Returns an object containing the `@stream` arguments if a field should be
- * streamed based on the experimental flag, stream directive present and
- * not disabled by the "if" argument.
- */
-function getStreamValues(exeContext, fieldNodes, path) {
-    // do not stream inner lists of multi-dimensional lists
-    if (typeof path.key === 'number') {
-        return;
-    }
-    // validation only allows equivalent streams on multiple fields, so it is
-    // safe to only check the first fieldNode for the stream directive
-    const stream = (0, graphql_1.getDirectiveValues)(utils_1.GraphQLStreamDirective, fieldNodes[0], exeContext.variableValues);
-    if (!stream) {
-        return;
-    }
-    if (stream['if'] === false) {
-        return;
-    }
-    (0, invariant_js_1.invariant)(typeof stream['initialCount'] === 'number', 'initialCount must be a number');
-    (0, invariant_js_1.invariant)(stream['initialCount'] >= 0, 'initialCount must be a positive integer');
-    return {
-        initialCount: stream['initialCount'],
-        label: typeof stream['label'] === 'string' ? stream['label'] : undefined,
-    };
-}
 /**
  * Complete a async iterator value by completing the result and calling
  * recursively until all the results are completed.
  */
-async function completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path, iterator, asyncPayloadRecord) {
-    var _a;
-    const errors = (_a = asyncPayloadRecord === null || asyncPayloadRecord === void 0 ? void 0 : asyncPayloadRecord.errors) !== null && _a !== void 0 ? _a : exeContext.errors;
-    const stream = getStreamValues(exeContext, fieldNodes, path);
+async function completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path, iterator) {
     let containsPromise = false;
     const completedResults = [];
     let index = 0;
     while (true) {
-        if (stream && typeof stream.initialCount === 'number' && index >= stream.initialCount) {
-            executeStreamIterator(index, iterator, exeContext, fieldNodes, info, itemType, path, stream.label, asyncPayloadRecord);
-            break;
-        }
-        const itemPath = (0, utils_1.addPath)(path, index, undefined);
-        let iteration;
+        const fieldPath = (0, utils_1.addPath)(path, index, undefined);
         try {
-            iteration = await iterator.next();
-            if (iteration.done) {
+            const { value, done } = await iterator.next();
+            if (done) {
                 break;
             }
+            try {
+                // TODO can the error checking logic be consolidated with completeListValue?
+                const completedItem = completeValue(exeContext, itemType, fieldNodes, info, fieldPath, value);
+                if ((0, utils_1.isPromise)(completedItem)) {
+                    containsPromise = true;
+                }
+                completedResults.push(completedItem);
+            }
+            catch (rawError) {
+                completedResults.push(null);
+                const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(fieldPath));
+                handleFieldError(error, itemType, exeContext);
+            }
         }
         catch (rawError) {
-            const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(itemPath));
-            completedResults.push(handleFieldError(error, itemType, errors));
+            completedResults.push(null);
+            const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(fieldPath));
+            handleFieldError(error, itemType, exeContext);
             break;
         }
-        if (completeListItemValue(iteration.value, completedResults, errors, exeContext, itemType, fieldNodes, info, itemPath, asyncPayloadRecord)) {
-            containsPromise = true;
-        }
         index += 1;
     }
     return containsPromise ? Promise.all(completedResults) : completedResults;
@@ -525,75 +416,48 @@ async function completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info
  * Complete a list value by completing each item in the list with the
  * inner type
  */
-function completeListValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord) {
-    var _a;
+function completeListValue(exeContext, returnType, fieldNodes, info, path, result) {
     const itemType = returnType.ofType;
-    const errors = (_a = asyncPayloadRecord === null || asyncPayloadRecord === void 0 ? void 0 : asyncPayloadRecord.errors) !== null && _a !== void 0 ? _a : exeContext.errors;
     if ((0, utils_1.isAsyncIterable)(result)) {
         const iterator = result[Symbol.asyncIterator]();
-        return completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path, iterator, asyncPayloadRecord);
+        return completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path, iterator);
     }
     if (!(0, utils_1.isIterableObject)(result)) {
         throw (0, utils_1.createGraphQLError)(`Expected Iterable, but did not find one for field "${info.parentType.name}.${info.fieldName}".`);
     }
-    const stream = getStreamValues(exeContext, fieldNodes, path);
     // This is specified as a simple map, however we're optimizing the path
     // where the list contains no Promises by avoiding creating another Promise.
     let containsPromise = false;
-    let previousAsyncPayloadRecord = asyncPayloadRecord;
-    const completedResults = [];
-    let index = 0;
-    for (const item of result) {
+    const completedResults = Array.from(result, (item, index) => {
         // No need to modify the info object containing the path,
         // since from here on it is not ever accessed by resolver functions.
         const itemPath = (0, utils_1.addPath)(path, index, undefined);
-        if (stream && typeof stream.initialCount === 'number' && index >= stream.initialCount) {
-            previousAsyncPayloadRecord = executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, stream.label, previousAsyncPayloadRecord);
-            index++;
-            continue;
+        try {
+            let completedItem;
+            if ((0, utils_1.isPromise)(item)) {
+                completedItem = item.then(resolved => completeValue(exeContext, itemType, fieldNodes, info, itemPath, resolved));
+            }
+            else {
+                completedItem = completeValue(exeContext, itemType, fieldNodes, info, itemPath, item);
+            }
+            if ((0, utils_1.isPromise)(completedItem)) {
+                containsPromise = true;
+                // Note: we don't rely on a `catch` method, but we do expect "thenable"
+                // to take a second callback for the error case.
+                return completedItem.then(undefined, rawError => {
+                    const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(itemPath));
+                    return handleFieldError(error, itemType, exeContext);
+                });
+            }
+            return completedItem;
         }
-        if (completeListItemValue(item, completedResults, errors, exeContext, itemType, fieldNodes, info, itemPath, asyncPayloadRecord)) {
-            containsPromise = true;
+        catch (rawError) {
+            const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(itemPath));
+            return handleFieldError(error, itemType, exeContext);
         }
-        index++;
-    }
+    });
     return containsPromise ? Promise.all(completedResults) : completedResults;
 }
-/**
- * Complete a list item value by adding it to the completed results.
- *
- * Returns true if the value is a Promise.
- */
-function completeListItemValue(item, completedResults, errors, exeContext, itemType, fieldNodes, info, itemPath, asyncPayloadRecord) {
-    try {
-        let completedItem;
-        if ((0, utils_1.isPromise)(item)) {
-            completedItem = item.then(resolved => completeValue(exeContext, itemType, fieldNodes, info, itemPath, resolved, asyncPayloadRecord));
-        }
-        else {
-            completedItem = completeValue(exeContext, itemType, fieldNodes, info, itemPath, item, asyncPayloadRecord);
-        }
-        if ((0, utils_1.isPromise)(completedItem)) {
-            // Note: we don't rely on a `catch` method, but we do expect "thenable"
-            // to take a second callback for the error case.
-            completedResults.push(completedItem.then(undefined, rawError => {
-                const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(itemPath));
-                const handledError = handleFieldError(error, itemType, errors);
-                filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
-                return handledError;
-            }));
-            return true;
-        }
-        completedResults.push(completedItem);
-    }
-    catch (rawError) {
-        const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(itemPath));
-        const handledError = handleFieldError(error, itemType, errors);
-        filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
-        completedResults.push(handledError);
-    }
-    return false;
-}
 /**
  * Complete a Scalar or Enum by serializing to a valid value, returning
  * null if serialization is not possible.
@@ -610,15 +474,15 @@ function completeLeafValue(returnType, result) {
  * Complete a value of an abstract type by determining the runtime object type
  * of that value, then complete the value for that type.
  */
-function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord) {
+function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result) {
     var _a;
     const resolveTypeFn = (_a = returnType.resolveType) !== null && _a !== void 0 ? _a : exeContext.typeResolver;
     const contextValue = exeContext.contextValue;
     const runtimeType = resolveTypeFn(result, contextValue, info, returnType);
     if ((0, utils_1.isPromise)(runtimeType)) {
-        return runtimeType.then(resolvedRuntimeType => completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result, asyncPayloadRecord));
+        return runtimeType.then(resolvedRuntimeType => completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result));
     }
-    return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result, asyncPayloadRecord);
+    return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result);
 }
 function ensureValidRuntimeType(runtimeTypeName, exeContext, returnType, fieldNodes, info, result) {
     if (runtimeTypeName == null) {
@@ -648,7 +512,9 @@ function ensureValidRuntimeType(runtimeTypeName, exeContext, returnType, fieldNo
 /**
  * Complete an Object value by executing all sub-selections.
  */
-function completeObjectValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord) {
+function completeObjectValue(exeContext, returnType, fieldNodes, info, path, result) {
+    // Collect sub-fields to execute to complete this value.
+    const subFieldNodes = (0, utils_1.collectSubFields)(exeContext.schema, exeContext.fragments, exeContext.variableValues, returnType, fieldNodes);
     // If there is an isTypeOf predicate function, call it with the
     // current result. If isTypeOf returns false, then raise an error rather
     // than continuing execution.
@@ -659,30 +525,20 @@ function completeObjectValue(exeContext, returnType, fieldNodes, info, path, res
                 if (!resolvedIsTypeOf) {
                     throw invalidReturnTypeError(returnType, result, fieldNodes);
                 }
-                return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result, asyncPayloadRecord);
+                return executeFields(exeContext, returnType, result, path, subFieldNodes);
             });
         }
         if (!isTypeOf) {
             throw invalidReturnTypeError(returnType, result, fieldNodes);
         }
     }
-    return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result, asyncPayloadRecord);
+    return executeFields(exeContext, returnType, result, path, subFieldNodes);
 }
 function invalidReturnTypeError(returnType, result, fieldNodes) {
     return (0, utils_1.createGraphQLError)(`Expected value of type "${returnType.name}" but got: ${(0, utils_1.inspect)(result)}.`, {
         nodes: fieldNodes,
     });
 }
-function collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result, asyncPayloadRecord) {
-    // Collect sub-fields to execute to complete this value.
-    const { fields: subFieldNodes, patches: subPatches } = collectSubfields(exeContext, returnType, fieldNodes);
-    const subFields = executeFields(exeContext, returnType, result, path, subFieldNodes, asyncPayloadRecord);
-    for (const subPatch of subPatches) {
-        const { label, fields: subPatchFieldNodes } = subPatch;
-        executeDeferredFragment(exeContext, returnType, result, subPatchFieldNodes, label, path, asyncPayloadRecord);
-    }
-    return subFields;
-}
 /**
  * If a resolveType function is not given, then a default resolve behavior is
  * used which attempts two strategies:
@@ -750,78 +606,19 @@ exports.defaultFieldResolver = defaultFieldResolver;
  * is not an async iterable.
  *
  * If the client-provided arguments to this function do not result in a
- * compliant subscription, a GraphQL Response (ExecutionResult) with descriptive
- * errors and no data will be returned.
+ * compliant subscription, a GraphQL Response (ExecutionResult) with
+ * descriptive errors and no data will be returned.
  *
- * If the source stream could not be created due to faulty subscription resolver
- * logic or underlying systems, the promise will resolve to a single
+ * If the source stream could not be created due to faulty subscription
+ * resolver logic or underlying systems, the promise will resolve to a single
  * ExecutionResult containing `errors` and no `data`.
  *
  * If the operation succeeded, the promise resolves to an AsyncIterator, which
  * yields a stream of ExecutionResults representing the response stream.
  *
- * This function does not support incremental delivery (`@defer` and `@stream`).
- * If an operation which would defer or stream data is executed with this
- * function, each `InitialIncrementalExecutionResult` and
- * `SubsequentIncrementalExecutionResult` in the result stream will be replaced
- * with an `ExecutionResult` with a single error stating that defer/stream is
- * not supported.  Use `experimentalSubscribeIncrementally` if you want to
- * support incremental delivery.
- *
- * Accepts an object with named arguments.
+ * Accepts either an object with named arguments, or individual arguments.
  */
 function subscribe(args) {
-    const maybePromise = experimentalSubscribeIncrementally(args);
-    if ((0, utils_1.isPromise)(maybePromise)) {
-        return maybePromise.then(resultOrIterable => (0, utils_1.isAsyncIterable)(resultOrIterable)
-            ? (0, utils_1.mapAsyncIterator)(resultOrIterable, ensureSingleExecutionResult)
-            : resultOrIterable);
-    }
-    return (0, utils_1.isAsyncIterable)(maybePromise) ? (0, utils_1.mapAsyncIterator)(maybePromise, ensureSingleExecutionResult) : maybePromise;
-}
-exports.subscribe = subscribe;
-function ensureSingleExecutionResult(result) {
-    if ('hasNext' in result) {
-        return {
-            errors: [(0, utils_1.createGraphQLError)(UNEXPECTED_MULTIPLE_PAYLOADS)],
-        };
-    }
-    return result;
-}
-/**
- * Implements the "Subscribe" algorithm described in the GraphQL specification,
- * including `@defer` and `@stream` as proposed in
- * https://github.com/graphql/graphql-spec/pull/742
- *
- * Returns a Promise which resolves to either an AsyncIterator (if successful)
- * or an ExecutionResult (error). The promise will be rejected if the schema or
- * other arguments to this function are invalid, or if the resolved event stream
- * is not an async iterable.
- *
- * If the client-provided arguments to this function do not result in a
- * compliant subscription, a GraphQL Response (ExecutionResult) with descriptive
- * errors and no data will be returned.
- *
- * If the source stream could not be created due to faulty subscription resolver
- * logic or underlying systems, the promise will resolve to a single
- * ExecutionResult containing `errors` and no `data`.
- *
- * If the operation succeeded, the promise resolves to an AsyncIterator, which
- * yields a stream of result representing the response stream.
- *
- * Each result may be an ExecutionResult with no `hasNext` (if executing the
- * event did not use `@defer` or `@stream`), or an
- * `InitialIncrementalExecutionResult` or `SubsequentIncrementalExecutionResult`
- * (if executing the event used `@defer` or `@stream`). In the case of
- * incremental execution results, each event produces a single
- * `InitialIncrementalExecutionResult` followed by one or more
- * `SubsequentIncrementalExecutionResult`s; all but the last have `hasNext: true`,
- * and the last has `hasNext: false`. There is no interleaving between results
- * generated from the same original event.
- *
- * Accepts an object with named arguments.
- */
-function experimentalSubscribeIncrementally(args) {
     // If a valid execution context cannot be created due to incorrect arguments,
     // a "Response" with only errors is returned.
     const exeContext = buildExecutionContext(args);
@@ -835,16 +632,7 @@ function experimentalSubscribeIncrementally(args) {
     }
     return mapSourceToResponse(exeContext, resultOrStream);
 }
-exports.experimentalSubscribeIncrementally = experimentalSubscribeIncrementally;
-async function* ensureAsyncIterable(someExecutionResult) {
-    if ('initialResult' in someExecutionResult) {
-        yield someExecutionResult.initialResult;
-        yield* someExecutionResult.subsequentResults;
-    }
-    else {
-        yield someExecutionResult;
-    }
-}
+exports.subscribe = subscribe;
 function mapSourceToResponse(exeContext, resultOrStream) {
     if (!(0, utils_1.isAsyncIterable)(resultOrStream)) {
         return resultOrStream;
@@ -855,7 +643,7 @@ function mapSourceToResponse(exeContext, resultOrStream) {
     // the GraphQL specification. The `execute` function provides the
     // "ExecuteSubscriptionEvent" algorithm, as it is nearly identical to the
     // "ExecuteQuery" algorithm, for which `execute` is also used.
-    return (0, flattenAsyncIterable_js_1.flattenAsyncIterable)((0, utils_1.mapAsyncIterator)(resultOrStream[Symbol.asyncIterator](), async (payload) => ensureAsyncIterable(await executeImpl(buildPerEventExecutionContext(exeContext, payload)))));
+    return (0, utils_1.mapAsyncIterator)(resultOrStream[Symbol.asyncIterator](), (payload) => executeImpl(buildPerEventExecutionContext(exeContext, payload)));
 }
 /**
  * Implements the "CreateSourceEventStream" algorithm described in the
@@ -915,7 +703,7 @@ function executeSubscription(exeContext) {
     if (rootType == null) {
         throw (0, utils_1.createGraphQLError)('Schema is not configured to execute subscription operation.', { nodes: operation });
     }
-    const { fields: rootFields } = (0, utils_1.collectFields)(schema, fragments, variableValues, rootType, operation.selectionSet);
+    const rootFields = (0, utils_1.collectFields)(schema, fragments, variableValues, rootType, operation.selectionSet);
     const [responseName, fieldNodes] = [...rootFields.entries()][0];
     const fieldName = fieldNodes[0].name.value;
     const fieldDef = getFieldDef(schema, rootType, fieldNodes[0]);
@@ -959,339 +747,6 @@ function assertEventStream(result) {
     }
     return result;
 }
-function executeDeferredFragment(exeContext, parentType, sourceValue, fields, label, path, parentContext) {
-    const asyncPayloadRecord = new DeferredFragmentRecord({
-        label,
-        path,
-        parentContext,
-        exeContext,
-    });
-    let promiseOrData;
-    try {
-        promiseOrData = executeFields(exeContext, parentType, sourceValue, path, fields, asyncPayloadRecord);
-        if ((0, utils_1.isPromise)(promiseOrData)) {
-            promiseOrData = promiseOrData.then(null, e => {
-                asyncPayloadRecord.errors.push(e);
-                return null;
-            });
-        }
-    }
-    catch (e) {
-        asyncPayloadRecord.errors.push(e);
-        promiseOrData = null;
-    }
-    asyncPayloadRecord.addData(promiseOrData);
-}
-function executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, label, parentContext) {
-    const asyncPayloadRecord = new StreamRecord({
-        label,
-        path: itemPath,
-        parentContext,
-        exeContext,
-    });
-    let completedItem;
-    try {
-        try {
-            if ((0, utils_1.isPromise)(item)) {
-                completedItem = item.then(resolved => completeValue(exeContext, itemType, fieldNodes, info, itemPath, resolved, asyncPayloadRecord));
-            }
-            else {
-                completedItem = completeValue(exeContext, itemType, fieldNodes, info, itemPath, item, asyncPayloadRecord);
-            }
-            if ((0, utils_1.isPromise)(completedItem)) {
-                // Note: we don't rely on a `catch` method, but we do expect "thenable"
-                // to take a second callback for the error case.
-                completedItem = completedItem.then(undefined, rawError => {
-                    const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(itemPath));
-                    const handledError = handleFieldError(error, itemType, asyncPayloadRecord.errors);
-                    filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
-                    return handledError;
-                });
-            }
-        }
-        catch (rawError) {
-            const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(itemPath));
-            completedItem = handleFieldError(error, itemType, asyncPayloadRecord.errors);
-            filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
-        }
-    }
-    catch (error) {
-        asyncPayloadRecord.errors.push(error);
-        filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
-        asyncPayloadRecord.addItems(null);
-        return asyncPayloadRecord;
-    }
-    let completedItems;
-    if ((0, utils_1.isPromise)(completedItem)) {
-        completedItems = completedItem.then(value => [value], error => {
-            asyncPayloadRecord.errors.push(error);
-            filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
-            return null;
-        });
-    }
-    else {
-        completedItems = [completedItem];
-    }
-    asyncPayloadRecord.addItems(completedItems);
-    return asyncPayloadRecord;
-}
-async function executeStreamIteratorItem(iterator, exeContext, fieldNodes, info, itemType, asyncPayloadRecord, itemPath) {
-    let item;
-    try {
-        const { value, done } = await iterator.next();
-        if (done) {
-            asyncPayloadRecord.setIsCompletedIterator();
-            return { done, value: undefined };
-        }
-        item = value;
-    }
-    catch (rawError) {
-        const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(itemPath));
-        const value = handleFieldError(error, itemType, asyncPayloadRecord.errors);
-        // don't continue if iterator throws
-        return { done: true, value };
-    }
-    let completedItem;
-    try {
-        completedItem = completeValue(exeContext, itemType, fieldNodes, info, itemPath, item, asyncPayloadRecord);
-        if ((0, utils_1.isPromise)(completedItem)) {
-            completedItem = completedItem.then(undefined, rawError => {
-                const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(itemPath));
-                const handledError = handleFieldError(error, itemType, asyncPayloadRecord.errors);
-                filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
-                return handledError;
-            });
-        }
-        return { done: false, value: completedItem };
-    }
-    catch (rawError) {
-        const error = (0, graphql_1.locatedError)(rawError, fieldNodes, (0, utils_1.pathToArray)(itemPath));
-        const value = handleFieldError(error, itemType, asyncPayloadRecord.errors);
-        filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
-        return { done: false, value };
-    }
-}
-async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNodes, info, itemType, path, label, parentContext) {
-    let index = initialIndex;
-    let previousAsyncPayloadRecord = parentContext !== null && parentContext !== void 0 ? parentContext : undefined;
-    while (true) {
-        const itemPath = (0, utils_1.addPath)(path, index, undefined);
-        const asyncPayloadRecord = new StreamRecord({
-            label,
-            path: itemPath,
-            parentContext: previousAsyncPayloadRecord,
-            iterator,
-            exeContext,
-        });
-        let iteration;
-        try {
-            iteration = await executeStreamIteratorItem(iterator, exeContext, fieldNodes, info, itemType, asyncPayloadRecord, itemPath);
-        }
-        catch (error) {
-            asyncPayloadRecord.errors.push(error);
-            filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
-            asyncPayloadRecord.addItems(null);
-            // entire stream has errored and bubbled upwards
-            if (iterator === null || iterator === void 0 ? void 0 : iterator.return) {
-                iterator.return().catch(() => {
-                    // ignore errors
-                });
-            }
-            return;
-        }
-        const { done, value: completedItem } = iteration;
-        let completedItems;
-        if ((0, utils_1.isPromise)(completedItem)) {
-            completedItems = completedItem.then(value => [value], error => {
-                asyncPayloadRecord.errors.push(error);
-                filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
-                return null;
-            });
-        }
-        else {
-            completedItems = [completedItem];
-        }
-        asyncPayloadRecord.addItems(completedItems);
-        if (done) {
-            break;
-        }
-        previousAsyncPayloadRecord = asyncPayloadRecord;
-        index++;
-    }
-}
-function filterSubsequentPayloads(exeContext, nullPath, currentAsyncRecord) {
-    const nullPathArray = (0, utils_1.pathToArray)(nullPath);
-    exeContext.subsequentPayloads.forEach(asyncRecord => {
-        var _a;
-        if (asyncRecord === currentAsyncRecord) {
-            // don't remove payload from where error originates
-            return;
-        }
-        for (let i = 0; i < nullPathArray.length; i++) {
-            if (asyncRecord.path[i] !== nullPathArray[i]) {
-                // asyncRecord points to a path unaffected by this payload
-                return;
-            }
-        }
-        // asyncRecord path points to nulled error field
-        if (isStreamPayload(asyncRecord) && ((_a = asyncRecord.iterator) === null || _a === void 0 ? void 0 : _a.return)) {
-            asyncRecord.iterator.return().catch(() => {
-                // ignore error
-            });
-        }
-        exeContext.subsequentPayloads.delete(asyncRecord);
-    });
-}
-function getCompletedIncrementalResults(exeContext) {
-    const incrementalResults = [];
-    for (const asyncPayloadRecord of exeContext.subsequentPayloads) {
-        const incrementalResult = {};
-        if (!asyncPayloadRecord.isCompleted) {
-            continue;
-        }
-        exeContext.subsequentPayloads.delete(asyncPayloadRecord);
-        if (isStreamPayload(asyncPayloadRecord)) {
-            const items = asyncPayloadRecord.items;
-            if (asyncPayloadRecord.isCompletedIterator) {
-                // async iterable resolver just finished but there may be pending payloads
-                continue;
-            }
-            incrementalResult.items = items;
-        }
-        else {
-            const data = asyncPayloadRecord.data;
-            incrementalResult.data = data !== null && data !== void 0 ? data : null;
-        }
-        incrementalResult.path = asyncPayloadRecord.path;
-        if (asyncPayloadRecord.label) {
-            incrementalResult.label = asyncPayloadRecord.label;
-        }
-        if (asyncPayloadRecord.errors.length > 0) {
-            incrementalResult.errors = asyncPayloadRecord.errors;
-        }
-        incrementalResults.push(incrementalResult);
-    }
-    return incrementalResults;
-}
-function yieldSubsequentPayloads(exeContext) {
-    let isDone = false;
-    async function next() {
-        if (isDone) {
-            return { value: undefined, done: true };
-        }
-        await Promise.race(Array.from(exeContext.subsequentPayloads).map(p => p.promise));
-        if (isDone) {
-            // a different call to next has exhausted all payloads
-            return { value: undefined, 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(asyncPayloadRecord => {
-            var _a;
-            if (isStreamPayload(asyncPayloadRecord) && ((_a = asyncPayloadRecord.iterator) === null || _a === void 0 ? void 0 : _a.return)) {
-                promises.push(asyncPayloadRecord.iterator.return());
-            }
-        });
-        return Promise.all(promises);
-    }
-    return {
-        [Symbol.asyncIterator]() {
-            return this;
-        },
-        next,
-        async return() {
-            await returnStreamIterators();
-            isDone = true;
-            return { value: undefined, done: true };
-        },
-        async throw(error) {
-            await returnStreamIterators();
-            isDone = true;
-            return Promise.reject(error);
-        },
-    };
-}
-class DeferredFragmentRecord {
-    constructor(opts) {
-        this.type = 'defer';
-        this.label = opts.label;
-        this.path = (0, utils_1.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 = MaybePromise => {
-                resolve(MaybePromise);
-            };
-        }).then(data => {
-            this.data = data;
-            this.isCompleted = true;
-        });
-    }
-    addData(data) {
-        var _a, _b, _c;
-        const parentData = (_a = this.parentContext) === null || _a === void 0 ? void 0 : _a.promise;
-        if (parentData) {
-            (_b = this._resolve) === null || _b === void 0 ? void 0 : _b.call(this, parentData.then(() => data));
-            return;
-        }
-        (_c = this._resolve) === null || _c === void 0 ? void 0 : _c.call(this, data);
-    }
-}
-class StreamRecord {
-    constructor(opts) {
-        this.type = 'stream';
-        this.items = null;
-        this.label = opts.label;
-        this.path = (0, utils_1.pathToArray)(opts.path);
-        this.parentContext = opts.parentContext;
-        this.iterator = opts.iterator;
-        this.errors = [];
-        this._exeContext = opts.exeContext;
-        this._exeContext.subsequentPayloads.add(this);
-        this.isCompleted = false;
-        this.items = null;
-        this.promise = new Promise(resolve => {
-            this._resolve = MaybePromise => {
-                resolve(MaybePromise);
-            };
-        }).then(items => {
-            this.items = items;
-            this.isCompleted = true;
-        });
-    }
-    addItems(items) {
-        var _a, _b, _c;
-        const parentData = (_a = this.parentContext) === null || _a === void 0 ? void 0 : _a.promise;
-        if (parentData) {
-            (_b = this._resolve) === null || _b === void 0 ? void 0 : _b.call(this, parentData.then(() => items));
-            return;
-        }
-        (_c = this._resolve) === null || _c === void 0 ? void 0 : _c.call(this, items);
-    }
-    setIsCompletedIterator() {
-        this.isCompletedIterator = true;
-    }
-}
-function isStreamPayload(asyncPayload) {
-    return asyncPayload.type === 'stream';
-}
 /**
  * This method looks up the field on the given type definition.
  * It has special casing for the three introspection fields,