graphql 14.4.2 → 14.5.3

package/execution/execute.js.flow

@@ -1,28 +1,46 @@
 // @flow strict
 
 import { forEach, isCollection } from 'iterall';
-import { GraphQLError } from '../error/GraphQLError';
-import { locatedError } from '../error/locatedError';
+
 import inspect from '../jsutils/inspect';
+import memoize3 from '../jsutils/memoize3';
 import invariant from '../jsutils/invariant';
+import devAssert from '../jsutils/devAssert';
 import isInvalid from '../jsutils/isInvalid';
 import isNullish from '../jsutils/isNullish';
 import isPromise from '../jsutils/isPromise';
+import { type ObjMap } from '../jsutils/ObjMap';
 import isObjectLike from '../jsutils/isObjectLike';
-import memoize3 from '../jsutils/memoize3';
-import promiseForObject from '../jsutils/promiseForObject';
 import promiseReduce from '../jsutils/promiseReduce';
-import { type ObjMap } from '../jsutils/ObjMap';
+import promiseForObject from '../jsutils/promiseForObject';
 import { type PromiseOrValue } from '../jsutils/PromiseOrValue';
+import { type Path, addPath, pathToArray } from '../jsutils/Path';
+
+import { GraphQLError } from '../error/GraphQLError';
+import { locatedError } from '../error/locatedError';
 
-import { getOperationRootType } from '../utilities/getOperationRootType';
-import { typeFromAST } from '../utilities/typeFromAST';
 import { Kind } from '../language/kinds';
 import {
-  getVariableValues,
-  getArgumentValues,
-  getDirectiveValues,
-} from './values';
+  type DocumentNode,
+  type OperationDefinitionNode,
+  type SelectionSetNode,
+  type FieldNode,
+  type FragmentSpreadNode,
+  type InlineFragmentNode,
+  type FragmentDefinitionNode,
+} from '../language/ast';
+
+import { assertValidSchema } from '../type/validate';
+import { type GraphQLSchema } from '../type/schema';
+import {
+  SchemaMetaFieldDef,
+  TypeMetaFieldDef,
+  TypeNameMetaFieldDef,
+} from '../type/introspection';
+import {
+  GraphQLIncludeDirective,
+  GraphQLSkipDirective,
+} from '../type/directives';
 import {
   type GraphQLObjectType,
   type GraphQLOutputType,
@@ -32,7 +50,6 @@ import {
   type GraphQLFieldResolver,
   type GraphQLResolveInfo,
   type GraphQLTypeResolver,
-  type ResponsePath,
   type GraphQLList,
   isObjectType,
   isAbstractType,
@@ -40,26 +57,15 @@ import {
   isListType,
   isNonNullType,
 } from '../type/definition';
-import { type GraphQLSchema } from '../type/schema';
-import {
-  SchemaMetaFieldDef,
-  TypeMetaFieldDef,
-  TypeNameMetaFieldDef,
-} from '../type/introspection';
-import {
-  GraphQLIncludeDirective,
-  GraphQLSkipDirective,
-} from '../type/directives';
-import { assertValidSchema } from '../type/validate';
+
+import { typeFromAST } from '../utilities/typeFromAST';
+import { getOperationRootType } from '../utilities/getOperationRootType';
+
 import {
-  type DocumentNode,
-  type OperationDefinitionNode,
-  type SelectionSetNode,
-  type FieldNode,
-  type FragmentSpreadNode,
-  type InlineFragmentNode,
-  type FragmentDefinitionNode,
-} from '../language/ast';
+  getVariableValues,
+  getArgumentValues,
+  getDirectiveValues,
+} from './values';
 
 /**
  * Terminology
@@ -235,30 +241,6 @@ function buildResponse(
     : { errors: exeContext.errors, data };
 }
 
-/**
- * Given a ResponsePath (found in the `path` entry in the information provided
- * as the last argument to a field resolver), return an Array of the path keys.
- */
-export function responsePathAsArray(
-  path: ResponsePath,
-): $ReadOnlyArray<string | number> {
-  const flattened = [];
-  let curr = path;
-  while (curr) {
-    flattened.push(curr.key);
-    curr = curr.prev;
-  }
-  return flattened.reverse();
-}
-
-/**
- * Given a ResponsePath and a key, return a new ResponsePath containing the
- * new key.
- */
-export function addPath(prev: ResponsePath | void, key: string | number) {
-  return { prev, key };
-}
-
 /**
  * Essential assertions before executing to provide developer feedback for
  * improper use of the GraphQL library.
@@ -268,13 +250,13 @@ export function assertValidExecutionArguments(
   document: DocumentNode,
   rawVariableValues: ?{ +[variable: string]: mixed, ... },
 ): void {
-  invariant(document, 'Must provide document');
+  devAssert(document, 'Must provide document');
 
   // If the schema used for execution is invalid, throw an error.
   assertValidSchema(schema);
 
   // Variables, if provided, must be an object.
-  invariant(
+  devAssert(
     rawVariableValues == null || isObjectLike(rawVariableValues),
     'Variables must be provided as an Object where each property is a variable value. Perhaps look to see if an unparsed JSON string was provided.',
   );
@@ -293,15 +275,13 @@ export function buildExecutionContext(
   contextValue: mixed,
   rawVariableValues: ?{ +[variable: string]: mixed, ... },
   operationName: ?string,
-  fieldResolver: ?GraphQLFieldResolver<any, any>,
-  typeResolver?: ?GraphQLTypeResolver<any, any>,
+  fieldResolver: ?GraphQLFieldResolver<mixed, mixed>,
+  typeResolver?: ?GraphQLTypeResolver<mixed, mixed>,
 ): $ReadOnlyArray<GraphQLError> | ExecutionContext {
-  const errors: Array<GraphQLError> = [];
   let operation: OperationDefinitionNode | void;
   let hasMultipleAssumedOperations = false;
   const fragments: ObjMap<FragmentDefinitionNode> = Object.create(null);
-  for (let i = 0; i < document.definitions.length; i++) {
-    const definition = document.definitions[i];
+  for (const definition of document.definitions) {
     switch (definition.kind) {
       case Kind.OPERATION_DEFINITION:
         if (!operationName && operation) {
@@ -321,52 +301,40 @@ export function buildExecutionContext(
 
   if (!operation) {
     if (operationName) {
-      errors.push(
-        new GraphQLError(`Unknown operation named "${operationName}".`),
-      );
-    } else {
-      errors.push(new GraphQLError('Must provide an operation.'));
+      return [new GraphQLError(`Unknown operation named "${operationName}".`)];
     }
-  } else if (hasMultipleAssumedOperations) {
-    errors.push(
+    return [new GraphQLError('Must provide an operation.')];
+  }
+
+  if (hasMultipleAssumedOperations) {
+    return [
       new GraphQLError(
         'Must provide operation name if query contains multiple operations.',
       ),
-    );
+    ];
   }
 
-  let variableValues;
-  if (operation) {
-    const coercedVariableValues = getVariableValues(
-      schema,
-      operation.variableDefinitions || [],
-      rawVariableValues || {},
-    );
-
-    if (coercedVariableValues.errors) {
-      errors.push(...coercedVariableValues.errors);
-    } else {
-      variableValues = coercedVariableValues.coerced;
-    }
-  }
+  const coercedVariableValues = getVariableValues(
+    schema,
+    operation.variableDefinitions || [],
+    rawVariableValues || {},
+    { maxErrors: 50 },
+  );
 
-  if (errors.length !== 0) {
-    return errors;
+  if (coercedVariableValues.errors) {
+    return coercedVariableValues.errors;
   }
 
-  invariant(operation, 'Has operation if no errors.');
-  invariant(variableValues, 'Has variables if no errors.');
-
   return {
     schema,
     fragments,
     rootValue,
     contextValue,
     operation,
-    variableValues,
+    variableValues: coercedVariableValues.coerced,
     fieldResolver: fieldResolver || defaultFieldResolver,
     typeResolver: typeResolver || defaultTypeResolver,
-    errors,
+    errors: [],
   };
 }
 
@@ -420,7 +388,7 @@ function executeFieldsSerially(
   exeContext: ExecutionContext,
   parentType: GraphQLObjectType,
   sourceValue: mixed,
-  path: ResponsePath | void,
+  path: Path | void,
   fields: ObjMap<Array<FieldNode>>,
 ): PromiseOrValue<ObjMap<mixed>> {
   return promiseReduce(
@@ -459,14 +427,13 @@ function executeFields(
   exeContext: ExecutionContext,
   parentType: GraphQLObjectType,
   sourceValue: mixed,
-  path: ResponsePath | void,
+  path: Path | void,
   fields: ObjMap<Array<FieldNode>>,
 ): PromiseOrValue<ObjMap<mixed>> {
   const results = Object.create(null);
   let containsPromise = false;
 
-  for (let i = 0, keys = Object.keys(fields); i < keys.length; ++i) {
-    const responseName = keys[i];
+  for (const responseName of Object.keys(fields)) {
     const fieldNodes = fields[responseName];
     const fieldPath = addPath(path, responseName);
     const result = resolveField(
@@ -511,8 +478,7 @@ export function collectFields(
   fields: ObjMap<Array<FieldNode>>,
   visitedFragmentNames: ObjMap<boolean>,
 ): ObjMap<Array<FieldNode>> {
-  for (let i = 0; i < selectionSet.selections.length; i++) {
-    const selection = selectionSet.selections[i];
+  for (const selection of selectionSet.selections) {
     switch (selection.kind) {
       case Kind.FIELD: {
         if (!shouldIncludeNode(exeContext, selection)) {
@@ -639,7 +605,7 @@ function resolveField(
   parentType: GraphQLObjectType,
   source: mixed,
   fieldNodes: $ReadOnlyArray<FieldNode>,
-  path: ResponsePath,
+  path: Path,
 ): PromiseOrValue<mixed> {
   const fieldNode = fieldNodes[0];
   const fieldName = fieldNode.name.value;
@@ -682,10 +648,10 @@ function resolveField(
 
 export function buildResolveInfo(
   exeContext: ExecutionContext,
-  fieldDef: GraphQLField<*, *>,
+  fieldDef: GraphQLField<mixed, mixed>,
   fieldNodes: $ReadOnlyArray<FieldNode>,
   parentType: GraphQLObjectType,
-  path: ResponsePath,
+  path: Path,
 ): GraphQLResolveInfo {
   // The resolve function's optional fourth argument is a collection of
   // information about the current execution state.
@@ -705,12 +671,12 @@ export function buildResolveInfo(
 
 // Isolates the "ReturnOrAbrupt" behavior to not de-opt the `resolveField`
 // function. Returns the result of resolveFn or the abrupt-return Error object.
-export function resolveFieldValueOrError<TSource>(
+export function resolveFieldValueOrError(
   exeContext: ExecutionContext,
-  fieldDef: GraphQLField<TSource, *>,
+  fieldDef: GraphQLField<mixed, mixed>,
   fieldNodes: $ReadOnlyArray<FieldNode>,
-  resolveFn: GraphQLFieldResolver<TSource, *>,
-  source: TSource,
+  resolveFn: GraphQLFieldResolver<mixed, mixed>,
+  source: mixed,
   info: GraphQLResolveInfo,
 ): Error | mixed {
   try {
@@ -751,7 +717,7 @@ function completeValueCatchingError(
   returnType: GraphQLOutputType,
   fieldNodes: $ReadOnlyArray<FieldNode>,
   info: GraphQLResolveInfo,
-  path: ResponsePath,
+  path: Path,
   result: mixed,
 ): PromiseOrValue<mixed> {
   try {
@@ -788,7 +754,7 @@ function handleFieldError(rawError, fieldNodes, path, returnType, exeContext) {
   const error = locatedError(
     asErrorInstance(rawError),
     fieldNodes,
-    responsePathAsArray(path),
+    pathToArray(path),
   );
 
   // If the field type is non-nullable, then it is resolved without any
@@ -829,7 +795,7 @@ function completeValue(
   returnType: GraphQLOutputType,
   fieldNodes: $ReadOnlyArray<FieldNode>,
   info: GraphQLResolveInfo,
-  path: ResponsePath,
+  path: Path,
   result: mixed,
 ): PromiseOrValue<mixed> {
   // If result is an Error, throw a located error.
@@ -905,11 +871,10 @@ function completeValue(
   }
 
   // Not reachable. All possible output types have been considered.
-  /* istanbul ignore next */
-  throw new Error(
-    `Cannot complete value of unexpected output type: "${inspect(
-      (returnType: empty),
-    )}".`,
+  invariant(
+    false,
+    'Cannot complete value of unexpected output type: ' +
+      inspect((returnType: empty)),
   );
 }
 
@@ -922,13 +887,14 @@ function completeListValue(
   returnType: GraphQLList<GraphQLOutputType>,
   fieldNodes: $ReadOnlyArray<FieldNode>,
   info: GraphQLResolveInfo,
-  path: ResponsePath,
+  path: Path,
   result: mixed,
 ): PromiseOrValue<$ReadOnlyArray<mixed>> {
-  invariant(
-    isCollection(result),
-    `Expected Iterable, but did not find one for field ${info.parentType.name}.${info.fieldName}.`,
-  );
+  if (!isCollection(result)) {
+    throw new GraphQLError(
+      `Expected Iterable, but did not find one for field ${info.parentType.name}.${info.fieldName}.`,
+    );
+  }
 
   // This is specified as a simple map, however we're optimizing the path
   // where the list contains no Promises by avoiding creating another Promise.
@@ -962,7 +928,6 @@ function completeListValue(
  * null if serialization is not possible.
  */
 function completeLeafValue(returnType: GraphQLLeafType, result: mixed): mixed {
-  invariant(returnType.serialize, 'Missing serialize method on type');
   const serializedResult = returnType.serialize(result);
   if (isInvalid(serializedResult)) {
     throw new Error(
@@ -982,7 +947,7 @@ function completeAbstractValue(
   returnType: GraphQLAbstractType,
   fieldNodes: $ReadOnlyArray<FieldNode>,
   info: GraphQLResolveInfo,
-  path: ResponsePath,
+  path: Path,
   result: mixed,
 ): PromiseOrValue<ObjMap<mixed>> {
   const resolveTypeFn = returnType.resolveType || exeContext.typeResolver;
@@ -1066,7 +1031,7 @@ function completeObjectValue(
   returnType: GraphQLObjectType,
   fieldNodes: $ReadOnlyArray<FieldNode>,
   info: GraphQLResolveInfo,
-  path: ResponsePath,
+  path: Path,
   result: mixed,
 ): PromiseOrValue<ObjMap<mixed>> {
   // If there is an isTypeOf predicate function, call it with the
@@ -1119,7 +1084,7 @@ function collectAndExecuteSubfields(
   exeContext: ExecutionContext,
   returnType: GraphQLObjectType,
   fieldNodes: $ReadOnlyArray<FieldNode>,
-  path: ResponsePath,
+  path: Path,
   result: mixed,
 ): PromiseOrValue<ObjMap<mixed>> {
   // Collect sub-fields to execute to complete this value.
@@ -1140,13 +1105,12 @@ function _collectSubfields(
 ): ObjMap<Array<FieldNode>> {
   let subFieldNodes = Object.create(null);
   const visitedFragmentNames = Object.create(null);
-  for (let i = 0; i < fieldNodes.length; i++) {
-    const selectionSet = fieldNodes[i].selectionSet;
-    if (selectionSet) {
+  for (const node of fieldNodes) {
+    if (node.selectionSet) {
       subFieldNodes = collectFields(
         exeContext,
         returnType,
-        selectionSet,
+        node.selectionSet,
         subFieldNodes,
         visitedFragmentNames,
       );
@@ -1165,7 +1129,7 @@ function _collectSubfields(
  * Otherwise, test each possible type for the abstract type by calling
  * isTypeOf for the object being coerced, returning the first type that matches.
  */
-export const defaultTypeResolver: GraphQLTypeResolver<any, *> = function(
+export const defaultTypeResolver: GraphQLTypeResolver<mixed, mixed> = function(
   value,
   contextValue,
   info,
@@ -1211,12 +1175,10 @@ export const defaultTypeResolver: GraphQLTypeResolver<any, *> = function(
  * and returns it as the result, or if it's a function, returns the result
  * of calling that function while passing along args and context value.
  */
-export const defaultFieldResolver: GraphQLFieldResolver<any, *> = function(
-  source,
-  args,
-  contextValue,
-  info,
-) {
+export const defaultFieldResolver: GraphQLFieldResolver<
+  mixed,
+  mixed,
+> = function(source: any, args, contextValue, info) {
   // ensure source is a value for which property access is acceptable.
   if (isObjectLike(source) || typeof source === 'function') {
     const property = source[info.fieldName];
@@ -1240,7 +1202,7 @@ export function getFieldDef(
   schema: GraphQLSchema,
   parentType: GraphQLObjectType,
   fieldName: string,
-): ?GraphQLField<*, *> {
+): ?GraphQLField<mixed, mixed> {
   if (
     fieldName === SchemaMetaFieldDef.name &&
     schema.getQueryType() === parentType