graphql 14.4.2 → 14.5.3

package/execution/values.js

@@ -9,19 +9,13 @@ exports.getDirectiveValues = getDirectiveValues;
 
 var _find = _interopRequireDefault(require("../polyfills/find"));
 
-var _GraphQLError = require("../error/GraphQLError");
-
-var _inspect = _interopRequireDefault(require("../jsutils/inspect"));
-
-var _invariant = _interopRequireDefault(require("../jsutils/invariant"));
-
 var _keyMap = _interopRequireDefault(require("../jsutils/keyMap"));
 
-var _coerceValue = require("../utilities/coerceValue");
+var _inspect = _interopRequireDefault(require("../jsutils/inspect"));
 
-var _typeFromAST = require("../utilities/typeFromAST");
+var _printPathArray = _interopRequireDefault(require("../jsutils/printPathArray"));
 
-var _valueFromAST = require("../utilities/valueFromAST");
+var _GraphQLError = require("../error/GraphQLError");
 
 var _kinds = require("../language/kinds");
 
@@ -29,6 +23,12 @@ var _printer = require("../language/printer");
 
 var _definition = require("../type/definition");
 
+var _typeFromAST = require("../utilities/typeFromAST");
+
+var _valueFromAST = require("../utilities/valueFromAST");
+
+var _coerceInputValue = require("../utilities/coerceInputValue");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
@@ -40,83 +40,90 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * exposed to user code. Care should be taken to not pull values from the
  * Object prototype.
  */
-function getVariableValues(schema, varDefNodes, inputs) {
+function getVariableValues(schema, varDefNodes, inputs, options) {
+  var maxErrors = options && options.maxErrors;
   var errors = [];
+
+  try {
+    var coerced = coerceVariableValues(schema, varDefNodes, inputs, function (error) {
+      if (maxErrors != null && errors.length >= maxErrors) {
+        throw new _GraphQLError.GraphQLError('Too many errors processing variables, error limit reached. Execution aborted.');
+      }
+
+      errors.push(error);
+    });
+
+    if (errors.length === 0) {
+      return {
+        coerced: coerced
+      };
+    }
+  } catch (error) {
+    errors.push(error);
+  }
+
+  return {
+    errors: errors
+  };
+}
+
+function coerceVariableValues(schema, varDefNodes, inputs, onError) {
   var coercedValues = {};
 
-  for (var i = 0; i < varDefNodes.length; i++) {
-    var varDefNode = varDefNodes[i];
+  var _loop = function _loop(_i2) {
+    var varDefNode = varDefNodes[_i2];
     var varName = varDefNode.variable.name.value;
     var varType = (0, _typeFromAST.typeFromAST)(schema, varDefNode.type);
 
     if (!(0, _definition.isInputType)(varType)) {
       // Must use input types for variables. This should be caught during
       // validation, however is checked again here for safety.
-      errors.push(new _GraphQLError.GraphQLError("Variable \"$".concat(varName, "\" expected value of type ") + "\"".concat((0, _printer.print)(varDefNode.type), "\" which cannot be used as an input type."), varDefNode.type));
-    } else {
-      var hasValue = hasOwnProperty(inputs, varName);
-      var value = hasValue ? inputs[varName] : undefined;
-
-      if (!hasValue && varDefNode.defaultValue) {
-        // If no value was provided to a variable with a default value,
-        // use the default value.
+      var varTypeStr = (0, _printer.print)(varDefNode.type);
+      onError(new _GraphQLError.GraphQLError("Variable \"$".concat(varName, "\" expected value of type \"").concat(varTypeStr, "\" which cannot be used as an input type."), varDefNode.type));
+      return "continue";
+    }
+
+    if (!hasOwnProperty(inputs, varName)) {
+      if (varDefNode.defaultValue) {
         coercedValues[varName] = (0, _valueFromAST.valueFromAST)(varDefNode.defaultValue, varType);
-      } else if ((!hasValue || value === null) && (0, _definition.isNonNullType)(varType)) {
-        // If no value or a nullish value was provided to a variable with a
-        // non-null type (required), produce an error.
-        errors.push(new _GraphQLError.GraphQLError(hasValue ? "Variable \"$".concat(varName, "\" of non-null type ") + "\"".concat((0, _inspect.default)(varType), "\" must not be null.") : "Variable \"$".concat(varName, "\" of required type ") + "\"".concat((0, _inspect.default)(varType), "\" was not provided."), varDefNode));
-      } else if (hasValue) {
-        if (value === null) {
-          // If the explicit value `null` was provided, an entry in the coerced
-          // values must exist as the value `null`.
-          coercedValues[varName] = null;
-        } else {
-          // Otherwise, a non-null value was provided, coerce it to the expected
-          // type or report an error if coercion fails.
-          var coerced = (0, _coerceValue.coerceValue)(value, varType, varDefNode);
-          var coercionErrors = coerced.errors;
-
-          if (coercionErrors) {
-            var _iteratorNormalCompletion = true;
-            var _didIteratorError = false;
-            var _iteratorError = undefined;
-
-            try {
-              for (var _iterator = coercionErrors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                var error = _step.value;
-                error.message = "Variable \"$".concat(varName, "\" got invalid value ").concat((0, _inspect.default)(value), "; ") + error.message;
-              }
-            } catch (err) {
-              _didIteratorError = true;
-              _iteratorError = err;
-            } finally {
-              try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                  _iterator.return();
-                }
-              } finally {
-                if (_didIteratorError) {
-                  throw _iteratorError;
-                }
-              }
-            }
-
-            errors.push.apply(errors, coercionErrors);
-          } else {
-            coercedValues[varName] = coerced.value;
-          }
-        }
       }
+
+      if ((0, _definition.isNonNullType)(varType)) {
+        var _varTypeStr = (0, _inspect.default)(varType);
+
+        onError(new _GraphQLError.GraphQLError("Variable \"$".concat(varName, "\" of required type \"").concat(_varTypeStr, "\" was not provided."), varDefNode));
+      }
+
+      return "continue";
     }
-  }
 
-  return errors.length === 0 ? {
-    errors: undefined,
-    coerced: coercedValues
-  } : {
-    errors: errors,
-    coerced: undefined
+    var value = inputs[varName];
+
+    if (value === null && (0, _definition.isNonNullType)(varType)) {
+      var _varTypeStr2 = (0, _inspect.default)(varType);
+
+      onError(new _GraphQLError.GraphQLError("Variable \"$".concat(varName, "\" of non-null type \"").concat(_varTypeStr2, "\" must not be null."), varDefNode));
+      return "continue";
+    }
+
+    coercedValues[varName] = (0, _coerceInputValue.coerceInputValue)(value, varType, function (path, invalidValue, error) {
+      var prefix = "Variable \"$".concat(varName, "\" got invalid value ") + (0, _inspect.default)(invalidValue);
+
+      if (path.length > 0) {
+        prefix += " at \"".concat(varName).concat((0, _printPathArray.default)(path), "\"");
+      }
+
+      onError(new _GraphQLError.GraphQLError(prefix + '; ' + error.message, varDefNode, undefined, undefined, undefined, error.originalError));
+    });
   };
+
+  for (var _i2 = 0; _i2 < varDefNodes.length; _i2++) {
+    var _ret = _loop(_i2);
+
+    if (_ret === "continue") continue;
+  }
+
+  return coercedValues;
 }
 /**
  * Prepares an object map of argument values given a list of argument
@@ -130,75 +137,59 @@ function getVariableValues(schema, varDefNodes, inputs) {
 
 function getArgumentValues(def, node, variableValues) {
   var coercedValues = {};
-  var argDefs = def.args;
-  var argNodes = node.arguments;
-
-  if (!argDefs || !argNodes) {
-    return coercedValues;
-  }
-
-  var argNodeMap = (0, _keyMap.default)(argNodes, function (arg) {
+  var argNodeMap = (0, _keyMap.default)(node.arguments || [], function (arg) {
     return arg.name.value;
   });
 
-  for (var i = 0; i < argDefs.length; i++) {
-    var argDef = argDefs[i];
+  for (var _i4 = 0, _def$args2 = def.args; _i4 < _def$args2.length; _i4++) {
+    var argDef = _def$args2[_i4];
     var name = argDef.name;
     var argType = argDef.type;
     var argumentNode = argNodeMap[name];
-    var hasValue = void 0;
-    var isNull = void 0;
-
-    if (argumentNode && argumentNode.value.kind === _kinds.Kind.VARIABLE) {
-      var variableName = argumentNode.value.name.value;
-      hasValue = variableValues != null && hasOwnProperty(variableValues, variableName);
-      isNull = variableValues != null && variableValues[variableName] === null;
-    } else {
-      hasValue = argumentNode != null;
-      isNull = argumentNode != null && argumentNode.value.kind === _kinds.Kind.NULL;
-    }
 
-    if (!hasValue && argDef.defaultValue !== undefined) {
-      // If no argument was provided where the definition has a default value,
-      // use the default value.
-      coercedValues[name] = argDef.defaultValue;
-    } else if ((!hasValue || isNull) && (0, _definition.isNonNullType)(argType)) {
-      // If no argument or a null value was provided to an argument with a
-      // non-null type (required), produce a field error.
-      if (isNull) {
-        throw new _GraphQLError.GraphQLError("Argument \"".concat(name, "\" of non-null type \"").concat((0, _inspect.default)(argType), "\" ") + 'must not be null.', argumentNode.value);
-      } else if (argumentNode && argumentNode.value.kind === _kinds.Kind.VARIABLE) {
-        var _variableName = argumentNode.value.name.value;
-        throw new _GraphQLError.GraphQLError("Argument \"".concat(name, "\" of required type \"").concat((0, _inspect.default)(argType), "\" ") + "was provided the variable \"$".concat(_variableName, "\" which was not provided a runtime value."), argumentNode.value);
-      } else {
+    if (!argumentNode) {
+      if (argDef.defaultValue !== undefined) {
+        coercedValues[name] = argDef.defaultValue;
+      } else if ((0, _definition.isNonNullType)(argType)) {
         throw new _GraphQLError.GraphQLError("Argument \"".concat(name, "\" of required type \"").concat((0, _inspect.default)(argType), "\" ") + 'was not provided.', node);
       }
-    } else if (hasValue) {
-      if (argumentNode.value.kind === _kinds.Kind.NULL) {
-        // If the explicit value `null` was provided, an entry in the coerced
-        // values must exist as the value `null`.
-        coercedValues[name] = null;
-      } else if (argumentNode.value.kind === _kinds.Kind.VARIABLE) {
-        var _variableName2 = argumentNode.value.name.value;
-        !variableValues ? (0, _invariant.default)(0, 'Must exist for hasValue to be true.') : void 0; // Note: This does no further checking that this variable is correct.
-        // This assumes that this query has been validated and the variable
-        // usage here is of the correct type.
-
-        coercedValues[name] = variableValues[_variableName2];
-      } else {
-        var valueNode = argumentNode.value;
-        var coercedValue = (0, _valueFromAST.valueFromAST)(valueNode, argType, variableValues);
-
-        if (coercedValue === undefined) {
-          // Note: ValuesOfCorrectType validation should catch this before
-          // execution. This is a runtime check to ensure execution does not
-          // continue with an invalid argument value.
-          throw new _GraphQLError.GraphQLError("Argument \"".concat(name, "\" has invalid value ").concat((0, _printer.print)(valueNode), "."), argumentNode.value);
+
+      continue;
+    }
+
+    var valueNode = argumentNode.value;
+    var isNull = valueNode.kind === _kinds.Kind.NULL;
+
+    if (valueNode.kind === _kinds.Kind.VARIABLE) {
+      var variableName = valueNode.name.value;
+
+      if (variableValues == null || !hasOwnProperty(variableValues, variableName)) {
+        if (argDef.defaultValue !== undefined) {
+          coercedValues[name] = argDef.defaultValue;
+        } else if ((0, _definition.isNonNullType)(argType)) {
+          throw new _GraphQLError.GraphQLError("Argument \"".concat(name, "\" of required type \"").concat((0, _inspect.default)(argType), "\" ") + "was provided the variable \"$".concat(variableName, "\" which was not provided a runtime value."), valueNode);
         }
 
-        coercedValues[name] = coercedValue;
+        continue;
       }
+
+      isNull = variableValues[variableName] == null;
+    }
+
+    if (isNull && (0, _definition.isNonNullType)(argType)) {
+      throw new _GraphQLError.GraphQLError("Argument \"".concat(name, "\" of non-null type \"").concat((0, _inspect.default)(argType), "\" ") + 'must not be null.', valueNode);
     }
+
+    var coercedValue = (0, _valueFromAST.valueFromAST)(valueNode, argType, variableValues);
+
+    if (coercedValue === undefined) {
+      // Note: ValuesOfCorrectType validation should catch this before
+      // execution. This is a runtime check to ensure execution does not
+      // continue with an invalid argument value.
+      throw new _GraphQLError.GraphQLError("Argument \"".concat(name, "\" has invalid value ").concat((0, _printer.print)(valueNode), "."), valueNode);
+    }
+
+    coercedValues[name] = coercedValue;
   }
 
   return coercedValues;

package/execution/values.js.flow

@@ -1,33 +1,37 @@
 // @flow strict
 
 import find from '../polyfills/find';
-import { GraphQLError } from '../error/GraphQLError';
-import inspect from '../jsutils/inspect';
-import invariant from '../jsutils/invariant';
+
 import keyMap from '../jsutils/keyMap';
-import { coerceValue } from '../utilities/coerceValue';
-import { typeFromAST } from '../utilities/typeFromAST';
-import { valueFromAST } from '../utilities/valueFromAST';
+import inspect from '../jsutils/inspect';
+import { type ObjMap } from '../jsutils/ObjMap';
+import printPathArray from '../jsutils/printPathArray';
+
+import { GraphQLError } from '../error/GraphQLError';
+
 import { Kind } from '../language/kinds';
 import { print } from '../language/printer';
-import {
-  type GraphQLField,
-  isInputType,
-  isNonNullType,
-} from '../type/definition';
-import { type GraphQLDirective } from '../type/directives';
-import { type ObjMap } from '../jsutils/ObjMap';
-import { type GraphQLSchema } from '../type/schema';
 import {
   type FieldNode,
   type DirectiveNode,
   type VariableDefinitionNode,
 } from '../language/ast';
 
-type CoercedVariableValues = {|
-  errors: $ReadOnlyArray<GraphQLError> | void,
-  coerced: { [variable: string]: mixed, ... } | void,
-|};
+import { type GraphQLSchema } from '../type/schema';
+import { type GraphQLDirective } from '../type/directives';
+import {
+  type GraphQLField,
+  isInputType,
+  isNonNullType,
+} from '../type/definition';
+
+import { typeFromAST } from '../utilities/typeFromAST';
+import { valueFromAST } from '../utilities/valueFromAST';
+import { coerceInputValue } from '../utilities/coerceInputValue';
+
+type CoercedVariableValues =
+  | {| errors: $ReadOnlyArray<GraphQLError> |}
+  | {| coerced: { [variable: string]: mixed, ... } |};
 
 /**
  * Prepares an object map of variableValues of the correct type based on the
@@ -42,72 +46,106 @@ export function getVariableValues(
   schema: GraphQLSchema,
   varDefNodes: $ReadOnlyArray<VariableDefinitionNode>,
   inputs: { +[variable: string]: mixed, ... },
+  options?: {| maxErrors?: number |},
 ): CoercedVariableValues {
+  const maxErrors = options && options.maxErrors;
   const errors = [];
+  try {
+    const coerced = coerceVariableValues(schema, varDefNodes, inputs, error => {
+      if (maxErrors != null && errors.length >= maxErrors) {
+        throw new GraphQLError(
+          'Too many errors processing variables, error limit reached. Execution aborted.',
+        );
+      }
+      errors.push(error);
+    });
+
+    if (errors.length === 0) {
+      return { coerced };
+    }
+  } catch (error) {
+    errors.push(error);
+  }
+
+  return { errors };
+}
+
+function coerceVariableValues(
+  schema: GraphQLSchema,
+  varDefNodes: $ReadOnlyArray<VariableDefinitionNode>,
+  inputs: { +[variable: string]: mixed, ... },
+  onError: GraphQLError => void,
+): { [variable: string]: mixed, ... } {
   const coercedValues = {};
-  for (let i = 0; i < varDefNodes.length; i++) {
-    const varDefNode = varDefNodes[i];
+  for (const varDefNode of varDefNodes) {
     const varName = varDefNode.variable.name.value;
     const varType = typeFromAST(schema, varDefNode.type);
     if (!isInputType(varType)) {
       // Must use input types for variables. This should be caught during
       // validation, however is checked again here for safety.
-      errors.push(
+      const varTypeStr = print(varDefNode.type);
+      onError(
         new GraphQLError(
-          `Variable "$${varName}" expected value of type ` +
-            `"${print(
-              varDefNode.type,
-            )}" which cannot be used as an input type.`,
+          `Variable "$${varName}" expected value of type "${varTypeStr}" which cannot be used as an input type.`,
           varDefNode.type,
         ),
       );
-    } else {
-      const hasValue = hasOwnProperty(inputs, varName);
-      const value = hasValue ? inputs[varName] : undefined;
-      if (!hasValue && varDefNode.defaultValue) {
-        // If no value was provided to a variable with a default value,
-        // use the default value.
+      continue;
+    }
+
+    if (!hasOwnProperty(inputs, varName)) {
+      if (varDefNode.defaultValue) {
         coercedValues[varName] = valueFromAST(varDefNode.defaultValue, varType);
-      } else if ((!hasValue || value === null) && isNonNullType(varType)) {
-        // If no value or a nullish value was provided to a variable with a
-        // non-null type (required), produce an error.
-        errors.push(
+      }
+
+      if (isNonNullType(varType)) {
+        const varTypeStr = inspect(varType);
+        onError(
           new GraphQLError(
-            hasValue
-              ? `Variable "$${varName}" of non-null type ` +
-                `"${inspect(varType)}" must not be null.`
-              : `Variable "$${varName}" of required type ` +
-                `"${inspect(varType)}" was not provided.`,
+            `Variable "$${varName}" of required type "${varTypeStr}" was not provided.`,
             varDefNode,
           ),
         );
-      } else if (hasValue) {
-        if (value === null) {
-          // If the explicit value `null` was provided, an entry in the coerced
-          // values must exist as the value `null`.
-          coercedValues[varName] = null;
-        } else {
-          // Otherwise, a non-null value was provided, coerce it to the expected
-          // type or report an error if coercion fails.
-          const coerced = coerceValue(value, varType, varDefNode);
-          const coercionErrors = coerced.errors;
-          if (coercionErrors) {
-            for (const error of coercionErrors) {
-              error.message =
-                `Variable "$${varName}" got invalid value ${inspect(value)}; ` +
-                error.message;
-            }
-            errors.push(...coercionErrors);
-          } else {
-            coercedValues[varName] = coerced.value;
-          }
-        }
       }
+      continue;
     }
+
+    const value = inputs[varName];
+    if (value === null && isNonNullType(varType)) {
+      const varTypeStr = inspect(varType);
+      onError(
+        new GraphQLError(
+          `Variable "$${varName}" of non-null type "${varTypeStr}" must not be null.`,
+          varDefNode,
+        ),
+      );
+      continue;
+    }
+
+    coercedValues[varName] = coerceInputValue(
+      value,
+      varType,
+      (path, invalidValue, error) => {
+        let prefix =
+          `Variable "$${varName}" got invalid value ` + inspect(invalidValue);
+        if (path.length > 0) {
+          prefix += ` at "${varName}${printPathArray(path)}"`;
+        }
+        onError(
+          new GraphQLError(
+            prefix + '; ' + error.message,
+            varDefNode,
+            undefined,
+            undefined,
+            undefined,
+            error.originalError,
+          ),
+        );
+      },
+    );
   }
-  return errors.length === 0
-    ? { errors: undefined, coerced: coercedValues }
-    : { errors, coerced: undefined };
+
+  return coercedValues;
 }
 
 /**
@@ -119,88 +157,73 @@ export function getVariableValues(
  * Object prototype.
  */
 export function getArgumentValues(
-  def: GraphQLField<*, *> | GraphQLDirective,
+  def: GraphQLField<mixed, mixed> | GraphQLDirective,
   node: FieldNode | DirectiveNode,
   variableValues?: ?ObjMap<mixed>,
 ): { [argument: string]: mixed, ... } {
   const coercedValues = {};
-  const argDefs = def.args;
-  const argNodes = node.arguments;
-  if (!argDefs || !argNodes) {
-    return coercedValues;
-  }
-  const argNodeMap = keyMap(argNodes, arg => arg.name.value);
-  for (let i = 0; i < argDefs.length; i++) {
-    const argDef = argDefs[i];
+  const argNodeMap = keyMap(node.arguments || [], arg => arg.name.value);
+
+  for (const argDef of def.args) {
     const name = argDef.name;
     const argType = argDef.type;
     const argumentNode = argNodeMap[name];
-    let hasValue;
-    let isNull;
-    if (argumentNode && argumentNode.value.kind === Kind.VARIABLE) {
-      const variableName = argumentNode.value.name.value;
-      hasValue =
-        variableValues != null && hasOwnProperty(variableValues, variableName);
-      isNull = variableValues != null && variableValues[variableName] === null;
-    } else {
-      hasValue = argumentNode != null;
-      isNull = argumentNode != null && argumentNode.value.kind === Kind.NULL;
-    }
 
-    if (!hasValue && argDef.defaultValue !== undefined) {
-      // If no argument was provided where the definition has a default value,
-      // use the default value.
-      coercedValues[name] = argDef.defaultValue;
-    } else if ((!hasValue || isNull) && isNonNullType(argType)) {
-      // If no argument or a null value was provided to an argument with a
-      // non-null type (required), produce a field error.
-      if (isNull) {
-        throw new GraphQLError(
-          `Argument "${name}" of non-null type "${inspect(argType)}" ` +
-            'must not be null.',
-          argumentNode.value,
-        );
-      } else if (argumentNode && argumentNode.value.kind === Kind.VARIABLE) {
-        const variableName = argumentNode.value.name.value;
-        throw new GraphQLError(
-          `Argument "${name}" of required type "${inspect(argType)}" ` +
-            `was provided the variable "$${variableName}" which was not provided a runtime value.`,
-          argumentNode.value,
-        );
-      } else {
+    if (!argumentNode) {
+      if (argDef.defaultValue !== undefined) {
+        coercedValues[name] = argDef.defaultValue;
+      } else if (isNonNullType(argType)) {
         throw new GraphQLError(
           `Argument "${name}" of required type "${inspect(argType)}" ` +
             'was not provided.',
           node,
         );
       }
-    } else if (hasValue) {
-      if (argumentNode.value.kind === Kind.NULL) {
-        // If the explicit value `null` was provided, an entry in the coerced
-        // values must exist as the value `null`.
-        coercedValues[name] = null;
-      } else if (argumentNode.value.kind === Kind.VARIABLE) {
-        const variableName = argumentNode.value.name.value;
-        invariant(variableValues, 'Must exist for hasValue to be true.');
-        // Note: This does no further checking that this variable is correct.
-        // This assumes that this query has been validated and the variable
-        // usage here is of the correct type.
-        coercedValues[name] = variableValues[variableName];
-      } else {
-        const valueNode = argumentNode.value;
-        const coercedValue = valueFromAST(valueNode, argType, variableValues);
-        if (coercedValue === undefined) {
-          // Note: ValuesOfCorrectType validation should catch this before
-          // execution. This is a runtime check to ensure execution does not
-          // continue with an invalid argument value.
+      continue;
+    }
+
+    const valueNode = argumentNode.value;
+    let isNull = valueNode.kind === Kind.NULL;
+
+    if (valueNode.kind === Kind.VARIABLE) {
+      const variableName = valueNode.name.value;
+      if (
+        variableValues == null ||
+        !hasOwnProperty(variableValues, variableName)
+      ) {
+        if (argDef.defaultValue !== undefined) {
+          coercedValues[name] = argDef.defaultValue;
+        } else if (isNonNullType(argType)) {
           throw new GraphQLError(
-            `Argument "${name}" has invalid value ${print(valueNode)}.`,
-            argumentNode.value,
+            `Argument "${name}" of required type "${inspect(argType)}" ` +
+              `was provided the variable "$${variableName}" which was not provided a runtime value.`,
+            valueNode,
           );
         }
-        coercedValues[name] = coercedValue;
+        continue;
       }
+      isNull = variableValues[variableName] == null;
+    }
+
+    if (isNull && isNonNullType(argType)) {
+      throw new GraphQLError(
+        `Argument "${name}" of non-null type "${inspect(argType)}" ` +
+          'must not be null.',
+        valueNode,
+      );
+    }
+
+    const coercedValue = valueFromAST(valueNode, argType, variableValues);
+    if (coercedValue === undefined) {
+      // Note: ValuesOfCorrectType validation should catch this before
+      // execution. This is a runtime check to ensure execution does not
+      // continue with an invalid argument value.
+      throw new GraphQLError(
+        `Argument "${name}" has invalid value ${print(valueNode)}.`,
+        valueNode,
+      );
     }
+    coercedValues[name] = coercedValue;
   }
   return coercedValues;
 }