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

package/execution/Executor.js

@@ -0,0 +1,655 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Executor = exports.getStreamUsage = exports.collectSubfields = void 0;
+const inspect_js_1 = require("../jsutils/inspect.js");
+const invariant_js_1 = require("../jsutils/invariant.js");
+const isAsyncIterable_js_1 = require("../jsutils/isAsyncIterable.js");
+const isIterableObject_js_1 = require("../jsutils/isIterableObject.js");
+const isPromise_js_1 = require("../jsutils/isPromise.js");
+const memoize2_js_1 = require("../jsutils/memoize2.js");
+const memoize3_js_1 = require("../jsutils/memoize3.js");
+const Path_js_1 = require("../jsutils/Path.js");
+const promiseForObject_js_1 = require("../jsutils/promiseForObject.js");
+const promiseReduce_js_1 = require("../jsutils/promiseReduce.js");
+const ensureGraphQLError_js_1 = require("../error/ensureGraphQLError.js");
+const GraphQLError_js_1 = require("../error/GraphQLError.js");
+const locatedError_js_1 = require("../error/locatedError.js");
+const ast_js_1 = require("../language/ast.js");
+const definition_js_1 = require("../type/definition.js");
+const AbortedGraphQLExecutionError_js_1 = require("./AbortedGraphQLExecutionError.js");
+const cancellablePromise_js_1 = require("./cancellablePromise.js");
+const collectFields_js_1 = require("./collectFields.js");
+const collectIteratorPromises_js_1 = require("./collectIteratorPromises.js");
+const createSharedExecutionContext_js_1 = require("./createSharedExecutionContext.js");
+const execute_js_1 = require("./execute.js");
+const getStreamUsage_js_1 = require("./getStreamUsage.js");
+const hooks_js_1 = require("./hooks.js");
+const returnIteratorCatchingErrors_js_1 = require("./returnIteratorCatchingErrors.js");
+const values_js_1 = require("./values.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.
+ */
+exports.collectSubfields = (0, memoize3_js_1.memoize3)((validatedExecutionArgs, returnType, fieldDetailsList) => {
+    const { schema, fragments, variableValues, hideSuggestions } = validatedExecutionArgs;
+    return (0, collectFields_js_1.collectSubfields)(schema, fragments, variableValues, returnType, fieldDetailsList, hideSuggestions);
+});
+exports.getStreamUsage = (0, memoize2_js_1.memoize2)((validatedExecutionArgs, fieldDetailsList) => (0, getStreamUsage_js_1.getStreamUsage)(validatedExecutionArgs, fieldDetailsList));
+/**
+ * @internal
+ */
+class CollectedErrors {
+    constructor() {
+        this._errorPositions = new Set();
+        this._errors = [];
+    }
+    get errors() {
+        return this._errors;
+    }
+    add(error, path) {
+        // Do not modify errors list if the execution position for this error or
+        // any of its ancestors has already been nulled via error propagation.
+        // This check should be unnecessary for implementations able to implement
+        // actual cancellation.
+        if (this.hasNulledPosition(path)) {
+            return;
+        }
+        this._errorPositions.add(path);
+        this._errors.push(error);
+    }
+    hasNulledPosition(startPath) {
+        let path = startPath;
+        while (path !== undefined) {
+            if (this._errorPositions.has(path)) {
+                return true;
+            }
+            path = path.prev;
+        }
+        return this._errorPositions.has(undefined);
+    }
+}
+const defaultAbortReason = new Error('This operation was aborted');
+/** @internal */
+class Executor {
+    constructor(validatedExecutionArgs, sharedExecutionContext) {
+        this.validatedExecutionArgs = validatedExecutionArgs;
+        this.aborted = false;
+        this.abortReason = defaultAbortReason;
+        this.collectedErrors = new CollectedErrors();
+        if (sharedExecutionContext === undefined) {
+            this.resolverAbortController = new AbortController();
+            this.sharedExecutionContext = (0, createSharedExecutionContext_js_1.createSharedExecutionContext)(this.resolverAbortController.signal);
+        }
+        else {
+            this.sharedExecutionContext = sharedExecutionContext;
+        }
+        const { getAbortSignal, getAsyncHelpers, promiseAll } = this.sharedExecutionContext;
+        this.getAbortSignal = getAbortSignal;
+        this.getAsyncHelpers = getAsyncHelpers;
+        this.promiseAll = promiseAll;
+    }
+    executeRootSelectionSet(serially) {
+        const externalAbortSignal = this.validatedExecutionArgs.externalAbortSignal;
+        let removeExternalAbortListener;
+        if (externalAbortSignal) {
+            externalAbortSignal.throwIfAborted();
+            const onExternalAbort = () => {
+                this.abort(externalAbortSignal.reason);
+            };
+            removeExternalAbortListener = () => externalAbortSignal.removeEventListener('abort', onExternalAbort);
+            externalAbortSignal.addEventListener('abort', onExternalAbort);
+        }
+        const maybeRemoveExternalAbortListener = () => {
+            removeExternalAbortListener?.();
+        };
+        let result;
+        try {
+            const { schema, fragments, rootValue, operation, variableValues, hideSuggestions, } = this.validatedExecutionArgs;
+            const { operation: operationType, selectionSet } = operation;
+            const rootType = schema.getRootType(operationType);
+            if (rootType == null) {
+                throw new GraphQLError_js_1.GraphQLError(`Schema is not configured to execute ${operationType} operation.`, { nodes: operation });
+            }
+            const { groupedFieldSet, newDeferUsages } = (0, collectFields_js_1.collectFields)(schema, fragments, variableValues, rootType, selectionSet, hideSuggestions);
+            result = this.executeCollectedRootFields(rootType, rootValue, groupedFieldSet, serially ?? operationType === ast_js_1.OperationTypeNode.MUTATION, newDeferUsages);
+            if ((0, isPromise_js_1.isPromise)(result)) {
+                const promise = result.then((data) => {
+                    maybeRemoveExternalAbortListener();
+                    return this.buildResponse(data);
+                }, (error) => {
+                    maybeRemoveExternalAbortListener();
+                    this.collectedErrors.add((0, ensureGraphQLError_js_1.ensureGraphQLError)(error), undefined);
+                    return this.buildResponse(null);
+                });
+                this.sharedExecutionContext.asyncWorkTracker.add(promise);
+                const { promise: cancellablePromise, abort: abortResultPromise } = (0, cancellablePromise_js_1.withCancellation)(promise.then((resolved) => this.finish(resolved)));
+                this.abortResultPromise = () => {
+                    abortResultPromise(this.createAbortedExecutionError(promise));
+                };
+                if (this.aborted) {
+                    this.abortResultPromise();
+                }
+                return cancellablePromise;
+            }
+            maybeRemoveExternalAbortListener();
+        }
+        catch (error) {
+            maybeRemoveExternalAbortListener();
+            this.collectedErrors.add((0, ensureGraphQLError_js_1.ensureGraphQLError)(error), undefined);
+            return this.finish(this.buildResponse(null));
+        }
+        return this.finish(this.buildResponse(result));
+    }
+    abort(reason) {
+        if (this.aborted) {
+            return;
+        }
+        this.aborted = true;
+        if (reason !== undefined) {
+            this.abortReason = reason;
+        }
+        this.abortResultPromise?.();
+        this.resolverAbortController?.abort(this.abortReason);
+    }
+    finish(result) {
+        if (this.aborted) {
+            throw this.createAbortedExecutionError(result);
+        }
+        this.aborted = true;
+        return result;
+    }
+    createAbortedExecutionError(result) {
+        return new AbortedGraphQLExecutionError_js_1.AbortedGraphQLExecutionError(this.abortReason, result);
+    }
+    getFinishSharedExecution() {
+        const resolverAbortController = this.resolverAbortController;
+        const asyncWorkFinishedHook = this.validatedExecutionArgs.hooks?.asyncWorkFinished;
+        if (asyncWorkFinishedHook === undefined) {
+            return () => resolverAbortController?.abort();
+        }
+        const validatedExecutionArgs = this.validatedExecutionArgs;
+        const sharedExecutionContext = this.sharedExecutionContext;
+        return () => {
+            resolverAbortController?.abort();
+            (0, hooks_js_1.runAsyncWorkFinishedHook)(validatedExecutionArgs, sharedExecutionContext, asyncWorkFinishedHook);
+        };
+    }
+    /**
+     * Given a completed execution context and data, build the `{ errors, data }`
+     * response defined by the "Response" section of the GraphQL specification.
+     */
+    buildResponse(data) {
+        this.getFinishSharedExecution()();
+        const errors = this.collectedErrors.errors;
+        return errors.length ? { errors, data } : { data };
+    }
+    executeCollectedRootFields(rootType, rootValue, originalGroupedFieldSet, serially, _newDeferUsages) {
+        return this.executeRootGroupedFieldSet(rootType, rootValue, originalGroupedFieldSet, serially, undefined);
+    }
+    executeRootGroupedFieldSet(rootType, rootValue, groupedFieldSet, serially, positionContext) {
+        return serially
+            ? this.executeFieldsSerially(rootType, rootValue, undefined, groupedFieldSet, positionContext)
+            : this.executeFields(rootType, rootValue, undefined, groupedFieldSet, positionContext);
+    }
+    /**
+     * Implements the "Executing selection sets" section of the spec
+     * for fields that must be executed serially.
+     */
+    executeFieldsSerially(parentType, sourceValue, path, groupedFieldSet, positionContext) {
+        return (0, promiseReduce_js_1.promiseReduce)(groupedFieldSet, (results, [responseName, fieldDetailsList]) => {
+            if (this.aborted) {
+                throw new Error('Aborted!');
+            }
+            const fieldPath = (0, Path_js_1.addPath)(path, responseName, parentType.name);
+            const result = this.executeField(parentType, sourceValue, fieldDetailsList, fieldPath, positionContext);
+            if (result === undefined) {
+                return results;
+            }
+            if ((0, isPromise_js_1.isPromise)(result)) {
+                return result.then((resolved) => {
+                    results[responseName] = resolved;
+                    return results;
+                });
+            }
+            results[responseName] = result;
+            return results;
+        }, Object.create(null));
+    }
+    /**
+     * Implements the "Executing selection sets" section of the spec
+     * for fields that may be executed in parallel.
+     */
+    executeFields(parentType, sourceValue, path, groupedFieldSet, positionContext) {
+        const results = Object.create(null);
+        let containsPromise = false;
+        try {
+            for (const [responseName, fieldDetailsList] of groupedFieldSet) {
+                const fieldPath = (0, Path_js_1.addPath)(path, responseName, parentType.name);
+                const result = this.executeField(parentType, sourceValue, fieldDetailsList, fieldPath, positionContext);
+                if (result !== undefined) {
+                    results[responseName] = result;
+                    if ((0, isPromise_js_1.isPromise)(result)) {
+                        containsPromise = true;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (containsPromise) {
+                this.sharedExecutionContext.asyncWorkTracker.addValues(Object.values(results));
+            }
+            throw error;
+        }
+        // If there are no promises, we can just return the object and any incrementalDataRecords
+        if (!containsPromise) {
+            return results;
+        }
+        // Otherwise, results is a map from field name to the result of resolving that
+        // field, which is possibly a promise. Return a promise that will return this
+        // same map, but with any promises replaced with the values they resolved to.
+        return (0, promiseForObject_js_1.promiseForObject)(results, this.promiseAll);
+    }
+    /**
+     * 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.
+     */
+    executeField(parentType, source, fieldDetailsList, path, positionContext) {
+        const validatedExecutionArgs = this.validatedExecutionArgs;
+        const { schema, contextValue, variableValues, hideSuggestions } = validatedExecutionArgs;
+        const firstFieldDetails = fieldDetailsList[0];
+        const firstNode = firstFieldDetails.node;
+        const fieldName = firstNode.name.value;
+        const fieldDef = schema.getField(parentType, fieldName);
+        if (!fieldDef) {
+            return;
+        }
+        const returnType = fieldDef.type;
+        const resolveFn = fieldDef.resolve ?? validatedExecutionArgs.fieldResolver;
+        const info = (0, execute_js_1.buildResolveInfo)(validatedExecutionArgs, fieldDef, toNodes(fieldDetailsList), parentType, path, this.getAbortSignal, this.getAsyncHelpers);
+        // 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 = (0, values_js_1.getArgumentValues)(fieldDef, firstNode, variableValues, firstFieldDetails.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);
+            if ((0, isPromise_js_1.isPromiseLike)(result)) {
+                return this.completePromisedValue(returnType, fieldDetailsList, info, path, result, positionContext);
+            }
+            const completed = this.completeValue(returnType, fieldDetailsList, info, path, result, positionContext);
+            if ((0, isPromise_js_1.isPromise)(completed)) {
+                // Note: we don't rely on a `catch` method, but we do expect "thenable"
+                // to take a second callback for the error case.
+                return completed.then(undefined, (rawError) => {
+                    this.handleFieldError(rawError, returnType, fieldDetailsList, path);
+                    return null;
+                });
+            }
+            return completed;
+        }
+        catch (rawError) {
+            this.handleFieldError(rawError, returnType, fieldDetailsList, path);
+            return null;
+        }
+    }
+    handleFieldError(rawError, returnType, fieldDetailsList, path) {
+        const error = (0, locatedError_js_1.locatedError)(rawError, toNodes(fieldDetailsList), (0, Path_js_1.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 (this.validatedExecutionArgs.errorPropagation &&
+            (0, definition_js_1.isNonNullType)(returnType)) {
+            throw error;
+        }
+        // Otherwise, error protection is applied, logging the error and resolving
+        // a null value for this field if one is encountered.
+        this.collectedErrors.add(error, path);
+    }
+    /**
+     * 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.
+     */
+    completeValue(returnType, fieldDetailsList, info, path, result, positionContext) {
+        // 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 ((0, definition_js_1.isNonNullType)(returnType)) {
+            const completed = this.completeValue(returnType.ofType, fieldDetailsList, info, path, result, positionContext);
+            if (completed === 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 null;
+        }
+        // If field type is List, complete each item in the list with the inner type
+        if ((0, definition_js_1.isListType)(returnType)) {
+            return this.completeListValue(returnType, fieldDetailsList, info, path, result, positionContext);
+        }
+        // If field type is a leaf type, Scalar or Enum, coerce to a valid value,
+        // returning null if coercion is not possible.
+        if ((0, definition_js_1.isLeafType)(returnType)) {
+            return this.completeLeafValue(returnType, result);
+        }
+        // If field type is an abstract type, Interface or Union, determine the
+        // runtime Object type and complete for that type.
+        if ((0, definition_js_1.isAbstractType)(returnType)) {
+            return this.completeAbstractValue(returnType, fieldDetailsList, info, path, result, positionContext);
+        }
+        // If field type is Object, execute and complete all sub-selections.
+        if ((0, definition_js_1.isObjectType)(returnType)) {
+            return this.completeObjectValue(returnType, fieldDetailsList, info, path, result, positionContext);
+            // c8 control statement technically placed a line early secondary to
+            // slight swc source mapping error (at least as compared to ts-node without swc)
+            /* c8 ignore next 7 */
+        }
+        // Not reachable, all possible output types have been considered.
+        (0, invariant_js_1.invariant)(false, 'Cannot complete value of unexpected output type: ' + (0, inspect_js_1.inspect)(returnType));
+    }
+    async completePromisedValue(returnType, fieldDetailsList, info, path, result, positionContext) {
+        try {
+            const resolved = await result;
+            if (this.aborted) {
+                throw new Error('Aborted!');
+            }
+            let completed = this.completeValue(returnType, fieldDetailsList, info, path, resolved, positionContext);
+            if ((0, isPromise_js_1.isPromise)(completed)) {
+                completed = await completed;
+            }
+            return completed;
+        }
+        catch (rawError) {
+            this.handleFieldError(rawError, returnType, fieldDetailsList, path);
+            return null;
+        }
+    }
+    /**
+     * Complete a async iterator value by completing the result and calling
+     * recursively until all the results are completed.
+     */
+    async completeAsyncIterableValue(itemType, fieldDetailsList, info, path, items, positionContext) {
+        // do not stream inner lists of multi-dimensional lists
+        const streamUsage = typeof path.key === 'number'
+            ? undefined
+            : (0, exports.getStreamUsage)(this.validatedExecutionArgs, fieldDetailsList);
+        let containsPromise = false;
+        const completedResults = [];
+        const asyncIterator = items[Symbol.asyncIterator]();
+        let index = 0;
+        let iteration;
+        try {
+            while (true) {
+                if (streamUsage?.initialCount === index &&
+                    this.handleStream(index, path, { handle: asyncIterator, isAsync: true }, streamUsage, info, itemType)) {
+                    break;
+                }
+                const itemPath = (0, Path_js_1.addPath)(path, index, undefined);
+                try {
+                    // eslint-disable-next-line no-await-in-loop
+                    iteration = await asyncIterator.next();
+                }
+                catch (rawError) {
+                    throw (0, locatedError_js_1.locatedError)(rawError, toNodes(fieldDetailsList), (0, Path_js_1.pathToArray)(path));
+                }
+                if (this.aborted || iteration.done) {
+                    break;
+                }
+                const item = iteration.value;
+                if (this.completeMaybePromisedListItemValue(item, completedResults, itemType, fieldDetailsList, info, itemPath, positionContext)) {
+                    containsPromise = true;
+                }
+                index++;
+            }
+        }
+        catch (error) {
+            this.sharedExecutionContext.asyncWorkTracker.add((0, returnIteratorCatchingErrors_js_1.returnIteratorCatchingErrors)(asyncIterator));
+            if (containsPromise) {
+                this.sharedExecutionContext.asyncWorkTracker.addValues(completedResults);
+            }
+            throw error;
+        }
+        // Throwing on completion outside of the loop may allow engines to better optimize
+        if (this.aborted) {
+            if (!iteration?.done) {
+                this.sharedExecutionContext.asyncWorkTracker.add((0, returnIteratorCatchingErrors_js_1.returnIteratorCatchingErrors)(asyncIterator));
+            }
+            throw new Error('Aborted!');
+        }
+        return containsPromise
+            ? this.promiseAll(completedResults)
+            : completedResults;
+    }
+    /* c8 ignore next 12 */
+    handleStream(_index, _path, _iterator, _streamUsage, _info, _itemType) {
+        return false;
+    }
+    /**
+     * Complete a list value by completing each item in the list with the
+     * inner type
+     */
+    completeListValue(returnType, fieldDetailsList, info, path, result, positionContext) {
+        const itemType = returnType.ofType;
+        if ((0, isAsyncIterable_js_1.isAsyncIterable)(result)) {
+            return this.completeAsyncIterableValue(itemType, fieldDetailsList, info, path, result, positionContext);
+        }
+        if (!(0, isIterableObject_js_1.isIterableObject)(result)) {
+            throw new GraphQLError_js_1.GraphQLError(`Expected Iterable, but did not find one for field "${info.parentType}.${info.fieldName}".`);
+        }
+        return this.completeIterableValue(itemType, fieldDetailsList, info, path, result, positionContext);
+    }
+    completeIterableValue(itemType, fieldDetailsList, info, path, items, positionContext) {
+        // do not stream inner lists of multi-dimensional lists
+        const streamUsage = typeof path.key === 'number'
+            ? undefined
+            : (0, exports.getStreamUsage)(this.validatedExecutionArgs, fieldDetailsList);
+        // 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 = [];
+        let index = 0;
+        const iterator = items[Symbol.iterator]();
+        try {
+            while (true) {
+                if (streamUsage?.initialCount === index &&
+                    this.handleStream(index, path, { handle: iterator }, streamUsage, info, itemType)) {
+                    break;
+                }
+                const iteration = iterator.next();
+                if (iteration.done) {
+                    break;
+                }
+                const item = iteration.value;
+                // No need to modify the info object containing the path,
+                // since from here on it is not ever accessed by resolver functions.
+                const itemPath = (0, Path_js_1.addPath)(path, index, undefined);
+                if (this.completeMaybePromisedListItemValue(item, completedResults, itemType, fieldDetailsList, info, itemPath, positionContext)) {
+                    containsPromise = true;
+                }
+                index++;
+            }
+        }
+        catch (error) {
+            const asyncWorkTracker = this.sharedExecutionContext.asyncWorkTracker;
+            if (containsPromise) {
+                asyncWorkTracker.addValues(completedResults);
+            }
+            asyncWorkTracker.addValues((0, collectIteratorPromises_js_1.collectIteratorPromises)(iterator));
+            throw error;
+        }
+        return containsPromise
+            ? this.promiseAll(completedResults)
+            : completedResults;
+    }
+    completeMaybePromisedListItemValue(item, completedResults, itemType, fieldDetailsList, info, itemPath, positionContext) {
+        if ((0, isPromise_js_1.isPromiseLike)(item)) {
+            completedResults.push(this.completePromisedListItemValue(item, itemType, fieldDetailsList, info, itemPath, positionContext));
+            return true;
+        }
+        else if (this.completeListItemValue(item, completedResults, itemType, fieldDetailsList, info, itemPath, positionContext)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Complete a list item value by adding it to the completed results.
+     *
+     * Returns true if the value is a Promise.
+     */
+    completeListItemValue(item, completedResults, itemType, fieldDetailsList, info, itemPath, positionContext) {
+        try {
+            const completedItem = this.completeValue(itemType, fieldDetailsList, info, itemPath, item, positionContext);
+            if ((0, isPromise_js_1.isPromise)(completedItem)) {
+                // Note: we don't rely on a `catch` method, but we do expect "thenable"
+                // to take a second callback for the error case.
+                completedResults.push(completedItem.then(undefined, (rawError) => {
+                    this.handleFieldError(rawError, itemType, fieldDetailsList, itemPath);
+                    return null;
+                }));
+                return true;
+            }
+            completedResults.push(completedItem);
+        }
+        catch (rawError) {
+            this.handleFieldError(rawError, itemType, fieldDetailsList, itemPath);
+            completedResults.push(null);
+        }
+        return false;
+    }
+    async completePromisedListItemValue(item, itemType, fieldDetailsList, info, itemPath, positionContext) {
+        try {
+            const resolved = await item;
+            if (this.aborted) {
+                throw new Error('Aborted!');
+            }
+            let completed = this.completeValue(itemType, fieldDetailsList, info, itemPath, resolved, positionContext);
+            if ((0, isPromise_js_1.isPromise)(completed)) {
+                completed = await completed;
+            }
+            return completed;
+        }
+        catch (rawError) {
+            this.handleFieldError(rawError, itemType, fieldDetailsList, itemPath);
+            return null;
+        }
+    }
+    /**
+     * Complete a Scalar or Enum by serializing to a valid value, returning
+     * null if serialization is not possible.
+     */
+    completeLeafValue(returnType, result) {
+        const coerced = returnType.coerceOutputValue(result);
+        if (coerced == null) {
+            throw new Error(`Expected \`${(0, inspect_js_1.inspect)(returnType)}.coerceOutputValue(${(0, inspect_js_1.inspect)(result)})\` to ` +
+                `return non-nullable value, returned: ${(0, inspect_js_1.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.
+     */
+    completeAbstractValue(returnType, fieldDetailsList, info, path, result, positionContext) {
+        const validatedExecutionArgs = this.validatedExecutionArgs;
+        const { schema, contextValue } = validatedExecutionArgs;
+        const resolveTypeFn = returnType.resolveType ?? validatedExecutionArgs.typeResolver;
+        const runtimeType = resolveTypeFn(result, contextValue, info, returnType);
+        if ((0, isPromise_js_1.isPromiseLike)(runtimeType)) {
+            return Promise.resolve(runtimeType).then((resolvedRuntimeType) => {
+                if (this.aborted) {
+                    throw new Error('Aborted!');
+                }
+                return this.completeObjectValue(this.ensureValidRuntimeType(resolvedRuntimeType, schema, returnType, fieldDetailsList, info, result), fieldDetailsList, info, path, result, positionContext);
+            });
+        }
+        return this.completeObjectValue(this.ensureValidRuntimeType(runtimeType, schema, returnType, fieldDetailsList, info, result), fieldDetailsList, info, path, result, positionContext);
+    }
+    ensureValidRuntimeType(runtimeTypeName, schema, returnType, fieldDetailsList, info, result) {
+        if (runtimeTypeName == null) {
+            throw new GraphQLError_js_1.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_js_1.GraphQLError(`Abstract type "${returnType}" must resolve to an Object type at runtime for field "${info.parentType}.${info.fieldName}" with ` +
+                `value ${(0, inspect_js_1.inspect)(result)}, received "${(0, inspect_js_1.inspect)(runtimeTypeName)}", which is not a valid Object type name.`);
+        }
+        const runtimeType = schema.getType(runtimeTypeName);
+        if (runtimeType == null) {
+            throw new GraphQLError_js_1.GraphQLError(`Abstract type "${returnType}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`, { nodes: toNodes(fieldDetailsList) });
+        }
+        if (!(0, definition_js_1.isObjectType)(runtimeType)) {
+            throw new GraphQLError_js_1.GraphQLError(`Abstract type "${returnType}" was resolved to a non-object type "${runtimeTypeName}".`, { nodes: toNodes(fieldDetailsList) });
+        }
+        if (!schema.isSubType(returnType, runtimeType)) {
+            throw new GraphQLError_js_1.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.
+     */
+    completeObjectValue(returnType, fieldDetailsList, info, path, result, positionContext) {
+        // 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, this.validatedExecutionArgs.contextValue, info);
+            if ((0, isPromise_js_1.isPromiseLike)(isTypeOf)) {
+                return Promise.resolve(isTypeOf).then((resolvedIsTypeOf) => {
+                    if (this.aborted) {
+                        throw new Error('Aborted!');
+                    }
+                    if (!resolvedIsTypeOf) {
+                        throw this.invalidReturnTypeError(returnType, result, fieldDetailsList);
+                    }
+                    return this.collectAndExecuteSubfields(returnType, fieldDetailsList, path, result, positionContext);
+                });
+            }
+            if (!isTypeOf) {
+                throw this.invalidReturnTypeError(returnType, result, fieldDetailsList);
+            }
+        }
+        return this.collectAndExecuteSubfields(returnType, fieldDetailsList, path, result, positionContext);
+    }
+    invalidReturnTypeError(returnType, result, fieldDetailsList) {
+        return new GraphQLError_js_1.GraphQLError(`Expected value of type "${returnType}" but got: ${(0, inspect_js_1.inspect)(result)}.`, { nodes: toNodes(fieldDetailsList) });
+    }
+    collectAndExecuteSubfields(returnType, fieldDetailsList, path, result, positionContext) {
+        // Collect sub-fields to execute to complete this value.
+        const { groupedFieldSet, newDeferUsages } = (0, exports.collectSubfields)(this.validatedExecutionArgs, returnType, fieldDetailsList);
+        return this.executeCollectedSubfields(returnType, result, path, groupedFieldSet, newDeferUsages, positionContext);
+    }
+    executeCollectedSubfields(parentType, sourceValue, path, originalGroupedFieldSet, _newDeferUsages, _positionContext) {
+        return this.executeFields(parentType, sourceValue, path, originalGroupedFieldSet, undefined);
+    }
+}
+exports.Executor = Executor;
+function toNodes(fieldDetailsList) {
+    return fieldDetailsList.map((fieldDetails) => fieldDetails.node);
+}
+//# sourceMappingURL=Executor.js.map