graphql 14.4.2 → 14.5.3

package/execution/values.mjs

@@ -1,14 +1,14 @@
 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 printPathArray from '../jsutils/printPathArray';
+import { GraphQLError } from '../error/GraphQLError';
 import { Kind } from '../language/kinds';
 import { print } from '../language/printer';
 import { isInputType, isNonNullType } from '../type/definition';
+import { typeFromAST } from '../utilities/typeFromAST';
+import { valueFromAST } from '../utilities/valueFromAST';
+import { coerceInputValue } from '../utilities/coerceInputValue';
 
 /**
  * Prepares an object map of variableValues of the correct type based on the
@@ -19,83 +19,90 @@ import { isInputType, isNonNullType } from '../type/definition';
  * exposed to user code. Care should be taken to not pull values from the
  * Object prototype.
  */
-export function getVariableValues(schema, varDefNodes, inputs) {
+export 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('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 = 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(new GraphQLError("Variable \"$".concat(varName, "\" expected value of type ") + "\"".concat(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 = print(varDefNode.type);
+      onError(new 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] = 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(new GraphQLError(hasValue ? "Variable \"$".concat(varName, "\" of non-null type ") + "\"".concat(inspect(varType), "\" must not be null.") : "Variable \"$".concat(varName, "\" of required type ") + "\"".concat(inspect(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 = 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(inspect(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 (isNonNullType(varType)) {
+        var _varTypeStr = inspect(varType);
+
+        onError(new 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 && isNonNullType(varType)) {
+      var _varTypeStr2 = inspect(varType);
+
+      onError(new GraphQLError("Variable \"$".concat(varName, "\" of non-null type \"").concat(_varTypeStr2, "\" must not be null."), varDefNode));
+      return "continue";
+    }
+
+    coercedValues[varName] = coerceInputValue(value, varType, function (path, invalidValue, error) {
+      var prefix = "Variable \"$".concat(varName, "\" got invalid value ") + inspect(invalidValue);
+
+      if (path.length > 0) {
+        prefix += " at \"".concat(varName).concat(printPathArray(path), "\"");
+      }
+
+      onError(new 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
@@ -106,77 +113,62 @@ export function getVariableValues(schema, varDefNodes, inputs) {
  * Object prototype.
  */
 
+
 export function getArgumentValues(def, node, variableValues) {
   var coercedValues = {};
-  var argDefs = def.args;
-  var argNodes = node.arguments;
-
-  if (!argDefs || !argNodes) {
-    return coercedValues;
-  }
-
-  var argNodeMap = keyMap(argNodes, function (arg) {
+  var argNodeMap = keyMap(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 === 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 === 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 \"".concat(name, "\" of non-null type \"").concat(inspect(argType), "\" ") + 'must not be null.', argumentNode.value);
-      } else if (argumentNode && argumentNode.value.kind === Kind.VARIABLE) {
-        var _variableName = argumentNode.value.name.value;
-        throw new GraphQLError("Argument \"".concat(name, "\" of required type \"").concat(inspect(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 (isNonNullType(argType)) {
         throw new GraphQLError("Argument \"".concat(name, "\" of required type \"").concat(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) {
-        var _variableName2 = argumentNode.value.name.value;
-        !variableValues ? invariant(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 = 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 \"".concat(name, "\" has invalid value ").concat(print(valueNode), "."), argumentNode.value);
+
+      continue;
+    }
+
+    var valueNode = argumentNode.value;
+    var isNull = valueNode.kind === Kind.NULL;
+
+    if (valueNode.kind === Kind.VARIABLE) {
+      var 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 \"".concat(name, "\" of required type \"").concat(inspect(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 && isNonNullType(argType)) {
+      throw new GraphQLError("Argument \"".concat(name, "\" of non-null type \"").concat(inspect(argType), "\" ") + 'must not be null.', valueNode);
+    }
+
+    var 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 \"".concat(name, "\" has invalid value ").concat(print(valueNode), "."), valueNode);
+    }
+
+    coercedValues[name] = coercedValue;
   }
 
   return coercedValues;

package/graphql.d.ts

@@ -0,0 +1,88 @@
+import Maybe from './tsutils/Maybe';
+import { Source } from './language/source';
+import { GraphQLSchema } from './type/schema';
+import { GraphQLFieldResolver, GraphQLTypeResolver } from './type/definition';
+import {
+  ExecutionResult,
+  ExecutionResultDataDefault,
+} from './execution/execute';
+
+/**
+ * This is the primary entry point function for fulfilling GraphQL operations
+ * by parsing, validating, and executing a GraphQL document along side a
+ * GraphQL schema.
+ *
+ * More sophisticated GraphQL servers, such as those which persist queries,
+ * may wish to separate the validation and execution phases to a static time
+ * tooling step, and a server runtime step.
+ *
+ * Accepts either an object with named arguments, or individual arguments:
+ *
+ * schema:
+ *    The GraphQL type system to use when validating and executing a query.
+ * source:
+ *    A GraphQL language formatted string representing the requested operation.
+ * rootValue:
+ *    The value provided as the first argument to resolver functions on the top
+ *    level type (e.g. the query object type).
+ * contextValue:
+ *    The context value is provided as an argument to resolver functions after
+ *    field arguments. It is used to pass shared information useful at any point
+ *    during executing this query, for example the currently logged in user and
+ *    connections to databases or other services.
+ * variableValues:
+ *    A mapping of variable name to runtime value to use for all variables
+ *    defined in the requestString.
+ * operationName:
+ *    The name of the operation to use if requestString contains multiple
+ *    possible operations. Can be omitted if requestString contains only
+ *    one operation.
+ * fieldResolver:
+ *    A resolver function to use when one is not provided by the schema.
+ *    If not provided, the default field resolver is used (which looks for a
+ *    value or method on the source value with the field's name).
+ */
+export interface GraphQLArgs {
+  schema: GraphQLSchema;
+  source: string | Source;
+  rootValue?: any;
+  contextValue?: any;
+  variableValues?: Maybe<{ [key: string]: any }>;
+  operationName?: Maybe<string>;
+  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
+}
+
+export function graphql<TData = ExecutionResultDataDefault>(
+  args: GraphQLArgs,
+): Promise<ExecutionResult<TData>>;
+export function graphql<TData = ExecutionResultDataDefault>(
+  schema: GraphQLSchema,
+  source: Source | string,
+  rootValue?: any,
+  contextValue?: any,
+  variableValues?: Maybe<{ [key: string]: any }>,
+  operationName?: Maybe<string>,
+  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>,
+  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>,
+): Promise<ExecutionResult<TData>>;
+
+/**
+ * The graphqlSync function also fulfills GraphQL operations by parsing,
+ * validating, and executing a GraphQL document along side a GraphQL schema.
+ * However, it guarantees to complete synchronously (or throw an error) assuming
+ * that all field resolvers are also synchronous.
+ */
+export function graphqlSync<TData = ExecutionResultDataDefault>(
+  args: GraphQLArgs,
+): ExecutionResult<TData>;
+export function graphqlSync<TData = ExecutionResultDataDefault>(
+  schema: GraphQLSchema,
+  source: Source | string,
+  rootValue?: any,
+  contextValue?: any,
+  variableValues?: Maybe<{ [key: string]: any }>,
+  operationName?: Maybe<string>,
+  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>,
+  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>,
+): ExecutionResult<TData>;

package/graphql.js

@@ -8,11 +8,11 @@ exports.graphqlSync = graphqlSync;
 
 var _isPromise = _interopRequireDefault(require("./jsutils/isPromise"));
 
-var _validate = require("./type/validate");
-
 var _parser = require("./language/parser");
 
-var _validate2 = require("./validation/validate");
+var _validate = require("./validation/validate");
+
+var _validate2 = require("./type/validate");
 
 var _execute = require("./execution/execute");
 
@@ -76,7 +76,7 @@ function graphqlImpl(args) {
       fieldResolver = args.fieldResolver,
       typeResolver = args.typeResolver; // Validate Schema
 
-  var schemaValidationErrors = (0, _validate.validateSchema)(schema);
+  var schemaValidationErrors = (0, _validate2.validateSchema)(schema);
 
   if (schemaValidationErrors.length > 0) {
     return {
@@ -96,7 +96,7 @@ function graphqlImpl(args) {
   } // Validate
 
 
-  var validationErrors = (0, _validate2.validate)(schema, document);
+  var validationErrors = (0, _validate.validate)(schema, document);
 
   if (validationErrors.length > 0) {
     return {

package/graphql.js.flow

@@ -1,17 +1,21 @@
 // @flow strict
 
 import isPromise from './jsutils/isPromise';
-import { validateSchema } from './type/validate';
+import { type PromiseOrValue } from './jsutils/PromiseOrValue';
+
 import { parse } from './language/parser';
-import { validate } from './validation/validate';
-import { type ExecutionResult, execute } from './execution/execute';
 import { type Source } from './language/source';
+
+import { validate } from './validation/validate';
+
+import { validateSchema } from './type/validate';
+import { type GraphQLSchema } from './type/schema';
 import {
   type GraphQLFieldResolver,
   type GraphQLTypeResolver,
 } from './type/definition';
-import { type GraphQLSchema } from './type/schema';
-import { type PromiseOrValue } from './jsutils/PromiseOrValue';
+
+import { type ExecutionResult, execute } from './execution/execute';
 
 /**
  * This is the primary entry point function for fulfilling GraphQL operations

package/graphql.mjs

@@ -1,8 +1,48 @@
 import isPromise from './jsutils/isPromise';
-import { validateSchema } from './type/validate';
 import { parse } from './language/parser';
 import { validate } from './validation/validate';
+import { validateSchema } from './type/validate';
 import { execute } from './execution/execute';
+/**
+ * This is the primary entry point function for fulfilling GraphQL operations
+ * by parsing, validating, and executing a GraphQL document along side a
+ * GraphQL schema.
+ *
+ * More sophisticated GraphQL servers, such as those which persist queries,
+ * may wish to separate the validation and execution phases to a static time
+ * tooling step, and a server runtime step.
+ *
+ * Accepts either an object with named arguments, or individual arguments:
+ *
+ * schema:
+ *    The GraphQL type system to use when validating and executing a query.
+ * source:
+ *    A GraphQL language formatted string representing the requested operation.
+ * rootValue:
+ *    The value provided as the first argument to resolver functions on the top
+ *    level type (e.g. the query object type).
+ * contextValue:
+ *    The context value is provided as an argument to resolver functions after
+ *    field arguments. It is used to pass shared information useful at any point
+ *    during executing this query, for example the currently logged in user and
+ *    connections to databases or other services.
+ * variableValues:
+ *    A mapping of variable name to runtime value to use for all variables
+ *    defined in the requestString.
+ * operationName:
+ *    The name of the operation to use if requestString contains multiple
+ *    possible operations. Can be omitted if requestString contains only
+ *    one operation.
+ * fieldResolver:
+ *    A resolver function to use when one is not provided by the schema.
+ *    If not provided, the default field resolver is used (which looks for a
+ *    value or method on the source value with the field's name).
+ * typeResolver:
+ *    A type resolver function to use when none is provided by the schema.
+ *    If not provided, the default type resolver is used (which looks for a
+ *    `__typename` field or alternatively calls the `isTypeOf` method).
+ */
+
 export function graphql(argsOrSchema, source, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) {
   var _arguments = arguments;