graphql 17.0.0-alpha.8 → 17.0.0-beta.0

package/execution/execute.mjs

@@ -1,43 +1,25 @@
-import { BoxedPromiseOrValue } from "../jsutils/BoxedPromiseOrValue.mjs";
 import { inspect } from "../jsutils/inspect.mjs";
-import { invariant } from "../jsutils/invariant.mjs";
 import { isAsyncIterable } from "../jsutils/isAsyncIterable.mjs";
-import { isIterableObject } from "../jsutils/isIterableObject.mjs";
 import { isObjectLike } from "../jsutils/isObjectLike.mjs";
-import { isPromise } from "../jsutils/isPromise.mjs";
-import { memoize3 } from "../jsutils/memoize3.mjs";
+import { isPromise, isPromiseLike } from "../jsutils/isPromise.mjs";
 import { addPath, pathToArray } from "../jsutils/Path.mjs";
-import { promiseForObject } from "../jsutils/promiseForObject.mjs";
-import { promiseReduce } from "../jsutils/promiseReduce.mjs";
+import { ensureGraphQLError } from "../error/ensureGraphQLError.mjs";
 import { GraphQLError } from "../error/GraphQLError.mjs";
 import { locatedError } from "../error/locatedError.mjs";
-import { OperationTypeNode } from "../language/ast.mjs";
 import { Kind } from "../language/kinds.mjs";
-import { isAbstractType, isLeafType, isListType, isNonNullType, isObjectType, } from "../type/definition.mjs";
-import { GraphQLStreamDirective } from "../type/directives.mjs";
-import { assertValidSchema } from "../type/validate.mjs";
-import { AbortSignalListener, cancellableIterable, cancellablePromise, } from "./AbortSignalListener.mjs";
-import { buildExecutionPlan } from "./buildExecutionPlan.mjs";
-import { collectFields, collectSubfields as _collectSubfields, } from "./collectFields.mjs";
+import { isSubscriptionOperationDefinitionNode } from "../language/predicates.mjs";
+import { GraphQLDisableErrorPropagationDirective } from "../type/directives.mjs";
+import { assertValidSchema } from "../type/index.mjs";
+import { cancellablePromise } from "./cancellablePromise.mjs";
+import { collectFields } from "./collectFields.mjs";
+import { createSharedExecutionContext } from "./createSharedExecutionContext.mjs";
+import { Executor } from "./Executor.mjs";
+import { ExecutorThrowingOnIncremental } from "./ExecutorThrowingOnIncremental.mjs";
 import { getVariableSignature } from "./getVariableSignature.mjs";
-import { buildIncrementalResponse } from "./IncrementalPublisher.mjs";
+import { IncrementalExecutor } from "./incremental/IncrementalExecutor.mjs";
 import { mapAsyncIterable } from "./mapAsyncIterable.mjs";
-import { DeferredFragmentRecord } from "./types.mjs";
-import { experimentalGetArgumentValues, getArgumentValues, getDirectiveValues, getVariableValues, } from "./values.mjs";
-/* eslint-disable @typescript-eslint/max-params */
-// This file contains a lot of such errors but we plan to refactor it anyway
-// so just disable it for entire file.
-/**
- * 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((validatedExecutionArgs, returnType, fieldDetailsList) => {
-    const { schema, fragments, variableValues, hideSuggestions } = validatedExecutionArgs;
-    return _collectSubfields(schema, fragments, variableValues, returnType, fieldDetailsList, hideSuggestions);
-});
+import { getArgumentValues, getVariableValues } from "./values.mjs";
 const UNEXPECTED_EXPERIMENTAL_DIRECTIVES = 'The provided schema unexpectedly contains experimental directives (@defer or @stream). These directives may only be utilized if experimental execution features are explicitly enabled.';
-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.
  *
@@ -58,24 +40,12 @@ export function execute(args) {
     if (args.schema.getDirective('defer') || args.schema.getDirective('stream')) {
         throw new Error(UNEXPECTED_EXPERIMENTAL_DIRECTIVES);
     }
-    const result = experimentalExecuteIncrementally(args);
-    // Multiple payloads could be encountered if the operation contains @defer or
-    // @stream directives and is not validated prior to execution
-    return ensureSinglePayload(result);
-}
-function ensureSinglePayload(result) {
-    if (isPromise(result)) {
-        return result.then((resolved) => {
-            if ('initialResult' in resolved) {
-                throw new Error(UNEXPECTED_MULTIPLE_PAYLOADS);
-            }
-            return resolved;
-        });
-    }
-    if ('initialResult' in result) {
-        throw new Error(UNEXPECTED_MULTIPLE_PAYLOADS);
+    const validatedExecutionArgs = validateExecutionArgs(args);
+    // Return early errors if execution context failed.
+    if (!('schema' in validatedExecutionArgs)) {
+        return { errors: validatedExecutionArgs };
     }
-    return result;
+    return executeRootSelectionSet(validatedExecutionArgs);
 }
 /**
  * Implements the "Executing requests" section of the GraphQL specification,
@@ -97,7 +67,17 @@ export function experimentalExecuteIncrementally(args) {
     if (!('schema' in validatedExecutionArgs)) {
         return { errors: validatedExecutionArgs };
     }
-    return experimentalExecuteQueryOrMutationOrSubscriptionEvent(validatedExecutionArgs);
+    return experimentalExecuteRootSelectionSet(validatedExecutionArgs);
+}
+export function executeIgnoringIncremental(args) {
+    // If a valid execution context cannot be created due to incorrect arguments,
+    // a "Response" with only errors is returned.
+    const validatedExecutionArgs = validateExecutionArgs(args);
+    // Return early errors if execution context failed.
+    if (!('schema' in validatedExecutionArgs)) {
+        return { errors: validatedExecutionArgs };
+    }
+    return executeRootSelectionSetIgnoringIncremental(validatedExecutionArgs);
 }
 /**
  * Implements the "Executing operations" section of the spec.
@@ -114,65 +94,14 @@ export function experimentalExecuteIncrementally(args) {
  * at which point we still log the error and null the parent field, which
  * in this case is the entire response.
  */
-export function executeQueryOrMutationOrSubscriptionEvent(validatedExecutionArgs) {
-    const result = experimentalExecuteQueryOrMutationOrSubscriptionEvent(validatedExecutionArgs);
-    return ensureSinglePayload(result);
+export function executeRootSelectionSet(validatedExecutionArgs) {
+    return new ExecutorThrowingOnIncremental(validatedExecutionArgs).executeRootSelectionSet();
 }
-export function experimentalExecuteQueryOrMutationOrSubscriptionEvent(validatedExecutionArgs) {
-    const abortSignal = validatedExecutionArgs.abortSignal;
-    const exeContext = {
-        validatedExecutionArgs,
-        errors: undefined,
-        abortSignalListener: abortSignal
-            ? new AbortSignalListener(abortSignal)
-            : undefined,
-        completed: false,
-        cancellableStreams: undefined,
-    };
-    try {
-        const { schema, fragments, rootValue, operation, variableValues, hideSuggestions, } = validatedExecutionArgs;
-        const { operation: operationType, selectionSet } = operation;
-        const rootType = schema.getRootType(operationType);
-        if (rootType == null) {
-            throw new GraphQLError(`Schema is not configured to execute ${operationType} operation.`, { nodes: operation });
-        }
-        const { groupedFieldSet, newDeferUsages } = collectFields(schema, fragments, variableValues, rootType, selectionSet, hideSuggestions);
-        const graphqlWrappedResult = executeRootExecutionPlan(exeContext, operation.operation, rootType, rootValue, groupedFieldSet, newDeferUsages);
-        if (isPromise(graphqlWrappedResult)) {
-            return graphqlWrappedResult.then((resolved) => {
-                exeContext.completed = true;
-                return buildDataResponse(exeContext, resolved);
-            }, (error) => {
-                exeContext.completed = true;
-                exeContext.abortSignalListener?.disconnect();
-                return {
-                    data: null,
-                    errors: withError(exeContext.errors, error),
-                };
-            });
-        }
-        exeContext.completed = true;
-        return buildDataResponse(exeContext, graphqlWrappedResult);
-    }
-    catch (error) {
-        exeContext.completed = true;
-        // TODO: add test case for synchronous null bubbling to root with cancellation
-        /* c8 ignore next */
-        exeContext.abortSignalListener?.disconnect();
-        return { data: null, errors: withError(exeContext.errors, error) };
-    }
-}
-function withError(errors, error) {
-    return errors === undefined ? [error] : [...errors, error];
+export function experimentalExecuteRootSelectionSet(validatedExecutionArgs) {
+    return new IncrementalExecutor(validatedExecutionArgs).executeRootSelectionSet();
 }
-function buildDataResponse(exeContext, graphqlWrappedResult) {
-    const { rawResult: data, incrementalDataRecords } = graphqlWrappedResult;
-    const errors = exeContext.errors;
-    if (incrementalDataRecords === undefined) {
-        exeContext.abortSignalListener?.disconnect();
-        return errors !== undefined ? { errors, data } : { data };
-    }
-    return buildIncrementalResponse(exeContext, data, errors, incrementalDataRecords);
+export function executeRootSelectionSetIgnoringIncremental(validatedExecutionArgs) {
+    return new Executor(validatedExecutionArgs).executeRootSelectionSet();
 }
 /**
  * Also implements the "Executing requests" section of the GraphQL specification.
@@ -187,6 +116,95 @@ export function executeSync(args) {
     }
     return result;
 }
+export function executeSubscriptionEvent(validatedExecutionArgs) {
+    return new ExecutorThrowingOnIncremental(validatedExecutionArgs).executeRootSelectionSet(false);
+}
+/**
+ * Implements the "Subscribe" algorithm described in the GraphQL specification.
+ *
+ * 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 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, a field error will be raised at the location of the `@defer` or
+ * `@stream` directive.
+ *
+ * Accepts an object with named arguments.
+ */
+export function subscribe(args) {
+    // If a valid execution context cannot be created due to incorrect arguments,
+    // a "Response" with only errors is returned.
+    const validatedExecutionArgs = validateSubscriptionArgs(args);
+    // Return early errors if execution context failed.
+    if (!('schema' in validatedExecutionArgs)) {
+        return { errors: validatedExecutionArgs };
+    }
+    const resultOrStream = createSourceEventStream(validatedExecutionArgs);
+    if (isPromise(resultOrStream)) {
+        return resultOrStream.then((resolvedResultOrStream) => mapSourceToResponse(validatedExecutionArgs, resolvedResultOrStream));
+    }
+    return mapSourceToResponse(validatedExecutionArgs, resultOrStream);
+}
+/**
+ * Implements the "CreateSourceEventStream" algorithm described in the
+ * GraphQL specification, resolving the subscription source event stream for a
+ * previously validated subscription request.
+ *
+ * Returns a Promise which resolves to either an AsyncIterable (if successful)
+ * or an ExecutionResult (error). The promise will be rejected if the validated
+ * execution arguments 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 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 the AsyncIterable for the
+ * event stream returned by the resolver.
+ *
+ * A Source Event Stream represents a sequence of events, each of which triggers
+ * a GraphQL execution for that event.
+ *
+ * This may be useful when hosting the stateful subscription service in a
+ * different process or machine than the stateless GraphQL execution engine,
+ * or otherwise separating these two steps. For more on this, see the
+ * "Supporting Subscriptions at Scale" information in the GraphQL specification.
+ */
+export function createSourceEventStream(validatedExecutionArgs) {
+    if (!('operation' in validatedExecutionArgs)) {
+        throw new GraphQLError('Passing ExecutionArgs to createSourceEventStream() was removed in graphql-js@17.0.0; call validateSubscriptionArgs() first and pass the result instead, or use subscribe() for the full subscription pipeline.');
+    }
+    try {
+        const eventStream = executeSubscription(validatedExecutionArgs);
+        if (isPromise(eventStream)) {
+            return eventStream.then(undefined, (error) => ({
+                errors: [ensureGraphQLError(error)],
+            }));
+        }
+        return eventStream;
+    }
+    catch (error) {
+        return { errors: [ensureGraphQLError(error)] };
+    }
+}
 /**
  * Constructs a ExecutionContext object from the arguments passed to
  * execute, which we will pass throughout the other execution methods.
@@ -197,10 +215,7 @@ export function executeSync(args) {
  * @internal
  */
 export function validateExecutionArgs(args) {
-    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, perEventExecutor, enableEarlyExecution, abortSignal, } = args;
-    if (abortSignal?.aborted) {
-        return [locatedError(abortSignal.reason, undefined)];
-    }
+    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, perEventExecutor, abortSignal: externalAbortSignal, enableEarlyExecution, hooks, options, } = args;
     // If the schema used for execution is invalid, throw an error.
     assertValidSchema(schema);
     let operation;
@@ -247,12 +262,13 @@ export function validateExecutionArgs(args) {
     const variableDefinitions = operation.variableDefinitions ?? [];
     const hideSuggestions = args.hideSuggestions ?? false;
     const variableValuesOrErrors = getVariableValues(schema, variableDefinitions, rawVariableValues ?? {}, {
-        maxErrors: 50,
+        maxErrors: options?.maxCoercionErrors ?? 50,
         hideSuggestions,
     });
     if (variableValuesOrErrors.errors) {
         return variableValuesOrErrors.errors;
     }
+    const errorPropagation = !operation.directives?.find((directive) => directive.name.value === GraphQLDisableErrorPropagationDirective.name);
     return {
         schema,
         fragmentDefinitions,
@@ -265,690 +281,25 @@ export function validateExecutionArgs(args) {
         typeResolver: typeResolver ?? defaultTypeResolver,
         subscribeFieldResolver: subscribeFieldResolver ?? defaultFieldResolver,
         perEventExecutor: perEventExecutor ?? executeSubscriptionEvent,
-        enableEarlyExecution: enableEarlyExecution === true,
         hideSuggestions,
-        abortSignal: args.abortSignal ?? undefined,
-    };
-}
-function executeRootExecutionPlan(exeContext, operation, rootType, rootValue, originalGroupedFieldSet, newDeferUsages) {
-    if (newDeferUsages.length === 0) {
-        return executeRootGroupedFieldSet(exeContext, operation, rootType, rootValue, originalGroupedFieldSet, undefined);
-    }
-    const newDeferMap = getNewDeferMap(newDeferUsages, undefined, undefined);
-    const { groupedFieldSet, newGroupedFieldSets } = buildExecutionPlan(originalGroupedFieldSet);
-    const graphqlWrappedResult = executeRootGroupedFieldSet(exeContext, operation, rootType, rootValue, groupedFieldSet, newDeferMap);
-    if (newGroupedFieldSets.size > 0) {
-        const newPendingExecutionGroups = collectExecutionGroups(exeContext, rootType, rootValue, undefined, undefined, newGroupedFieldSets, newDeferMap);
-        return withNewExecutionGroups(graphqlWrappedResult, newPendingExecutionGroups);
-    }
-    return graphqlWrappedResult;
-}
-function withNewExecutionGroups(result, newPendingExecutionGroups) {
-    if (isPromise(result)) {
-        return result.then((resolved) => {
-            addIncrementalDataRecords(resolved, newPendingExecutionGroups);
-            return resolved;
-        });
-    }
-    addIncrementalDataRecords(result, newPendingExecutionGroups);
-    return result;
-}
-function executeRootGroupedFieldSet(exeContext, operation, rootType, rootValue, groupedFieldSet, deferMap) {
-    switch (operation) {
-        case OperationTypeNode.QUERY:
-            return executeFields(exeContext, rootType, rootValue, undefined, groupedFieldSet, undefined, deferMap);
-        case OperationTypeNode.MUTATION:
-            return executeFieldsSerially(exeContext, rootType, rootValue, undefined, groupedFieldSet, undefined, deferMap);
-        case OperationTypeNode.SUBSCRIPTION:
-            // TODO: deprecate `subscribe` and move all logic here
-            // Temporary solution until we finish merging execute and subscribe together
-            return executeFields(exeContext, rootType, rootValue, undefined, groupedFieldSet, undefined, deferMap);
-    }
-}
-/**
- * Implements the "Executing selection sets" section of the spec
- * for fields that must be executed serially.
- */
-function executeFieldsSerially(exeContext, parentType, sourceValue, path, groupedFieldSet, incrementalContext, deferMap) {
-    const abortSignal = exeContext.validatedExecutionArgs.abortSignal;
-    return promiseReduce(groupedFieldSet, (graphqlWrappedResult, [responseName, fieldDetailsList]) => {
-        const fieldPath = addPath(path, responseName, parentType.name);
-        if (abortSignal?.aborted) {
-            handleFieldError(abortSignal.reason, exeContext, parentType, fieldDetailsList, fieldPath, incrementalContext);
-            graphqlWrappedResult.rawResult[responseName] = null;
-            return graphqlWrappedResult;
-        }
-        const result = executeField(exeContext, parentType, sourceValue, fieldDetailsList, fieldPath, incrementalContext, deferMap);
-        if (result === undefined) {
-            return graphqlWrappedResult;
-        }
-        if (isPromise(result)) {
-            return result.then((resolved) => {
-                graphqlWrappedResult.rawResult[responseName] = resolved.rawResult;
-                addIncrementalDataRecords(graphqlWrappedResult, resolved.incrementalDataRecords);
-                return graphqlWrappedResult;
-            });
-        }
-        graphqlWrappedResult.rawResult[responseName] = result.rawResult;
-        addIncrementalDataRecords(graphqlWrappedResult, result.incrementalDataRecords);
-        return graphqlWrappedResult;
-    }, {
-        rawResult: Object.create(null),
-        incrementalDataRecords: undefined,
-    });
-}
-function addIncrementalDataRecords(graphqlWrappedResult, incrementalDataRecords) {
-    if (incrementalDataRecords === undefined) {
-        return;
-    }
-    if (graphqlWrappedResult.incrementalDataRecords === undefined) {
-        graphqlWrappedResult.incrementalDataRecords = [...incrementalDataRecords];
-    }
-    else {
-        graphqlWrappedResult.incrementalDataRecords.push(...incrementalDataRecords);
-    }
-}
-/**
- * Implements the "Executing selection sets" section of the spec
- * for fields that may be executed in parallel.
- */
-function executeFields(exeContext, parentType, sourceValue, path, groupedFieldSet, incrementalContext, deferMap) {
-    const results = Object.create(null);
-    const graphqlWrappedResult = {
-        rawResult: results,
-        incrementalDataRecords: undefined,
-    };
-    let containsPromise = false;
-    try {
-        for (const [responseName, fieldDetailsList] of groupedFieldSet) {
-            const fieldPath = addPath(path, responseName, parentType.name);
-            const result = executeField(exeContext, parentType, sourceValue, fieldDetailsList, fieldPath, incrementalContext, deferMap);
-            if (result !== undefined) {
-                if (isPromise(result)) {
-                    results[responseName] = result.then((resolved) => {
-                        addIncrementalDataRecords(graphqlWrappedResult, resolved.incrementalDataRecords);
-                        return resolved.rawResult;
-                    });
-                    containsPromise = true;
-                }
-                else {
-                    results[responseName] = result.rawResult;
-                    addIncrementalDataRecords(graphqlWrappedResult, result.incrementalDataRecords);
-                }
-            }
-        }
-    }
-    catch (error) {
-        if (containsPromise) {
-            // Ensure that any promises returned by other fields are handled, as they may also reject.
-            return promiseForObject(results, () => {
-                /* noop */
-            }).finally(() => {
-                throw error;
-            });
-        }
-        throw error;
-    }
-    // If there are no promises, we can just return the object and any incrementalDataRecords
-    if (!containsPromise) {
-        return graphqlWrappedResult;
-    }
-    // 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 promiseForObject(results, (resolved) => ({
-        rawResult: resolved,
-        incrementalDataRecords: graphqlWrappedResult.incrementalDataRecords,
-    }));
-}
-function toNodes(fieldDetailsList) {
-    return fieldDetailsList.map((fieldDetails) => fieldDetails.node);
-}
-/**
- * Implements the "Executing fields" section of the spec
- * In particular, this function figures out the value that the field returns by
- * calling its resolve function, then calls completeValue to complete promises,
- * coercing scalars, or execute the sub-selection-set for objects.
- */
-function executeField(exeContext, parentType, source, fieldDetailsList, path, incrementalContext, deferMap) {
-    const { validatedExecutionArgs, abortSignalListener } = exeContext;
-    const { schema, contextValue, variableValues, hideSuggestions, abortSignal } = validatedExecutionArgs;
-    const fieldName = fieldDetailsList[0].node.name.value;
-    const fieldDef = schema.getField(parentType, fieldName);
-    if (!fieldDef) {
-        return;
-    }
-    const returnType = fieldDef.type;
-    const resolveFn = fieldDef.resolve ?? validatedExecutionArgs.fieldResolver;
-    const info = buildResolveInfo(validatedExecutionArgs, fieldDef, toNodes(fieldDetailsList), parentType, path);
-    // Get the resolve function, regardless of if its result is normal or abrupt (error).
-    try {
-        // Build a JS object of arguments from the field.arguments AST, using the
-        // variables scope to fulfill any variable references.
-        // TODO: find a way to memoize, in case this field is within a List type.
-        const args = experimentalGetArgumentValues(fieldDetailsList[0].node, fieldDef.args, variableValues, fieldDetailsList[0].fragmentVariableValues, hideSuggestions);
-        // The resolve function's optional third argument is a context value that
-        // is provided to every resolve function within an execution. It is commonly
-        // used to represent an authenticated user, or request-specific caches.
-        const result = resolveFn(source, args, contextValue, info, abortSignal);
-        if (isPromise(result)) {
-            return completePromisedValue(exeContext, returnType, fieldDetailsList, info, path, abortSignalListener
-                ? cancellablePromise(result, abortSignalListener)
-                : result, incrementalContext, deferMap);
-        }
-        const completed = completeValue(exeContext, returnType, fieldDetailsList, info, path, result, incrementalContext, deferMap);
-        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) => {
-                handleFieldError(rawError, exeContext, returnType, fieldDetailsList, path, incrementalContext);
-                return { rawResult: null, incrementalDataRecords: undefined };
-            });
-        }
-        return completed;
-    }
-    catch (rawError) {
-        handleFieldError(rawError, exeContext, returnType, fieldDetailsList, path, incrementalContext);
-        return { rawResult: null, incrementalDataRecords: undefined };
-    }
-}
-/**
- * TODO: consider no longer exporting this function
- * @internal
- */
-export function buildResolveInfo(validatedExecutionArgs, fieldDef, fieldNodes, parentType, path) {
-    const { schema, fragmentDefinitions, rootValue, operation, variableValues } = validatedExecutionArgs;
-    // The resolve function's optional fourth argument is a collection of
-    // information about the current execution state.
-    return {
-        fieldName: fieldDef.name,
-        fieldNodes,
-        returnType: fieldDef.type,
-        parentType,
-        path,
-        schema,
-        fragments: fragmentDefinitions,
-        rootValue,
-        operation,
-        variableValues,
-    };
-}
-function handleFieldError(rawError, exeContext, returnType, fieldDetailsList, path, incrementalContext) {
-    const error = locatedError(rawError, toNodes(fieldDetailsList), pathToArray(path));
-    // 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)) {
-        throw error;
-    }
-    // Otherwise, error protection is applied, logging the error and resolving
-    // a null value for this field if one is encountered.
-    const context = incrementalContext ?? exeContext;
-    let errors = context.errors;
-    if (errors === undefined) {
-        errors = [];
-        context.errors = errors;
-    }
-    errors.push(error);
-}
-/**
- * Implements the instructions for completeValue as defined in the
- * "Value Completion" section of the spec.
- *
- * If the field type is Non-Null, then this recursively completes the value
- * for the inner type. It throws a field error if that completion returns null,
- * as per the "Nullability" section of the spec.
- *
- * If the field type is a List, then this recursively completes the value
- * for the inner type on each item in the list.
- *
- * If the field type is a Scalar or Enum, ensures the completed value is a legal
- * value of the type by calling the `coerceOutputValue` method of GraphQL type
- * definition.
- *
- * If the field is an abstract type, determine the runtime type of the value
- * and then complete based on that type
- *
- * Otherwise, the field type expects a sub-selection set, and will complete the
- * value by executing all sub-selections.
- */
-function completeValue(exeContext, returnType, fieldDetailsList, info, path, result, incrementalContext, deferMap) {
-    // If result is an Error, throw a located error.
-    if (result instanceof Error) {
-        throw 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, fieldDetailsList, info, path, result, incrementalContext, deferMap);
-        if (completed.rawResult === null) {
-            throw new Error(`Cannot return null for non-nullable field ${info.parentType}.${info.fieldName}.`);
-        }
-        return completed;
-    }
-    // If result value is null or undefined then return null.
-    if (result == null) {
-        return { rawResult: null, incrementalDataRecords: undefined };
-    }
-    // If field type is List, complete each item in the list with the inner type
-    if (isListType(returnType)) {
-        return completeListValue(exeContext, returnType, fieldDetailsList, info, path, result, incrementalContext, deferMap);
-    }
-    // If field type is a leaf type, Scalar or Enum, coerce to a valid value,
-    // returning null if coercion is not possible.
-    if (isLeafType(returnType)) {
-        return {
-            rawResult: completeLeafValue(returnType, result),
-            incrementalDataRecords: undefined,
-        };
-    }
-    // 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, fieldDetailsList, info, path, result, incrementalContext, deferMap);
-    }
-    // If field type is Object, execute and complete all sub-selections.
-    if (isObjectType(returnType)) {
-        return completeObjectValue(exeContext, returnType, fieldDetailsList, info, path, result, incrementalContext, deferMap);
-    }
-    /* c8 ignore next 6 */
-    // Not reachable, all possible output types have been considered.
-    (false) || invariant(false, 'Cannot complete value of unexpected output type: ' + inspect(returnType));
-}
-async function completePromisedValue(exeContext, returnType, fieldDetailsList, info, path, result, incrementalContext, deferMap) {
-    try {
-        const resolved = await result;
-        let completed = completeValue(exeContext, returnType, fieldDetailsList, info, path, resolved, incrementalContext, deferMap);
-        if (isPromise(completed)) {
-            completed = await completed;
-        }
-        return completed;
-    }
-    catch (rawError) {
-        handleFieldError(rawError, exeContext, returnType, fieldDetailsList, path, incrementalContext);
-        return { rawResult: null, incrementalDataRecords: undefined };
-    }
-}
-/**
- * Returns an object containing info for streaming if a field should be
- * streamed based on the experimental flag, stream directive present and
- * not disabled by the "if" argument.
- */
-function getStreamUsage(validatedExecutionArgs, fieldDetailsList, path) {
-    // do not stream inner lists of multi-dimensional lists
-    if (typeof path.key === 'number') {
-        return;
-    }
-    // TODO: add test for this case (a streamed list nested under a list).
-    /* c8 ignore next 7 */
-    if (fieldDetailsList
-        ._streamUsage !== undefined) {
-        return fieldDetailsList
-            ._streamUsage;
-    }
-    const { operation, variableValues } = validatedExecutionArgs;
-    // 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, fieldDetailsList[0].node, variableValues, fieldDetailsList[0].fragmentVariableValues);
-    if (!stream) {
-        return;
-    }
-    if (stream.if === false) {
-        return;
-    }
-    (typeof stream.initialCount === 'number') || invariant(false, 'initialCount must be a number');
-    (stream.initialCount >= 0) || invariant(false, 'initialCount must be a positive integer');
-    (operation.operation !== OperationTypeNode.SUBSCRIPTION) || invariant(false, '`@stream` directive not supported on subscription operations. Disable `@stream` by setting the `if` argument to `false`.');
-    const streamedFieldDetailsList = fieldDetailsList.map((fieldDetails) => ({
-        node: fieldDetails.node,
-        deferUsage: undefined,
-        fragmentVariableValues: fieldDetails.fragmentVariableValues,
-    }));
-    const streamUsage = {
-        initialCount: stream.initialCount,
-        label: typeof stream.label === 'string' ? stream.label : undefined,
-        fieldDetailsList: streamedFieldDetailsList,
-    };
-    fieldDetailsList._streamUsage =
-        streamUsage;
-    return streamUsage;
-}
-/**
- * Complete a async iterator value by completing the result and calling
- * recursively until all the results are completed.
- */
-async function completeAsyncIteratorValue(exeContext, itemType, fieldDetailsList, info, path, asyncIterator, incrementalContext, deferMap) {
-    let containsPromise = false;
-    const completedResults = [];
-    const graphqlWrappedResult = {
-        rawResult: completedResults,
-        incrementalDataRecords: undefined,
-    };
-    let index = 0;
-    const streamUsage = getStreamUsage(exeContext.validatedExecutionArgs, fieldDetailsList, path);
-    const earlyReturn = asyncIterator.return === undefined
-        ? undefined
-        : asyncIterator.return.bind(asyncIterator);
-    try {
-        while (true) {
-            if (streamUsage && index >= streamUsage.initialCount) {
-                const streamItemQueue = buildAsyncStreamItemQueue(index, path, asyncIterator, exeContext, streamUsage.fieldDetailsList, info, itemType);
-                let streamRecord;
-                if (earlyReturn === undefined) {
-                    streamRecord = {
-                        label: streamUsage.label,
-                        path,
-                        streamItemQueue,
-                    };
-                }
-                else {
-                    streamRecord = {
-                        label: streamUsage.label,
-                        path,
-                        earlyReturn,
-                        streamItemQueue,
-                    };
-                    if (exeContext.cancellableStreams === undefined) {
-                        exeContext.cancellableStreams = new Set();
-                    }
-                    exeContext.cancellableStreams.add(streamRecord);
-                }
-                addIncrementalDataRecords(graphqlWrappedResult, [streamRecord]);
-                break;
-            }
-            const itemPath = addPath(path, index, undefined);
-            let iteration;
-            try {
-                // eslint-disable-next-line no-await-in-loop
-                iteration = await asyncIterator.next();
-            }
-            catch (rawError) {
-                throw locatedError(rawError, toNodes(fieldDetailsList), pathToArray(path));
-            }
-            // TODO: add test case for stream returning done before initialCount
-            /* c8 ignore next 3 */
-            if (iteration.done) {
-                break;
-            }
-            const item = iteration.value;
-            // TODO: add tests for stream backed by asyncIterator that returns a promise
-            /* c8 ignore start */
-            if (isPromise(item)) {
-                completedResults.push(completePromisedListItemValue(item, graphqlWrappedResult, exeContext, itemType, fieldDetailsList, info, itemPath, incrementalContext, deferMap));
-                containsPromise = true;
-            }
-            else if (
-            /* c8 ignore stop */
-            completeListItemValue(item, completedResults, graphqlWrappedResult, exeContext, itemType, fieldDetailsList, info, itemPath, incrementalContext, deferMap)
-            // TODO: add tests for stream backed by asyncIterator that completes to a promise
-            /* c8 ignore start */
-            ) {
-                containsPromise = true;
-            }
-            /* c8 ignore stop */
-            index++;
-        }
-    }
-    catch (error) {
-        if (earlyReturn !== undefined) {
-            earlyReturn().catch(() => {
-                /* c8 ignore next 1 */
-                // ignore error
-            });
-        }
-        throw error;
-    }
-    return containsPromise
-        ? /* c8 ignore start */ Promise.all(completedResults).then((resolved) => ({
-            rawResult: resolved,
-            incrementalDataRecords: graphqlWrappedResult.incrementalDataRecords,
-        }))
-        : /* c8 ignore stop */ graphqlWrappedResult;
-}
-/**
- * Complete a list value by completing each item in the list with the
- * inner type
- */
-function completeListValue(exeContext, returnType, fieldDetailsList, info, path, result, incrementalContext, deferMap) {
-    const itemType = returnType.ofType;
-    if (isAsyncIterable(result)) {
-        const abortSignalListener = exeContext.abortSignalListener;
-        const maybeCancellableIterable = abortSignalListener
-            ? cancellableIterable(result, abortSignalListener)
-            : result;
-        const asyncIterator = maybeCancellableIterable[Symbol.asyncIterator]();
-        return completeAsyncIteratorValue(exeContext, itemType, fieldDetailsList, info, path, asyncIterator, incrementalContext, deferMap);
-    }
-    if (!isIterableObject(result)) {
-        throw new GraphQLError(`Expected Iterable, but did not find one for field "${info.parentType}.${info.fieldName}".`);
-    }
-    return completeIterableValue(exeContext, itemType, fieldDetailsList, info, path, result, incrementalContext, deferMap);
-}
-function completeIterableValue(exeContext, itemType, fieldDetailsList, info, path, items, incrementalContext, deferMap) {
-    // 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 = [];
-    const graphqlWrappedResult = {
-        rawResult: completedResults,
-        incrementalDataRecords: undefined,
+        errorPropagation,
+        externalAbortSignal: externalAbortSignal ?? undefined,
+        enableEarlyExecution: enableEarlyExecution === true,
+        hooks: hooks ?? undefined,
     };
-    let index = 0;
-    const streamUsage = getStreamUsage(exeContext.validatedExecutionArgs, fieldDetailsList, path);
-    const iterator = items[Symbol.iterator]();
-    let iteration = iterator.next();
-    while (!iteration.done) {
-        const item = iteration.value;
-        if (streamUsage && index >= streamUsage.initialCount) {
-            const syncStreamRecord = {
-                label: streamUsage.label,
-                path,
-                streamItemQueue: buildSyncStreamItemQueue(item, index, path, iterator, exeContext, streamUsage.fieldDetailsList, info, itemType),
-            };
-            addIncrementalDataRecords(graphqlWrappedResult, [syncStreamRecord]);
-            break;
-        }
-        // 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);
-        if (isPromise(item)) {
-            completedResults.push(completePromisedListItemValue(item, graphqlWrappedResult, exeContext, itemType, fieldDetailsList, info, itemPath, incrementalContext, deferMap));
-            containsPromise = true;
-        }
-        else if (completeListItemValue(item, completedResults, graphqlWrappedResult, exeContext, itemType, fieldDetailsList, info, itemPath, incrementalContext, deferMap)) {
-            containsPromise = true;
-        }
-        index++;
-        iteration = iterator.next();
-    }
-    return containsPromise
-        ? Promise.all(completedResults).then((resolved) => ({
-            rawResult: resolved,
-            incrementalDataRecords: graphqlWrappedResult.incrementalDataRecords,
-        }))
-        : graphqlWrappedResult;
-}
-/**
- * Complete a list item value by adding it to the completed results.
- *
- * Returns true if the value is a Promise.
- */
-function completeListItemValue(item, completedResults, parent, exeContext, itemType, fieldDetailsList, info, itemPath, incrementalContext, deferMap) {
-    try {
-        const completedItem = completeValue(exeContext, itemType, fieldDetailsList, info, itemPath, item, incrementalContext, deferMap);
-        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((resolved) => {
-                addIncrementalDataRecords(parent, resolved.incrementalDataRecords);
-                return resolved.rawResult;
-            }, (rawError) => {
-                handleFieldError(rawError, exeContext, itemType, fieldDetailsList, itemPath, incrementalContext);
-                return null;
-            }));
-            return true;
-        }
-        completedResults.push(completedItem.rawResult);
-        addIncrementalDataRecords(parent, completedItem.incrementalDataRecords);
-    }
-    catch (rawError) {
-        handleFieldError(rawError, exeContext, itemType, fieldDetailsList, itemPath, incrementalContext);
-        completedResults.push(null);
-    }
-    return false;
-}
-async function completePromisedListItemValue(item, parent, exeContext, itemType, fieldDetailsList, info, itemPath, incrementalContext, deferMap) {
-    try {
-        const abortSignalListener = exeContext.abortSignalListener;
-        const maybeCancellableItem = abortSignalListener
-            ? cancellablePromise(item, abortSignalListener)
-            : item;
-        const resolved = await maybeCancellableItem;
-        let completed = completeValue(exeContext, itemType, fieldDetailsList, info, itemPath, resolved, incrementalContext, deferMap);
-        if (isPromise(completed)) {
-            completed = await completed;
-        }
-        addIncrementalDataRecords(parent, completed.incrementalDataRecords);
-        return completed.rawResult;
-    }
-    catch (rawError) {
-        handleFieldError(rawError, exeContext, itemType, fieldDetailsList, itemPath, incrementalContext);
-        return null;
-    }
-}
-/**
- * Complete a Scalar or Enum by serializing to a valid value, returning
- * null if serialization is not possible.
- */
-function completeLeafValue(returnType, result) {
-    const coerced = returnType.coerceOutputValue(result);
-    if (coerced == null) {
-        throw new Error(`Expected \`${inspect(returnType)}.coerceOutputValue(${inspect(result)})\` to ` +
-            `return non-nullable value, returned: ${inspect(coerced)}`);
-    }
-    return coerced;
-}
-/**
- * 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, fieldDetailsList, info, path, result, incrementalContext, deferMap) {
-    const validatedExecutionArgs = exeContext.validatedExecutionArgs;
-    const { schema, contextValue } = validatedExecutionArgs;
-    const resolveTypeFn = returnType.resolveType ?? validatedExecutionArgs.typeResolver;
-    const runtimeType = resolveTypeFn(result, contextValue, info, returnType);
-    if (isPromise(runtimeType)) {
-        return runtimeType.then((resolvedRuntimeType) => completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeType, schema, returnType, fieldDetailsList, info, result), fieldDetailsList, info, path, result, incrementalContext, deferMap));
-    }
-    return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeType, schema, returnType, fieldDetailsList, info, result), fieldDetailsList, info, path, result, incrementalContext, deferMap);
-}
-function ensureValidRuntimeType(runtimeTypeName, schema, returnType, fieldDetailsList, info, result) {
-    if (runtimeTypeName == null) {
-        throw new GraphQLError(`Abstract type "${returnType}" must resolve to an Object type at runtime for field "${info.parentType}.${info.fieldName}". Either the "${returnType}" type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.`, { nodes: toNodes(fieldDetailsList) });
-    }
-    if (typeof runtimeTypeName !== 'string') {
-        throw new GraphQLError(`Abstract type "${returnType}" must resolve to an Object type at runtime for field "${info.parentType}.${info.fieldName}" with ` +
-            `value ${inspect(result)}, received "${inspect(runtimeTypeName)}", which is not a valid Object type name.`);
-    }
-    const runtimeType = schema.getType(runtimeTypeName);
-    if (runtimeType == null) {
-        throw new GraphQLError(`Abstract type "${returnType}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`, { nodes: toNodes(fieldDetailsList) });
-    }
-    if (!isObjectType(runtimeType)) {
-        throw new GraphQLError(`Abstract type "${returnType}" was resolved to a non-object type "${runtimeTypeName}".`, { nodes: toNodes(fieldDetailsList) });
-    }
-    if (!schema.isSubType(returnType, runtimeType)) {
-        throw new GraphQLError(`Runtime Object type "${runtimeType}" is not a possible type for "${returnType}".`, { nodes: toNodes(fieldDetailsList) });
-    }
-    return runtimeType;
-}
-/**
- * Complete an Object value by executing all sub-selections.
- */
-function completeObjectValue(exeContext, returnType, fieldDetailsList, info, path, result, incrementalContext, deferMap) {
-    if ((incrementalContext ?? exeContext).completed) {
-        throw new Error('Completed, aborting.');
-    }
-    // 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.
-    if (returnType.isTypeOf) {
-        const isTypeOf = returnType.isTypeOf(result, exeContext.validatedExecutionArgs.contextValue, info);
-        if (isPromise(isTypeOf)) {
-            return isTypeOf.then((resolvedIsTypeOf) => {
-                if (!resolvedIsTypeOf) {
-                    throw invalidReturnTypeError(returnType, result, fieldDetailsList);
-                }
-                return collectAndExecuteSubfields(exeContext, returnType, fieldDetailsList, path, result, incrementalContext, deferMap);
-            });
-        }
-        if (!isTypeOf) {
-            throw invalidReturnTypeError(returnType, result, fieldDetailsList);
-        }
-    }
-    return collectAndExecuteSubfields(exeContext, returnType, fieldDetailsList, path, result, incrementalContext, deferMap);
-}
-function invalidReturnTypeError(returnType, result, fieldDetailsList) {
-    return new GraphQLError(`Expected value of type "${returnType}" but got: ${inspect(result)}.`, { nodes: toNodes(fieldDetailsList) });
-}
-/**
- * Instantiates new DeferredFragmentRecords for the given path within an
- * incremental data record, returning an updated map of DeferUsage
- * objects to DeferredFragmentRecords.
- *
- * Note: As defer directives may be used with operations returning lists,
- * a DeferUsage object may correspond to many DeferredFragmentRecords.
- */
-function getNewDeferMap(newDeferUsages, deferMap, path) {
-    const newDeferMap = new Map(deferMap);
-    // For each new deferUsage object:
-    for (const newDeferUsage of newDeferUsages) {
-        const parentDeferUsage = newDeferUsage.parentDeferUsage;
-        const parent = parentDeferUsage === undefined
-            ? undefined
-            : deferredFragmentRecordFromDeferUsage(parentDeferUsage, newDeferMap);
-        // Instantiate the new record.
-        const deferredFragmentRecord = new DeferredFragmentRecord(path, newDeferUsage.label, parent);
-        // Update the map.
-        newDeferMap.set(newDeferUsage, deferredFragmentRecord);
-    }
-    return newDeferMap;
 }
-function deferredFragmentRecordFromDeferUsage(deferUsage, deferMap) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return deferMap.get(deferUsage);
-}
-function collectAndExecuteSubfields(exeContext, returnType, fieldDetailsList, path, result, incrementalContext, deferMap) {
-    const validatedExecutionArgs = exeContext.validatedExecutionArgs;
-    // Collect sub-fields to execute to complete this value.
-    const collectedSubfields = collectSubfields(validatedExecutionArgs, returnType, fieldDetailsList);
-    const { groupedFieldSet, newDeferUsages } = collectedSubfields;
-    if (newDeferUsages.length > 0) {
-        (validatedExecutionArgs.operation.operation !==
-            OperationTypeNode.SUBSCRIPTION) || invariant(false, '`@defer` directive not supported on subscription operations. Disable `@defer` by setting the `if` argument to `false`.');
-    }
-    return executeSubExecutionPlan(exeContext, returnType, result, groupedFieldSet, newDeferUsages, path, incrementalContext, deferMap);
-}
-function executeSubExecutionPlan(exeContext, returnType, sourceValue, originalGroupedFieldSet, newDeferUsages, path, incrementalContext, deferMap) {
-    if (deferMap === undefined && newDeferUsages.length === 0) {
-        return executeFields(exeContext, returnType, sourceValue, path, originalGroupedFieldSet, incrementalContext, deferMap);
-    }
-    const newDeferMap = getNewDeferMap(newDeferUsages, deferMap, path);
-    const { groupedFieldSet, newGroupedFieldSets } = buildSubExecutionPlan(originalGroupedFieldSet, incrementalContext?.deferUsageSet);
-    const graphqlWrappedResult = executeFields(exeContext, returnType, sourceValue, path, groupedFieldSet, incrementalContext, newDeferMap);
-    if (newGroupedFieldSets.size > 0) {
-        const newPendingExecutionGroups = collectExecutionGroups(exeContext, returnType, sourceValue, path, incrementalContext?.deferUsageSet, newGroupedFieldSets, newDeferMap);
-        return withNewExecutionGroups(graphqlWrappedResult, newPendingExecutionGroups);
+export function validateSubscriptionArgs(args) {
+    const validatedExecutionArgs = validateExecutionArgs(args);
+    if (!('schema' in validatedExecutionArgs)) {
+        return validatedExecutionArgs;
     }
-    return graphqlWrappedResult;
+    assertSubscriptionExecutionArgs(validatedExecutionArgs);
+    return validatedExecutionArgs;
 }
-function buildSubExecutionPlan(originalGroupedFieldSet, deferUsageSet) {
-    let executionPlan = originalGroupedFieldSet._executionPlan;
-    if (executionPlan !== undefined) {
-        return executionPlan;
+function assertSubscriptionExecutionArgs(validatedExecutionArgs) {
+    if (!isSubscriptionOperationDefinitionNode(validatedExecutionArgs.operation)) {
+        throw new GraphQLError('Expected subscription operation.');
     }
-    executionPlan = buildExecutionPlan(originalGroupedFieldSet, deferUsageSet);
-    originalGroupedFieldSet._executionPlan = executionPlan;
-    return executionPlan;
 }
 /**
  * If a resolveType function is not given, then a default resolve behavior is
@@ -968,25 +319,34 @@ export const defaultTypeResolver = function (value, contextValue, info, abstract
     // Otherwise, test each possible type.
     const possibleTypes = info.schema.getPossibleTypes(abstractType);
     const promisedIsTypeOfResults = [];
-    for (let i = 0; i < possibleTypes.length; i++) {
-        const type = possibleTypes[i];
-        if (type.isTypeOf) {
-            const isTypeOfResult = type.isTypeOf(value, contextValue, info);
-            if (isPromise(isTypeOfResult)) {
-                promisedIsTypeOfResults[i] = isTypeOfResult;
-            }
-            else if (isTypeOfResult) {
-                if (promisedIsTypeOfResults.length > 0) {
-                    Promise.all(promisedIsTypeOfResults).then(undefined, () => {
-                        /* ignore errors */
-                    });
+    try {
+        for (let i = 0; i < possibleTypes.length; i++) {
+            const type = possibleTypes[i];
+            if (type.isTypeOf) {
+                const isTypeOfResult = type.isTypeOf(value, contextValue, info);
+                if (isPromiseLike(isTypeOfResult)) {
+                    promisedIsTypeOfResults[i] = isTypeOfResult;
+                }
+                else if (isTypeOfResult) {
+                    if (promisedIsTypeOfResults.length) {
+                        info.getAsyncHelpers().track(promisedIsTypeOfResults);
+                    }
+                    return type.name;
                 }
-                return type.name;
             }
         }
     }
+    catch (error) {
+        if (promisedIsTypeOfResults.length) {
+            info.getAsyncHelpers().track(promisedIsTypeOfResults);
+        }
+        throw error;
+    }
     if (promisedIsTypeOfResults.length) {
-        return Promise.all(promisedIsTypeOfResults).then((isTypeOfResults) => {
+        return info
+            .getAsyncHelpers()
+            .promiseAll(promisedIsTypeOfResults)
+            .then((isTypeOfResults) => {
             for (let i = 0; i < isTypeOfResults.length; i++) {
                 if (isTypeOfResults[i]) {
                     return possibleTypes[i].name;
@@ -1001,135 +361,43 @@ export const defaultTypeResolver = function (value, contextValue, info, abstract
  * and returns it as the result, or if it's a function, returns the result
  * of calling that function while passing along args and context value.
  */
-export const defaultFieldResolver = function (source, args, contextValue, info, abortSignal) {
+export const defaultFieldResolver = function (source, args, contextValue, info) {
     // ensure source is a value for which property access is acceptable.
     if (isObjectLike(source) || typeof source === 'function') {
         const property = source[info.fieldName];
         if (typeof property === 'function') {
-            return source[info.fieldName](args, contextValue, info, abortSignal);
+            return source[info.fieldName](args, contextValue, info);
         }
         return property;
     }
 };
-/**
- * Implements the "Subscribe" algorithm described in the GraphQL specification.
- *
- * 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 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, a field error will be raised at the location of the `@defer` or
- * `@stream` directive.
- *
- * Accepts an object with named arguments.
- */
-export function subscribe(args) {
-    // If a valid execution context cannot be created due to incorrect arguments,
-    // a "Response" with only errors is returned.
-    const validatedExecutionArgs = validateExecutionArgs(args);
-    // Return early errors if execution context failed.
-    if (!('schema' in validatedExecutionArgs)) {
-        return { errors: validatedExecutionArgs };
-    }
-    const resultOrStream = createSourceEventStreamImpl(validatedExecutionArgs);
-    if (isPromise(resultOrStream)) {
-        return resultOrStream.then((resolvedResultOrStream) => mapSourceToResponse(validatedExecutionArgs, resolvedResultOrStream));
-    }
-    return mapSourceToResponse(validatedExecutionArgs, resultOrStream);
-}
 function mapSourceToResponse(validatedExecutionArgs, resultOrStream) {
     if (!isAsyncIterable(resultOrStream)) {
         return resultOrStream;
     }
-    const abortSignal = validatedExecutionArgs.abortSignal;
-    const abortSignalListener = abortSignal
-        ? new AbortSignalListener(abortSignal)
-        : undefined;
     // For each payload yielded from a subscription, map it over the normal
     // GraphQL `execute` function, with `payload` as the rootValue.
     // This implements the "MapSourceToResponseEvent" algorithm described in
     // the GraphQL specification..
-    return mapAsyncIterable(abortSignalListener
-        ? cancellableIterable(resultOrStream, abortSignalListener)
-        : resultOrStream, (payload) => {
+    function mapFn(payload) {
         const perEventExecutionArgs = {
             ...validatedExecutionArgs,
             rootValue: payload,
         };
         return validatedExecutionArgs.perEventExecutor(perEventExecutionArgs);
-    }, () => abortSignalListener?.disconnect());
-}
-export function executeSubscriptionEvent(validatedExecutionArgs) {
-    return executeQueryOrMutationOrSubscriptionEvent(validatedExecutionArgs);
-}
-/**
- * Implements the "CreateSourceEventStream" algorithm described in the
- * GraphQL specification, resolving the subscription source event stream.
- *
- * Returns a Promise which resolves to either an AsyncIterable (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 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 the AsyncIterable for the
- * event stream returned by the resolver.
- *
- * A Source Event Stream represents a sequence of events, each of which triggers
- * a GraphQL execution for that event.
- *
- * This may be useful when hosting the stateful subscription service in a
- * different process or machine than the stateless GraphQL execution engine,
- * or otherwise separating these two steps. For more on this, see the
- * "Supporting Subscriptions at Scale" information in the GraphQL specification.
- */
-export function createSourceEventStream(args) {
-    // If a valid execution context cannot be created due to incorrect arguments,
-    // a "Response" with only errors is returned.
-    const validatedExecutionArgs = validateExecutionArgs(args);
-    // Return early errors if execution context failed.
-    if (!('schema' in validatedExecutionArgs)) {
-        return { errors: validatedExecutionArgs };
     }
-    return createSourceEventStreamImpl(validatedExecutionArgs);
-}
-function createSourceEventStreamImpl(validatedExecutionArgs) {
-    try {
-        const eventStream = executeSubscription(validatedExecutionArgs);
-        if (isPromise(eventStream)) {
-            return eventStream.then(undefined, (error) => ({
-                errors: [error],
-            }));
-        }
-        return eventStream;
-    }
-    catch (error) {
-        return { errors: [error] };
+    const externalAbortSignal = validatedExecutionArgs.externalAbortSignal;
+    if (externalAbortSignal) {
+        const generator = mapAsyncIterable(resultOrStream, mapFn);
+        return {
+            ...generator,
+            next: () => cancellablePromise(generator.next(), externalAbortSignal),
+        };
     }
+    return mapAsyncIterable(resultOrStream, mapFn);
 }
 function executeSubscription(validatedExecutionArgs) {
-    const { schema, fragments, rootValue, contextValue, operation, variableValues, hideSuggestions, abortSignal, } = validatedExecutionArgs;
+    const { schema, fragments, rootValue, contextValue, operation, variableValues, hideSuggestions, externalAbortSignal, } = validatedExecutionArgs;
     const rootType = schema.getSubscriptionType();
     if (rootType == null) {
         throw new GraphQLError('Schema is not configured to execute subscription operation.', { nodes: operation });
@@ -1137,40 +405,39 @@ function executeSubscription(validatedExecutionArgs) {
     const { groupedFieldSet } = collectFields(schema, fragments, variableValues, rootType, operation.selectionSet, hideSuggestions);
     const firstRootField = groupedFieldSet.entries().next().value;
     const [responseName, fieldDetailsList] = firstRootField;
-    const fieldName = fieldDetailsList[0].node.name.value;
+    const firstFieldDetails = fieldDetailsList[0];
+    const firstNode = firstFieldDetails.node;
+    const fieldName = firstNode.name.value;
     const fieldDef = schema.getField(rootType, fieldName);
     const fieldNodes = fieldDetailsList.map((fieldDetails) => fieldDetails.node);
     if (!fieldDef) {
         throw new GraphQLError(`The subscription field "${fieldName}" is not defined.`, { nodes: fieldNodes });
     }
+    const sharedExecutionContext = createSharedExecutionContext(externalAbortSignal);
     const path = addPath(undefined, responseName, rootType.name);
-    const info = buildResolveInfo(validatedExecutionArgs, fieldDef, fieldNodes, rootType, path);
+    const info = buildResolveInfo(validatedExecutionArgs, fieldDef, fieldNodes, rootType, path, sharedExecutionContext.getAbortSignal, sharedExecutionContext.getAsyncHelpers);
     try {
         // Implements the "ResolveFieldEventStream" algorithm from GraphQL specification.
         // It differs from "ResolveFieldValue" due to providing a different `resolveFn`.
         // Build a JS object of arguments from the field.arguments AST, using the
         // variables scope to fulfill any variable references.
-        const args = getArgumentValues(fieldDef, fieldNodes[0], variableValues, hideSuggestions);
+        const args = getArgumentValues(fieldDef, firstNode, variableValues, firstFieldDetails.fragmentVariableValues, hideSuggestions);
         // Call the `subscribe()` resolver or the default resolver to produce an
         // AsyncIterable yielding raw payloads.
         const resolveFn = fieldDef.subscribe ?? validatedExecutionArgs.subscribeFieldResolver;
         // The resolve function's optional third argument is a context value that
         // is provided to every resolve function within an execution. It is commonly
         // used to represent an authenticated user, or request-specific caches.
-        const result = resolveFn(rootValue, args, contextValue, info, abortSignal);
-        if (isPromise(result)) {
-            const abortSignalListener = abortSignal
-                ? new AbortSignalListener(abortSignal)
-                : undefined;
-            const promise = abortSignalListener
-                ? cancellablePromise(result, abortSignalListener)
-                : result;
-            return promise.then(assertEventStream).then((resolved) => {
-                abortSignalListener?.disconnect();
-                return resolved;
-            }, (error) => {
-                abortSignalListener?.disconnect();
-                throw locatedError(error, fieldNodes, pathToArray(path));
+        const result = resolveFn(rootValue, args, contextValue, info);
+        if (isPromiseLike(result)) {
+            const promisedResult = Promise.resolve(result);
+            const promise = externalAbortSignal
+                ? cancellablePromise(promisedResult, externalAbortSignal)
+                : promisedResult;
+            return promise
+                .then(assertEventStream)
+                .then(undefined, (error) => {
+                throw locatedError(error, toNodes(fieldDetailsList), pathToArray(path));
             });
         }
         return assertEventStream(result);
@@ -1190,204 +457,31 @@ function assertEventStream(result) {
     }
     return result;
 }
-function collectExecutionGroups(exeContext, parentType, sourceValue, path, parentDeferUsages, newGroupedFieldSets, deferMap) {
-    const newPendingExecutionGroups = [];
-    for (const [deferUsageSet, groupedFieldSet] of newGroupedFieldSets) {
-        const deferredFragmentRecords = getDeferredFragmentRecords(deferUsageSet, deferMap);
-        const pendingExecutionGroup = {
-            deferredFragmentRecords,
-            result: undefined,
-        };
-        const executor = () => executeExecutionGroup(pendingExecutionGroup, exeContext, parentType, sourceValue, path, groupedFieldSet, {
-            errors: undefined,
-            completed: false,
-            deferUsageSet,
-        }, deferMap);
-        if (exeContext.validatedExecutionArgs.enableEarlyExecution) {
-            pendingExecutionGroup.result = new BoxedPromiseOrValue(shouldDefer(parentDeferUsages, deferUsageSet)
-                ? Promise.resolve().then(executor)
-                : executor());
-        }
-        else {
-            pendingExecutionGroup.result = () => new BoxedPromiseOrValue(executor());
-        }
-        newPendingExecutionGroups.push(pendingExecutionGroup);
-    }
-    return newPendingExecutionGroups;
-}
-function shouldDefer(parentDeferUsages, deferUsages) {
-    // If we have a new child defer usage, defer.
-    // Otherwise, this defer usage was already deferred when it was initially
-    // encountered, and is now in the midst of executing early, so the new
-    // deferred grouped fields set can be executed immediately.
-    return (parentDeferUsages === undefined ||
-        !Array.from(deferUsages).every((deferUsage) => parentDeferUsages.has(deferUsage)));
-}
-function executeExecutionGroup(pendingExecutionGroup, exeContext, parentType, sourceValue, path, groupedFieldSet, incrementalContext, deferMap) {
-    let result;
-    try {
-        result = executeFields(exeContext, parentType, sourceValue, path, groupedFieldSet, incrementalContext, deferMap);
-    }
-    catch (error) {
-        incrementalContext.completed = true;
-        return {
-            pendingExecutionGroup,
-            path: pathToArray(path),
-            errors: withError(incrementalContext.errors, error),
-        };
-    }
-    if (isPromise(result)) {
-        return result.then((resolved) => {
-            incrementalContext.completed = true;
-            return buildCompletedExecutionGroup(incrementalContext.errors, pendingExecutionGroup, path, resolved);
-        }, (error) => {
-            incrementalContext.completed = true;
-            return {
-                pendingExecutionGroup,
-                path: pathToArray(path),
-                errors: withError(incrementalContext.errors, error),
-            };
-        });
-    }
-    incrementalContext.completed = true;
-    return buildCompletedExecutionGroup(incrementalContext.errors, pendingExecutionGroup, path, result);
-}
-function buildCompletedExecutionGroup(errors, pendingExecutionGroup, path, result) {
-    const { rawResult: data, incrementalDataRecords } = result;
+/**
+ * TODO: consider no longer exporting this function
+ * @internal
+ */
+// eslint-disable-next-line max-params
+export function buildResolveInfo(validatedExecutionArgs, fieldDef, fieldNodes, parentType, path, getAbortSignal, getAsyncHelpers) {
+    const { schema, fragmentDefinitions, rootValue, operation, variableValues } = validatedExecutionArgs;
+    // The resolve function's optional fourth argument is a collection of
+    // information about the current execution state.
     return {
-        pendingExecutionGroup,
-        path: pathToArray(path),
-        result: errors === undefined ? { data } : { data, errors },
-        incrementalDataRecords,
-    };
-}
-function getDeferredFragmentRecords(deferUsages, deferMap) {
-    return Array.from(deferUsages).map((deferUsage) => deferredFragmentRecordFromDeferUsage(deferUsage, deferMap));
-}
-function buildSyncStreamItemQueue(initialItem, initialIndex, streamPath, iterator, exeContext, fieldDetailsList, info, itemType) {
-    const streamItemQueue = [];
-    const enableEarlyExecution = exeContext.validatedExecutionArgs.enableEarlyExecution;
-    const firstExecutor = () => {
-        const initialPath = addPath(streamPath, initialIndex, undefined);
-        const firstStreamItem = new BoxedPromiseOrValue(completeStreamItem(initialPath, initialItem, exeContext, { errors: undefined, completed: false }, fieldDetailsList, info, itemType));
-        let iteration = iterator.next();
-        let currentIndex = initialIndex + 1;
-        let currentStreamItem = firstStreamItem;
-        while (!iteration.done) {
-            // TODO: add test case for early sync termination
-            /* c8 ignore next 6 */
-            if (currentStreamItem instanceof BoxedPromiseOrValue) {
-                const result = currentStreamItem.value;
-                if (!isPromise(result) && result.errors !== undefined) {
-                    break;
-                }
-            }
-            const itemPath = addPath(streamPath, currentIndex, undefined);
-            const value = iteration.value;
-            const currentExecutor = () => completeStreamItem(itemPath, value, exeContext, { errors: undefined, completed: false }, fieldDetailsList, info, itemType);
-            currentStreamItem = enableEarlyExecution
-                ? new BoxedPromiseOrValue(currentExecutor())
-                : () => new BoxedPromiseOrValue(currentExecutor());
-            streamItemQueue.push(currentStreamItem);
-            iteration = iterator.next();
-            currentIndex = initialIndex + 1;
-        }
-        streamItemQueue.push(new BoxedPromiseOrValue({}));
-        return firstStreamItem.value;
+        fieldName: fieldDef.name,
+        fieldNodes,
+        returnType: fieldDef.type,
+        parentType,
+        path,
+        schema,
+        fragments: fragmentDefinitions,
+        rootValue,
+        operation,
+        variableValues,
+        getAbortSignal,
+        getAsyncHelpers,
     };
-    streamItemQueue.push(enableEarlyExecution
-        ? new BoxedPromiseOrValue(Promise.resolve().then(firstExecutor))
-        : () => new BoxedPromiseOrValue(firstExecutor()));
-    return streamItemQueue;
 }
-function buildAsyncStreamItemQueue(initialIndex, streamPath, asyncIterator, exeContext, fieldDetailsList, info, itemType) {
-    const streamItemQueue = [];
-    const executor = () => getNextAsyncStreamItemResult(streamItemQueue, streamPath, initialIndex, asyncIterator, exeContext, fieldDetailsList, info, itemType);
-    streamItemQueue.push(exeContext.validatedExecutionArgs.enableEarlyExecution
-        ? new BoxedPromiseOrValue(executor())
-        : () => new BoxedPromiseOrValue(executor()));
-    return streamItemQueue;
-}
-async function getNextAsyncStreamItemResult(streamItemQueue, streamPath, index, asyncIterator, exeContext, fieldDetailsList, info, itemType) {
-    let iteration;
-    try {
-        iteration = await asyncIterator.next();
-    }
-    catch (error) {
-        return {
-            errors: [
-                locatedError(error, toNodes(fieldDetailsList), pathToArray(streamPath)),
-            ],
-        };
-    }
-    if (iteration.done) {
-        return {};
-    }
-    const itemPath = addPath(streamPath, index, undefined);
-    const result = completeStreamItem(itemPath, iteration.value, exeContext, { errors: undefined, completed: false }, fieldDetailsList, info, itemType);
-    const executor = () => getNextAsyncStreamItemResult(streamItemQueue, streamPath, index + 1, asyncIterator, exeContext, fieldDetailsList, info, itemType);
-    streamItemQueue.push(exeContext.validatedExecutionArgs.enableEarlyExecution
-        ? new BoxedPromiseOrValue(executor())
-        : () => new BoxedPromiseOrValue(executor()));
-    return result;
-}
-function completeStreamItem(itemPath, item, exeContext, incrementalContext, fieldDetailsList, info, itemType) {
-    if (isPromise(item)) {
-        const abortSignalListener = exeContext.abortSignalListener;
-        const maybeCancellableItem = abortSignalListener
-            ? cancellablePromise(item, abortSignalListener)
-            : item;
-        return completePromisedValue(exeContext, itemType, fieldDetailsList, info, itemPath, maybeCancellableItem, incrementalContext, new Map()).then((resolvedItem) => {
-            incrementalContext.completed = true;
-            return buildStreamItemResult(incrementalContext.errors, resolvedItem);
-        }, (error) => {
-            incrementalContext.completed = true;
-            return {
-                errors: withError(incrementalContext.errors, error),
-            };
-        });
-    }
-    let result;
-    try {
-        try {
-            result = completeValue(exeContext, itemType, fieldDetailsList, info, itemPath, item, incrementalContext, new Map());
-        }
-        catch (rawError) {
-            handleFieldError(rawError, exeContext, itemType, fieldDetailsList, itemPath, incrementalContext);
-            result = { rawResult: null, incrementalDataRecords: undefined };
-        }
-    }
-    catch (error) {
-        incrementalContext.completed = true;
-        return {
-            errors: withError(incrementalContext.errors, error),
-        };
-    }
-    if (isPromise(result)) {
-        return result
-            .then(undefined, (rawError) => {
-            handleFieldError(rawError, exeContext, itemType, fieldDetailsList, itemPath, incrementalContext);
-            return { rawResult: null, incrementalDataRecords: undefined };
-        })
-            .then((resolvedItem) => {
-            incrementalContext.completed = true;
-            return buildStreamItemResult(incrementalContext.errors, resolvedItem);
-        }, (error) => {
-            incrementalContext.completed = true;
-            return {
-                errors: withError(incrementalContext.errors, error),
-            };
-        });
-    }
-    incrementalContext.completed = true;
-    return buildStreamItemResult(incrementalContext.errors, result);
-}
-function buildStreamItemResult(errors, result) {
-    const { rawResult: item, incrementalDataRecords } = result;
-    return {
-        item,
-        errors,
-        incrementalDataRecords,
-    };
+function toNodes(fieldDetailsList) {
+    return fieldDetailsList.map((fieldDetails) => fieldDetails.node);
 }
 //# sourceMappingURL=execute.js.map