@graphql-tools/executor 0.0.2 → 0.0.3-alpha-20221031181646-cd48ed2f

package/esm/execution/execute.js

@@ -1,6 +1,16 @@
-import { locatedError, Kind, isAbstractType, isLeafType, isListType, isNonNullType, isObjectType, assertValidSchema, SchemaMetaFieldDef, TypeMetaFieldDef, TypeNameMetaFieldDef, } from 'graphql';
-import { collectFields, collectSubFields, createGraphQLError, inspect, isAsyncIterable, isIterableObject, isObjectLike, isPromise, mapAsyncIterator, pathToArray, addPath, getArgumentValues, promiseReduce, getDefinedRootType, } from '@graphql-tools/utils';
+import { locatedError, Kind, isAbstractType, isLeafType, isListType, isNonNullType, isObjectType, assertValidSchema, getDirectiveValues, SchemaMetaFieldDef, TypeMetaFieldDef, TypeNameMetaFieldDef, } from 'graphql';
+import { createGraphQLError, inspect, isAsyncIterable, isIterableObject, isObjectLike, isPromise, pathToArray, addPath, getArgumentValues, promiseReduce, memoize3, getDefinedRootType, mapAsyncIterator, GraphQLStreamDirective, collectFields, collectSubFields as _collectSubfields, } from '@graphql-tools/utils';
 import { getVariableValues } from './values.js';
+import { promiseForObject } from './promiseForObject.js';
+import { flattenAsyncIterable } from './flattenAsyncIterable.js';
+import { invariant } from './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 = memoize3((exeContext, returnType, fieldNodes) => _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.
  *
@@ -10,8 +20,43 @@ import { getVariableValues } from './values.js';
  *
  * 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.
  */
 export function execute(args) {
+    const result = experimentalExecuteIncrementally(args);
+    if (!isPromise(result)) {
+        if ('initialResult' in result) {
+            throw new Error(UNEXPECTED_MULTIPLE_PAYLOADS);
+        }
+        return result;
+    }
+    return result.then(incrementalResult => {
+        if ('initialResult' in incrementalResult) {
+            return {
+                errors: [createGraphQLError(UNEXPECTED_MULTIPLE_PAYLOADS)],
+            };
+        }
+        return incrementalResult;
+    });
+}
+/**
+ * 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.
+ */
+export 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);
@@ -36,12 +81,34 @@ function executeImpl(exeContext) {
     try {
         const result = executeOperation(exeContext);
         if (isPromise(result)) {
-            return result.then(data => buildResponse(data, exeContext.errors), error => {
+            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 => {
                 exeContext.errors.push(error);
                 return buildResponse(null, exeContext.errors);
             });
         }
-        return buildResponse(result, exeContext.errors);
+        const initialResult = buildResponse(result, exeContext.errors);
+        if (exeContext.subsequentPayloads.size > 0) {
+            return {
+                initialResult: {
+                    ...initialResult,
+                    hasNext: true,
+                },
+                subsequentResults: yieldSubsequentPayloads(exeContext),
+            };
+        }
+        return initialResult;
     }
     catch (error) {
         exeContext.errors.push(error);
@@ -54,9 +121,9 @@ function executeImpl(exeContext) {
  * that all field resolvers are also synchronous.
  */
 export function executeSync(args) {
-    const result = execute(args);
+    const result = experimentalExecuteIncrementally(args);
     // Assert that the execution was synchronous.
-    if (isPromise(result)) {
+    if (isPromise(result) || 'initialResult' in result) {
         throw new Error('GraphQL execution failed to complete synchronously.');
     }
     return result;
@@ -142,6 +209,7 @@ export function buildExecutionContext(args) {
         fieldResolver: fieldResolver !== null && fieldResolver !== void 0 ? fieldResolver : defaultFieldResolver,
         typeResolver: typeResolver !== null && typeResolver !== void 0 ? typeResolver : defaultTypeResolver,
         subscribeFieldResolver: subscribeFieldResolver !== null && subscribeFieldResolver !== void 0 ? subscribeFieldResolver : defaultFieldResolver,
+        subsequentPayloads: new Set(),
         errors: [],
     };
 }
@@ -149,6 +217,7 @@ function buildPerEventExecutionContext(exeContext, payload) {
     return {
         ...exeContext,
         rootValue: payload,
+        subsequentPayloads: new Set(),
         errors: [],
     };
 }
@@ -158,26 +227,32 @@ function buildPerEventExecutionContext(exeContext, payload) {
 function executeOperation(exeContext) {
     const { operation, schema, fragments, variableValues, rootValue } = exeContext;
     const rootType = getDefinedRootType(schema, operation.operation, [operation]);
-    const rootFields = collectFields(schema, fragments, variableValues, rootType, operation.selectionSet);
+    if (rootType == null) {
+        createGraphQLError(`Schema is not configured to execute ${operation.operation} operation.`, {
+            nodes: operation,
+        });
+    }
+    const { fields: rootFields, patches } = collectFields(schema, fragments, variableValues, rootType, operation.selectionSet);
     const path = undefined;
-    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}".`);
+    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;
 }
 /**
  * Implements the "Executing selection sets" section of the spec
  * for fields that must be executed serially.
  */
 function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields) {
-    return promiseReduce(fields.entries(), (results, [responseName, fieldNodes]) => {
+    return promiseReduce(fields, (results, [responseName, fieldNodes]) => {
         const fieldPath = addPath(path, responseName, parentType.name);
         const result = executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath);
         if (result === undefined) {
@@ -197,19 +272,30 @@ 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) {
+function executeFields(exeContext, parentType, sourceValue, path, fields, asyncPayloadRecord) {
     const results = Object.create(null);
     let containsPromise = false;
-    for (const [responseName, fieldNodes] of fields.entries()) {
-        const fieldPath = addPath(path, responseName, parentType.name);
-        const result = executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath);
-        if (result !== undefined) {
-            results[responseName] = result;
-            if (isPromise(result)) {
-                containsPromise = true;
+    try {
+        for (const [responseName, fieldNodes] of fields) {
+            const fieldPath = addPath(path, responseName, parentType.name);
+            const result = executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath, asyncPayloadRecord);
+            if (result !== undefined) {
+                results[responseName] = result;
+                if (isPromise(result)) {
+                    containsPromise = true;
+                }
             }
         }
     }
+    catch (error) {
+        if (containsPromise) {
+            // Ensure that any promises returned by other fields are handled, as they may also reject.
+            return promiseForObject(results).finally(() => {
+                throw error;
+            });
+        }
+        throw error;
+    }
     // If there are no promises, we can just return the object
     if (!containsPromise) {
         return results;
@@ -217,13 +303,7 @@ function executeFields(exeContext, parentType, sourceValue, path, fields) {
     // 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 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;
-    });
+    return promiseForObject(results);
 }
 /**
  * Implements the "Executing fields" section of the spec
@@ -231,14 +311,15 @@ function executeFields(exeContext, parentType, sourceValue, path, fields) {
  * 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) {
-    var _a;
+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;
     const fieldDef = getFieldDef(exeContext.schema, parentType, fieldNodes[0]);
     if (!fieldDef) {
         return;
     }
     const returnType = fieldDef.type;
-    const resolveFn = (_a = fieldDef.resolve) !== null && _a !== void 0 ? _a : exeContext.fieldResolver;
+    const resolveFn = (_b = fieldDef.resolve) !== null && _b !== void 0 ? _b : 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 {
@@ -253,24 +334,28 @@ function executeField(exeContext, parentType, source, fieldNodes, path) {
         const result = resolveFn(source, args, contextValue, info);
         let completed;
         if (isPromise(result)) {
-            completed = result.then(resolved => completeValue(exeContext, returnType, fieldNodes, info, path, resolved));
+            completed = result.then(resolved => completeValue(exeContext, returnType, fieldNodes, info, path, resolved, asyncPayloadRecord));
         }
         else {
-            completed = completeValue(exeContext, returnType, fieldNodes, info, path, result);
+            completed = completeValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord);
         }
         if (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 = locatedError(rawError, fieldNodes, pathToArray(path));
-                return handleFieldError(error, returnType, exeContext);
+                const handledError = handleFieldError(error, returnType, errors);
+                filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+                return handledError;
             });
         }
         return completed;
     }
     catch (rawError) {
         const error = locatedError(rawError, fieldNodes, pathToArray(path));
-        return handleFieldError(error, returnType, exeContext);
+        const handledError = handleFieldError(error, returnType, errors);
+        filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+        return handledError;
     }
 }
 /**
@@ -293,7 +378,7 @@ export function buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, p
         variableValues: exeContext.variableValues,
     };
 }
-function handleFieldError(error, returnType, exeContext) {
+function handleFieldError(error, returnType, errors) {
     // If the field type is non-nullable, then it is resolved without any
     // protection from errors, however it still properly locates the error.
     if (isNonNullType(returnType)) {
@@ -301,7 +386,7 @@ function handleFieldError(error, returnType, exeContext) {
     }
     // Otherwise, error protection is applied, logging the error and resolving
     // a null value for this field if one is encountered.
-    exeContext.errors.push(error);
+    errors.push(error);
     return null;
 }
 /**
@@ -325,7 +410,7 @@ function handleFieldError(error, returnType, exeContext) {
  * 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) {
+function completeValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord) {
     // If result is an Error, throw a located error.
     if (result instanceof Error) {
         throw result;
@@ -333,7 +418,7 @@ function completeValue(exeContext, returnType, fieldNodes, info, path, result) {
     // If field type is NonNull, complete for inner type, and throw field error
     // if result is null.
     if (isNonNullType(returnType)) {
-        const completed = completeValue(exeContext, returnType.ofType, fieldNodes, info, path, result);
+        const completed = completeValue(exeContext, returnType.ofType, fieldNodes, info, path, result, asyncPayloadRecord);
         if (completed === null) {
             throw new Error(`Cannot return null for non-nullable field ${info.parentType.name}.${info.fieldName}.`);
         }
@@ -345,7 +430,7 @@ function completeValue(exeContext, returnType, fieldNodes, info, path, result) {
     }
     // If field type is List, complete each item in the list with the inner type
     if (isListType(returnType)) {
-        return completeListValue(exeContext, returnType, fieldNodes, info, path, result);
+        return completeListValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord);
     }
     // If field type is a leaf type, Scalar or Enum, serialize to a valid value,
     // returning null if serialization is not possible.
@@ -355,51 +440,74 @@ function completeValue(exeContext, returnType, fieldNodes, info, path, result) {
     // If field type is an abstract type, Interface or Union, determine the
     // runtime Object type and complete for that type.
     if (isAbstractType(returnType)) {
-        return completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result);
+        return completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord);
     }
     // If field type is Object, execute and complete all sub-selections.
     if (isObjectType(returnType)) {
-        return completeObjectValue(exeContext, returnType, fieldNodes, info, path, result);
+        return completeObjectValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord);
     }
     /* c8 ignore next 6 */
     // Not reachable, all possible output types have been considered.
     console.assert(false, 'Cannot complete value of unexpected output type: ' + 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 = getDirectiveValues(GraphQLStreamDirective, fieldNodes[0], exeContext.variableValues);
+    if (!stream) {
+        return;
+    }
+    if (stream['if'] === false) {
+        return;
+    }
+    invariant(typeof stream['initialCount'] === 'number', 'initialCount must be a number');
+    invariant(stream['initialCount'] >= 0, 'initialCount must be a positive integer');
+    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) {
+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);
     let containsPromise = false;
     const completedResults = [];
     let index = 0;
     while (true) {
-        const fieldPath = addPath(path, index, undefined);
+        if (stream && typeof stream.initialCount === 'number' && index >= stream.initialCount) {
+            executeStreamIterator(index, iterator, exeContext, fieldNodes, info, itemType, path, stream.label, asyncPayloadRecord);
+            break;
+        }
+        const itemPath = addPath(path, index, undefined);
+        let iteration;
         try {
-            const { value, done } = await iterator.next();
-            if (done) {
+            iteration = await iterator.next();
+            if (iteration.done) {
                 break;
             }
-            try {
-                // TODO can the error checking logic be consolidated with completeListValue?
-                const completedItem = completeValue(exeContext, itemType, fieldNodes, info, fieldPath, value);
-                if (isPromise(completedItem)) {
-                    containsPromise = true;
-                }
-                completedResults.push(completedItem);
-            }
-            catch (rawError) {
-                completedResults.push(null);
-                const error = locatedError(rawError, fieldNodes, pathToArray(fieldPath));
-                handleFieldError(error, itemType, exeContext);
-            }
         }
         catch (rawError) {
-            completedResults.push(null);
-            const error = locatedError(rawError, fieldNodes, pathToArray(fieldPath));
-            handleFieldError(error, itemType, exeContext);
+            const error = locatedError(rawError, fieldNodes, pathToArray(itemPath));
+            completedResults.push(handleFieldError(error, itemType, errors));
             break;
         }
+        if (completeListItemValue(iteration.value, completedResults, errors, exeContext, itemType, fieldNodes, info, itemPath, asyncPayloadRecord)) {
+            containsPromise = true;
+        }
         index += 1;
     }
     return containsPromise ? Promise.all(completedResults) : completedResults;
@@ -408,48 +516,75 @@ 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) {
+function completeListValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord) {
+    var _a;
     const itemType = returnType.ofType;
+    const errors = (_a = asyncPayloadRecord === null || asyncPayloadRecord === void 0 ? void 0 : asyncPayloadRecord.errors) !== null && _a !== void 0 ? _a : exeContext.errors;
     if (isAsyncIterable(result)) {
         const iterator = result[Symbol.asyncIterator]();
-        return completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path, iterator);
+        return completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path, iterator, asyncPayloadRecord);
     }
     if (!isIterableObject(result)) {
         throw 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;
-    const completedResults = Array.from(result, (item, index) => {
+    let previousAsyncPayloadRecord = asyncPayloadRecord;
+    const completedResults = [];
+    let index = 0;
+    for (const item of result) {
         // No need to modify the info object containing the path,
         // since from here on it is not ever accessed by resolver functions.
         const itemPath = addPath(path, index, undefined);
-        try {
-            let completedItem;
-            if (isPromise(item)) {
-                completedItem = item.then(resolved => completeValue(exeContext, itemType, fieldNodes, info, itemPath, resolved));
-            }
-            else {
-                completedItem = completeValue(exeContext, itemType, fieldNodes, info, itemPath, item);
-            }
-            if (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 = locatedError(rawError, fieldNodes, pathToArray(itemPath));
-                    return handleFieldError(error, itemType, exeContext);
-                });
-            }
-            return completedItem;
+        if (stream && typeof stream.initialCount === 'number' && index >= stream.initialCount) {
+            previousAsyncPayloadRecord = executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, stream.label, previousAsyncPayloadRecord);
+            index++;
+            continue;
         }
-        catch (rawError) {
-            const error = locatedError(rawError, fieldNodes, pathToArray(itemPath));
-            return handleFieldError(error, itemType, exeContext);
+        if (completeListItemValue(item, completedResults, errors, exeContext, itemType, fieldNodes, info, itemPath, asyncPayloadRecord)) {
+            containsPromise = true;
         }
-    });
+        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 (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 (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 = locatedError(rawError, fieldNodes, pathToArray(itemPath));
+                const handledError = handleFieldError(error, itemType, errors);
+                filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
+                return handledError;
+            }));
+            return true;
+        }
+        completedResults.push(completedItem);
+    }
+    catch (rawError) {
+        const error = locatedError(rawError, fieldNodes, 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.
@@ -466,15 +601,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) {
+function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord) {
     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 (isPromise(runtimeType)) {
-        return runtimeType.then(resolvedRuntimeType => completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result));
+        return runtimeType.then(resolvedRuntimeType => completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result, asyncPayloadRecord));
     }
-    return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result);
+    return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result, asyncPayloadRecord);
 }
 function ensureValidRuntimeType(runtimeTypeName, exeContext, returnType, fieldNodes, info, result) {
     if (runtimeTypeName == null) {
@@ -504,9 +639,7 @@ function ensureValidRuntimeType(runtimeTypeName, exeContext, returnType, fieldNo
 /**
  * Complete an Object value by executing all sub-selections.
  */
-function completeObjectValue(exeContext, returnType, fieldNodes, info, path, result) {
-    // Collect sub-fields to execute to complete this value.
-    const subFieldNodes = collectSubFields(exeContext.schema, exeContext.fragments, exeContext.variableValues, returnType, fieldNodes);
+function completeObjectValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord) {
     // 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.
@@ -517,20 +650,30 @@ function completeObjectValue(exeContext, returnType, fieldNodes, info, path, res
                 if (!resolvedIsTypeOf) {
                     throw invalidReturnTypeError(returnType, result, fieldNodes);
                 }
-                return executeFields(exeContext, returnType, result, path, subFieldNodes);
+                return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result, asyncPayloadRecord);
             });
         }
         if (!isTypeOf) {
             throw invalidReturnTypeError(returnType, result, fieldNodes);
         }
     }
-    return executeFields(exeContext, returnType, result, path, subFieldNodes);
+    return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result, asyncPayloadRecord);
 }
 function invalidReturnTypeError(returnType, result, fieldNodes) {
     return createGraphQLError(`Expected value of type "${returnType.name}" but got: ${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:
@@ -596,19 +739,77 @@ export const defaultFieldResolver = function (source, args, contextValue, info)
  * 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.
  *
- * Accepts either an object with named arguments, or individual arguments.
+ * 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.
  */
 export function subscribe(args) {
+    const maybePromise = experimentalSubscribeIncrementally(args);
+    if (isPromise(maybePromise)) {
+        return maybePromise.then(resultOrIterable => isAsyncIterable(resultOrIterable)
+            ? mapAsyncIterator(resultOrIterable, ensureSingleExecutionResult)
+            : resultOrIterable);
+    }
+    return isAsyncIterable(maybePromise) ? mapAsyncIterator(maybePromise, ensureSingleExecutionResult) : maybePromise;
+}
+function ensureSingleExecutionResult(result) {
+    if ('hasNext' in result) {
+        return {
+            errors: [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.
+ */
+export 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);
@@ -622,6 +823,15 @@ export function subscribe(args) {
     }
     return mapSourceToResponse(exeContext, resultOrStream);
 }
+async function* ensureAsyncIterable(someExecutionResult) {
+    if ('initialResult' in someExecutionResult) {
+        yield someExecutionResult.initialResult;
+        yield* someExecutionResult.subsequentResults;
+    }
+    else {
+        yield someExecutionResult;
+    }
+}
 function mapSourceToResponse(exeContext, resultOrStream) {
     if (!isAsyncIterable(resultOrStream)) {
         return resultOrStream;
@@ -632,7 +842,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 mapAsyncIterator(resultOrStream[Symbol.asyncIterator](), (payload) => executeImpl(buildPerEventExecutionContext(exeContext, payload)));
+    return flattenAsyncIterable(mapAsyncIterator(resultOrStream[Symbol.asyncIterator](), async (payload) => ensureAsyncIterable(await executeImpl(buildPerEventExecutionContext(exeContext, payload)))));
 }
 /**
  * Implements the "CreateSourceEventStream" algorithm described in the
@@ -691,7 +901,7 @@ function executeSubscription(exeContext) {
     if (rootType == null) {
         throw createGraphQLError('Schema is not configured to execute subscription operation.', { nodes: operation });
     }
-    const rootFields = collectFields(schema, fragments, variableValues, rootType, operation.selectionSet);
+    const { fields: rootFields } = 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]);
@@ -735,6 +945,339 @@ 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 (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 (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 (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 = locatedError(rawError, fieldNodes, pathToArray(itemPath));
+                    const handledError = handleFieldError(error, itemType, asyncPayloadRecord.errors);
+                    filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
+                    return handledError;
+                });
+            }
+        }
+        catch (rawError) {
+            const error = locatedError(rawError, fieldNodes, 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 (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 = locatedError(rawError, fieldNodes, 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 (isPromise(completedItem)) {
+            completedItem = completedItem.then(undefined, rawError => {
+                const error = locatedError(rawError, fieldNodes, pathToArray(itemPath));
+                const handledError = handleFieldError(error, itemType, asyncPayloadRecord.errors);
+                filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
+                return handledError;
+            });
+        }
+        return { done: false, value: completedItem };
+    }
+    catch (rawError) {
+        const error = locatedError(rawError, fieldNodes, 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 = 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 (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 = 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 = 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 = 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,