graphql 17.0.0-beta.0 → 17.0.0-beta.2

package/execution/Executor.js

@@ -1,44 +1,36 @@
 "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 inspect_ts_1 = require("../jsutils/inspect.js");
+const invariant_ts_1 = require("../jsutils/invariant.js");
+const isAsyncIterable_ts_1 = require("../jsutils/isAsyncIterable.js");
+const isIterableObject_ts_1 = require("../jsutils/isIterableObject.js");
+const isPromise_ts_1 = require("../jsutils/isPromise.js");
+const memoize2_ts_1 = require("../jsutils/memoize2.js");
+const memoize3_ts_1 = require("../jsutils/memoize3.js");
+const Path_ts_1 = require("../jsutils/Path.js");
+const promiseForObject_ts_1 = require("../jsutils/promiseForObject.js");
+const promiseReduce_ts_1 = require("../jsutils/promiseReduce.js");
+const ensureGraphQLError_ts_1 = require("../error/ensureGraphQLError.js");
+const GraphQLError_ts_1 = require("../error/GraphQLError.js");
+const locatedError_ts_1 = require("../error/locatedError.js");
+const ast_ts_1 = require("../language/ast.js");
+const definition_ts_1 = require("../type/definition.js");
+const AbortedGraphQLExecutionError_ts_1 = require("./AbortedGraphQLExecutionError.js");
+const buildResolveInfo_ts_1 = require("./buildResolveInfo.js");
+const cancellablePromise_ts_1 = require("./cancellablePromise.js");
+const collectFields_ts_1 = require("./collectFields.js");
+const collectIteratorPromises_ts_1 = require("./collectIteratorPromises.js");
+const createSharedExecutionContext_ts_1 = require("./createSharedExecutionContext.js");
+const getStreamUsage_ts_1 = require("./getStreamUsage.js");
+const hooks_ts_1 = require("./hooks.js");
+const returnIteratorCatchingErrors_ts_1 = require("./returnIteratorCatchingErrors.js");
+const values_ts_1 = require("./values.js");
+exports.collectSubfields = (0, memoize3_ts_1.memoize3)((validatedExecutionArgs, returnType, fieldDetailsList) => {
     const { schema, fragments, variableValues, hideSuggestions } = validatedExecutionArgs;
-    return (0, collectFields_js_1.collectSubfields)(schema, fragments, variableValues, returnType, fieldDetailsList, hideSuggestions);
+    return (0, collectFields_ts_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
- */
+exports.getStreamUsage = (0, memoize2_ts_1.memoize2)((validatedExecutionArgs, fieldDetailsList) => (0, getStreamUsage_ts_1.getStreamUsage)(validatedExecutionArgs, fieldDetailsList));
 class CollectedErrors {
     constructor() {
         this._errorPositions = new Set();
@@ -48,10 +40,6 @@ class CollectedErrors {
         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;
         }
@@ -70,7 +58,6 @@ class CollectedErrors {
     }
 }
 const defaultAbortReason = new Error('This operation was aborted');
-/** @internal */
 class Executor {
     constructor(validatedExecutionArgs, sharedExecutionContext) {
         this.validatedExecutionArgs = validatedExecutionArgs;
@@ -79,7 +66,7 @@ class Executor {
         this.collectedErrors = new CollectedErrors();
         if (sharedExecutionContext === undefined) {
             this.resolverAbortController = new AbortController();
-            this.sharedExecutionContext = (0, createSharedExecutionContext_js_1.createSharedExecutionContext)(this.resolverAbortController.signal);
+            this.sharedExecutionContext = (0, createSharedExecutionContext_ts_1.createSharedExecutionContext)(this.resolverAbortController.signal);
         }
         else {
             this.sharedExecutionContext = sharedExecutionContext;
@@ -109,21 +96,21 @@ class Executor {
             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 });
+                throw new GraphQLError_ts_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 { groupedFieldSet, newDeferUsages } = (0, collectFields_ts_1.collectFields)(schema, fragments, variableValues, rootType, selectionSet, hideSuggestions);
+            result = this.executeCollectedRootFields(rootType, rootValue, groupedFieldSet, serially ?? operationType === ast_ts_1.OperationTypeNode.MUTATION, newDeferUsages);
+            if ((0, isPromise_ts_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);
+                    this.collectedErrors.add((0, ensureGraphQLError_ts_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)));
+                const { promise: cancellablePromise, abort: abortResultPromise } = (0, cancellablePromise_ts_1.withCancellation)(promise.then((resolved) => this.finish(resolved)));
                 this.abortResultPromise = () => {
                     abortResultPromise(this.createAbortedExecutionError(promise));
                 };
@@ -136,7 +123,7 @@ class Executor {
         }
         catch (error) {
             maybeRemoveExternalAbortListener();
-            this.collectedErrors.add((0, ensureGraphQLError_js_1.ensureGraphQLError)(error), undefined);
+            this.collectedErrors.add((0, ensureGraphQLError_ts_1.ensureGraphQLError)(error), undefined);
             return this.finish(this.buildResponse(null));
         }
         return this.finish(this.buildResponse(result));
@@ -160,7 +147,7 @@ class Executor {
         return result;
     }
     createAbortedExecutionError(result) {
-        return new AbortedGraphQLExecutionError_js_1.AbortedGraphQLExecutionError(this.abortReason, result);
+        return new AbortedGraphQLExecutionError_ts_1.AbortedGraphQLExecutionError(this.abortReason, result);
     }
     getFinishSharedExecution() {
         const resolverAbortController = this.resolverAbortController;
@@ -172,13 +159,9 @@ class Executor {
         const sharedExecutionContext = this.sharedExecutionContext;
         return () => {
             resolverAbortController?.abort();
-            (0, hooks_js_1.runAsyncWorkFinishedHook)(validatedExecutionArgs, sharedExecutionContext, asyncWorkFinishedHook);
+            (0, hooks_ts_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;
@@ -192,21 +175,17 @@ class Executor {
             ? 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]) => {
+        return (0, promiseReduce_ts_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 fieldPath = (0, Path_ts_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)) {
+            if ((0, isPromise_ts_1.isPromise)(result)) {
                 return result.then((resolved) => {
                     results[responseName] = resolved;
                     return results;
@@ -216,20 +195,16 @@ class Executor {
             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 fieldPath = (0, Path_ts_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)) {
+                    if ((0, isPromise_ts_1.isPromise)(result)) {
                         containsPromise = true;
                     }
                 }
@@ -241,21 +216,11 @@ class Executor {
             }
             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.
-     */
+        return (0, promiseForObject_ts_1.promiseForObject)(results, this.promiseAll);
+    }
     executeField(parentType, source, fieldDetailsList, path, positionContext) {
         const validatedExecutionArgs = this.validatedExecutionArgs;
         const { schema, contextValue, variableValues, hideSuggestions } = validatedExecutionArgs;
@@ -268,24 +233,15 @@ class Executor {
         }
         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).
+        const info = (0, buildResolveInfo_ts_1.buildResolveInfo)(validatedExecutionArgs, fieldDef, toNodes(fieldDetailsList), parentType, path, this.getAbortSignal, this.getAsyncHelpers);
         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 args = (0, values_ts_1.getArgumentValues)(fieldDef, firstNode, variableValues, firstFieldDetails.fragmentVariableValues, hideSuggestions);
             const result = resolveFn(source, args, contextValue, info);
-            if ((0, isPromise_js_1.isPromiseLike)(result)) {
+            if ((0, isPromise_ts_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.
+            if ((0, isPromise_ts_1.isPromise)(completed)) {
                 return completed.then(undefined, (rawError) => {
                     this.handleFieldError(rawError, returnType, fieldDetailsList, path);
                     return null;
@@ -299,79 +255,40 @@ class Executor {
         }
     }
     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.
+        const error = (0, locatedError_ts_1.locatedError)(rawError, toNodes(fieldDetailsList), (0, Path_ts_1.pathToArray)(path));
         if (this.validatedExecutionArgs.errorPropagation &&
-            (0, definition_js_1.isNonNullType)(returnType)) {
+            (0, definition_ts_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)) {
+        if ((0, definition_ts_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)) {
+        if ((0, definition_ts_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)) {
+        if ((0, definition_ts_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)) {
+        if ((0, definition_ts_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)) {
+        if ((0, definition_ts_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));
+        (0, invariant_ts_1.invariant)(false, 'Cannot complete value of unexpected output type: ' + (0, inspect_ts_1.inspect)(returnType));
     }
     async completePromisedValue(returnType, fieldDetailsList, info, path, result, positionContext) {
         try {
@@ -380,7 +297,7 @@ class Executor {
                 throw new Error('Aborted!');
             }
             let completed = this.completeValue(returnType, fieldDetailsList, info, path, resolved, positionContext);
-            if ((0, isPromise_js_1.isPromise)(completed)) {
+            if ((0, isPromise_ts_1.isPromise)(completed)) {
                 completed = await completed;
             }
             return completed;
@@ -390,12 +307,7 @@ class Executor {
             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);
@@ -410,13 +322,12 @@ class Executor {
                     this.handleStream(index, path, { handle: asyncIterator, isAsync: true }, streamUsage, info, itemType)) {
                     break;
                 }
-                const itemPath = (0, Path_js_1.addPath)(path, index, undefined);
+                const itemPath = (0, Path_ts_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));
+                    throw (0, locatedError_ts_1.locatedError)(rawError, toNodes(fieldDetailsList), (0, Path_ts_1.pathToArray)(path));
                 }
                 if (this.aborted || iteration.done) {
                     break;
@@ -429,16 +340,15 @@ class Executor {
             }
         }
         catch (error) {
-            this.sharedExecutionContext.asyncWorkTracker.add((0, returnIteratorCatchingErrors_js_1.returnIteratorCatchingErrors)(asyncIterator));
+            this.sharedExecutionContext.asyncWorkTracker.add((0, returnIteratorCatchingErrors_ts_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));
+                this.sharedExecutionContext.asyncWorkTracker.add((0, returnIteratorCatchingErrors_ts_1.returnIteratorCatchingErrors)(asyncIterator));
             }
             throw new Error('Aborted!');
         }
@@ -446,31 +356,23 @@ class Executor {
             ? 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)) {
+        if ((0, isAsyncIterable_ts_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}".`);
+        if (!(0, isIterableObject_ts_1.isIterableObject)(result)) {
+            throw new GraphQLError_ts_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;
@@ -486,9 +388,7 @@ class Executor {
                     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);
+                const itemPath = (0, Path_ts_1.addPath)(path, index, undefined);
                 if (this.completeMaybePromisedListItemValue(item, completedResults, itemType, fieldDetailsList, info, itemPath, positionContext)) {
                     containsPromise = true;
                 }
@@ -500,7 +400,7 @@ class Executor {
             if (containsPromise) {
                 asyncWorkTracker.addValues(completedResults);
             }
-            asyncWorkTracker.addValues((0, collectIteratorPromises_js_1.collectIteratorPromises)(iterator));
+            asyncWorkTracker.addValues((0, collectIteratorPromises_ts_1.collectIteratorPromises)(iterator));
             throw error;
         }
         return containsPromise
@@ -508,7 +408,7 @@ class Executor {
             : completedResults;
     }
     completeMaybePromisedListItemValue(item, completedResults, itemType, fieldDetailsList, info, itemPath, positionContext) {
-        if ((0, isPromise_js_1.isPromiseLike)(item)) {
+        if ((0, isPromise_ts_1.isPromiseLike)(item)) {
             completedResults.push(this.completePromisedListItemValue(item, itemType, fieldDetailsList, info, itemPath, positionContext));
             return true;
         }
@@ -517,17 +417,10 @@ class Executor {
         }
         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.
+            if ((0, isPromise_ts_1.isPromise)(completedItem)) {
                 completedResults.push(completedItem.then(undefined, (rawError) => {
                     this.handleFieldError(rawError, itemType, fieldDetailsList, itemPath);
                     return null;
@@ -549,7 +442,7 @@ class Executor {
                 throw new Error('Aborted!');
             }
             let completed = this.completeValue(itemType, fieldDetailsList, info, itemPath, resolved, positionContext);
-            if ((0, isPromise_js_1.isPromise)(completed)) {
+            if ((0, isPromise_ts_1.isPromise)(completed)) {
                 completed = await completed;
             }
             return completed;
@@ -559,29 +452,21 @@ class Executor {
             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)}`);
+            throw new Error(`Expected \`${(0, inspect_ts_1.inspect)(returnType)}.coerceOutputValue(${(0, inspect_ts_1.inspect)(result)})\` to ` +
+                `return non-nullable value, returned: ${(0, inspect_ts_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 ((0, isPromise_ts_1.isPromiseLike)(runtimeType)) {
+            return runtimeType.then((resolvedRuntimeType) => {
                 if (this.aborted) {
                     throw new Error('Aborted!');
                 }
@@ -592,35 +477,29 @@ class Executor {
     }
     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) });
+            throw new GraphQLError_ts_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.`);
+            throw new GraphQLError_ts_1.GraphQLError(`Abstract type "${returnType}" must resolve to an Object type at runtime for field "${info.parentType}.${info.fieldName}" with ` +
+                `value ${(0, inspect_ts_1.inspect)(result)}, received "${(0, inspect_ts_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) });
+            throw new GraphQLError_ts_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 (!(0, definition_ts_1.isObjectType)(runtimeType)) {
+            throw new GraphQLError_ts_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) });
+            throw new GraphQLError_ts_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 ((0, isPromise_ts_1.isPromiseLike)(isTypeOf)) {
+                return isTypeOf.then((resolvedIsTypeOf) => {
                     if (this.aborted) {
                         throw new Error('Aborted!');
                     }
@@ -637,10 +516,9 @@ class Executor {
         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) });
+        return new GraphQLError_ts_1.GraphQLError(`Expected value of type "${returnType}" but got: ${(0, inspect_ts_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);
     }