Adds isValidValue and isValidLiteral to Scalar and Enum types. (graphql#861)

leebyron · web-flow · commit 4b78d0d0be6d · 2017-05-18T15:52:08.000+02:00
Used for more semantically correct validity checking after graphql#848
diff --git a/src/type/definition.js b/src/type/definition.js
@@ -9,6 +9,7 @@
  */
 
 import invariant from '../jsutils/invariant';
+import isNullish from '../jsutils/isNullish';
 import { ENUM } from '../language/kinds';
 import { assertValidName } from '../utilities/assertValidName';
 import type {
@@ -323,16 +324,28 @@ export class GraphQLScalarType {
     return serializer(value);
   }
 
+  // Determines if an internal value is valid for this type.
+  // Equivalent to checking for if the parsedValue is nullish.
+  isValidValue(value: mixed): boolean {
+    return !isNullish(this.parseValue(value));
+  }
+
   // Parses an externally provided value to use as an input.
   parseValue(value: mixed): mixed {
     const parser = this._scalarConfig.parseValue;
-    return parser ? parser(value) : null;
+    return parser && !isNullish(value) ? parser(value) : undefined;
+  }
+
+  // Determines if an internal value is valid for this type.
+  // Equivalent to checking for if the parsedLiteral is nullish.
+  isValidLiteral(valueNode: ValueNode): boolean {
+    return !isNullish(this.parseLiteral(valueNode));
   }
 
   // Parses an externally provided literal value to use as an input.
   parseLiteral(valueNode: ValueNode): mixed {
     const parser = this._scalarConfig.parseLiteral;
-    return parser ? parser(valueNode) : null;
+    return parser ? parser(valueNode) : undefined;
   }
 
   toString(): string {
@@ -896,6 +909,11 @@ export class GraphQLEnumType/* <T> */ {
     return enumValue ? enumValue.name : null;
   }
 
+  isValidValue(value: mixed): boolean {
+    return typeof value === 'string' &&
+      this._getNameLookup()[value] !== undefined;
+  }
+
   parseValue(value: mixed): ?any/* T */ {
     if (typeof value === 'string') {
       const enumValue = this._getNameLookup()[value];
@@ -905,6 +923,11 @@ export class GraphQLEnumType/* <T> */ {
     }
   }
 
+  isValidLiteral(valueNode: ValueNode): boolean {
+    return valueNode.kind === ENUM &&
+      this._getNameLookup()[valueNode.value] !== undefined;
+  }
+
   parseLiteral(valueNode: ValueNode): ?any/* T */ {
     if (valueNode.kind === ENUM) {
       const enumValue = this._getNameLookup()[valueNode.value];
diff --git a/src/utilities/isValidJSValue.js b/src/utilities/isValidJSValue.js
@@ -95,7 +95,7 @@ export function isValidJSValue(
   // a non-null value.
   try {
     const parseResult = type.parseValue(value);
-    if (isNullish(parseResult)) {
+    if (isNullish(parseResult) && !type.isValidValue(value)) {
       return [
         `Expected type "${type.name}", found ${JSON.stringify(value)}.`
       ];
diff --git a/src/utilities/isValidLiteralValue.js b/src/utilities/isValidLiteralValue.js
@@ -30,7 +30,6 @@ import {
 import type { GraphQLInputType } from '../type/definition';
 import invariant from '../jsutils/invariant';
 import keyMap from '../jsutils/keyMap';
-import isNullish from '../jsutils/isNullish';
 
 
 /**
@@ -115,11 +114,8 @@ export function isValidLiteralValue(
     'Must be input type'
   );
 
-  // Scalars must parse to a non-null value, Enums may be null but must
-  // serialize back to a named value.
-  const parseResult = type.parseLiteral(valueNode);
-  if (type instanceof GraphQLEnumType ?
-      !type.serialize(parseResult) : isNullish(parseResult)) {
+  // Scalars determine if a literal values is valid.
+  if (!type.isValidLiteral(valueNode)) {
     return [ `Expected type "${type.name}", found ${print(valueNode)}.` ];
   }
 
diff --git a/src/utilities/valueFromAST.js b/src/utilities/valueFromAST.js
@@ -152,11 +152,9 @@ export function valueFromAST(
   );
 
   const parsed = type.parseLiteral(valueNode);
-  if (type instanceof GraphQLEnumType ?
-      !type.serialize(parsed) : isNullish(parsed)) {
-    // null or invalid values represent a failure to parse correctly (unless
-    // we have a legitimately null-valued Enum), in which case no value is
-    // returned.
+  if (isNullish(parsed) && !type.isValidLiteral(valueNode)) {
+    // Invalid values represent a failure to parse correctly, in which case
+    // no value is returned.
     return;
   }
 
