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

package/execution/Executor.mjs

@@ -0,0 +1,651 @@
+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 { isPromise, isPromiseLike } from "../jsutils/isPromise.mjs";
+import { memoize2 } from "../jsutils/memoize2.mjs";
+import { memoize3 } from "../jsutils/memoize3.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 { isAbstractType, isLeafType, isListType, isNonNullType, isObjectType, } from "../type/definition.mjs";
+import { AbortedGraphQLExecutionError } from "./AbortedGraphQLExecutionError.mjs";
+import { withCancellation } from "./cancellablePromise.mjs";
+import { collectFields, collectSubfields as _collectSubfields, } from "./collectFields.mjs";
+import { collectIteratorPromises } from "./collectIteratorPromises.mjs";
+import { createSharedExecutionContext } from "./createSharedExecutionContext.mjs";
+import { buildResolveInfo } from "./execute.mjs";
+import { getStreamUsage as _getStreamUsage } from "./getStreamUsage.mjs";
+import { runAsyncWorkFinishedHook } from "./hooks.mjs";
+import { returnIteratorCatchingErrors } from "./returnIteratorCatchingErrors.mjs";
+import { getArgumentValues } from "./values.mjs";
+/**
+ * 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.
+ */
+export const collectSubfields = memoize3((validatedExecutionArgs, returnType, fieldDetailsList) => {
+    const { schema, fragments, variableValues, hideSuggestions } = validatedExecutionArgs;
+    return _collectSubfields(schema, fragments, variableValues, returnType, fieldDetailsList, hideSuggestions);
+});
+export const getStreamUsage = memoize2((validatedExecutionArgs, fieldDetailsList) => _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 */
+export 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 = 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(`Schema is not configured to execute ${operationType} operation.`, { nodes: operation });
+            }
+            const { groupedFieldSet, newDeferUsages } = collectFields(schema, fragments, variableValues, rootType, selectionSet, hideSuggestions);
+            result = this.executeCollectedRootFields(rootType, rootValue, groupedFieldSet, serially ?? operationType === OperationTypeNode.MUTATION, newDeferUsages);
+            if (isPromise(result)) {
+                const promise = result.then((data) => {
+                    maybeRemoveExternalAbortListener();
+                    return this.buildResponse(data);
+                }, (error) => {
+                    maybeRemoveExternalAbortListener();
+                    this.collectedErrors.add(ensureGraphQLError(error), undefined);
+                    return this.buildResponse(null);
+                });
+                this.sharedExecutionContext.asyncWorkTracker.add(promise);
+                const { promise: cancellablePromise, abort: abortResultPromise } = 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(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(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();
+            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 promiseReduce(groupedFieldSet, (results, [responseName, fieldDetailsList]) => {
+            if (this.aborted) {
+                throw new Error('Aborted!');
+            }
+            const fieldPath = addPath(path, responseName, parentType.name);
+            const result = this.executeField(parentType, sourceValue, fieldDetailsList, fieldPath, positionContext);
+            if (result === undefined) {
+                return results;
+            }
+            if (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 = addPath(path, responseName, parentType.name);
+                const result = this.executeField(parentType, sourceValue, fieldDetailsList, fieldPath, positionContext);
+                if (result !== undefined) {
+                    results[responseName] = result;
+                    if (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 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 = 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 = 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 (isPromiseLike(result)) {
+                return this.completePromisedValue(returnType, fieldDetailsList, info, path, result, positionContext);
+            }
+            const completed = this.completeValue(returnType, fieldDetailsList, info, path, result, positionContext);
+            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) => {
+                    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 = 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 (this.validatedExecutionArgs.errorPropagation &&
+            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 (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 (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 (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 (isAbstractType(returnType)) {
+            return this.completeAbstractValue(returnType, fieldDetailsList, info, path, result, positionContext);
+        }
+        // If field type is Object, execute and complete all sub-selections.
+        if (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.
+        invariant(false, 'Cannot complete value of unexpected output type: ' + 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 (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
+            : 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 = addPath(path, index, undefined);
+                try {
+                    // eslint-disable-next-line no-await-in-loop
+                    iteration = await asyncIterator.next();
+                }
+                catch (rawError) {
+                    throw locatedError(rawError, toNodes(fieldDetailsList), 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(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(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 (isAsyncIterable(result)) {
+            return this.completeAsyncIterableValue(itemType, fieldDetailsList, info, path, result, positionContext);
+        }
+        if (!isIterableObject(result)) {
+            throw new 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
+            : 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 = 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(collectIteratorPromises(iterator));
+            throw error;
+        }
+        return containsPromise
+            ? this.promiseAll(completedResults)
+            : completedResults;
+    }
+    completeMaybePromisedListItemValue(item, completedResults, itemType, fieldDetailsList, info, itemPath, positionContext) {
+        if (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 (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 (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 \`${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.
+     */
+    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 (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(`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.
+     */
+    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 (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(`Expected value of type "${returnType}" but got: ${inspect(result)}.`, { nodes: toNodes(fieldDetailsList) });
+    }
+    collectAndExecuteSubfields(returnType, fieldDetailsList, path, result, positionContext) {
+        // Collect sub-fields to execute to complete this value.
+        const { groupedFieldSet, newDeferUsages } = 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);
+    }
+}
+function toNodes(fieldDetailsList) {
+    return fieldDetailsList.map((fieldDetails) => fieldDetails.node);
+}
+//# sourceMappingURL=Executor.js.map