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

package/execution/Executor.mjs

@@ -14,28 +14,20 @@ 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 { buildResolveInfo } from "./buildResolveInfo.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();
@@ -45,10 +37,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;
         }
@@ -67,7 +55,6 @@ class CollectedErrors {
     }
 }
 const defaultAbortReason = new Error('This operation was aborted');
-/** @internal */
 export class Executor {
     constructor(validatedExecutionArgs, sharedExecutionContext) {
         this.validatedExecutionArgs = validatedExecutionArgs;
@@ -172,10 +159,6 @@ export class Executor {
             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;
@@ -189,10 +172,6 @@ export 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 promiseReduce(groupedFieldSet, (results, [responseName, fieldDetailsList]) => {
             if (this.aborted) {
@@ -213,10 +192,6 @@ export 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;
@@ -238,21 +213,11 @@ export 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 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;
@@ -266,23 +231,14 @@ export class Executor {
         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;
@@ -297,44 +253,16 @@ export class Executor {
     }
     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) {
@@ -342,32 +270,21 @@ export class Executor {
             }
             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) {
@@ -387,12 +304,7 @@ export 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
             : getStreamUsage(this.validatedExecutionArgs, fieldDetailsList);
@@ -409,7 +321,6 @@ export class Executor {
                 }
                 const itemPath = addPath(path, index, undefined);
                 try {
-                    // eslint-disable-next-line no-await-in-loop
                     iteration = await asyncIterator.next();
                 }
                 catch (rawError) {
@@ -432,7 +343,6 @@ export class Executor {
             }
             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));
@@ -443,14 +353,9 @@ export 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 (isAsyncIterable(result)) {
@@ -462,12 +367,9 @@ export class Executor {
         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;
@@ -483,8 +385,6 @@ export 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 = addPath(path, index, undefined);
                 if (this.completeMaybePromisedListItemValue(item, completedResults, itemType, fieldDetailsList, info, itemPath, positionContext)) {
                     containsPromise = true;
@@ -514,17 +414,10 @@ export 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 (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;
@@ -556,10 +449,6 @@ export 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) {
@@ -568,17 +457,13 @@ export class Executor {
         }
         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) => {
+            return runtimeType.then((resolvedRuntimeType) => {
                 if (this.aborted) {
                     throw new Error('Aborted!');
                 }
@@ -607,17 +492,11 @@ export class Executor {
         }
         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) => {
+                return isTypeOf.then((resolvedIsTypeOf) => {
                     if (this.aborted) {
                         throw new Error('Aborted!');
                     }
@@ -637,7 +516,6 @@ export class Executor {
         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);
     }