language support for NullValue

src/execution/__tests__/variables-test.js

@@ -159,6 +159,36 @@ describe('Execute: Handles inputs', () => {
         });
       });
 
+      it('properly parses null value to null', async () => {
+        const doc = `
+        {
+          fieldWithObjectInput(input: {a: null, b: null, c: "C", d: null})
+        }
+        `;
+        const ast = parse(doc);
+
+        return expect(await execute(schema, ast)).to.deep.equal({
+          data: {
+            fieldWithObjectInput: '{"a":null,"b":null,"c":"C","d":null}'
+          }
+        });
+      });
+
+      it('properly parses null value in list', async () => {
+        const doc = `
+        {
+          fieldWithObjectInput(input: {b: ["A",null,"C"], c: "C"})
+        }
+        `;
+        const ast = parse(doc);
+
+        return expect(await execute(schema, ast)).to.deep.equal({
+          data: {
+            fieldWithObjectInput: '{"b":["A",null,"C"],"c":"C"}'
+          }
+        });
+      });
+
       it('does not use incorrect value', async () => {
         const doc = `
         {

src/execution/values.js

@@ -13,6 +13,7 @@ import { forEach, isCollection } from 'iterall';
 import { GraphQLError } from '../error';
 import invariant from '../jsutils/invariant';
 import isNullish from '../jsutils/isNullish';
+import isInvalid from '../jsutils/isInvalid';
 import keyMap from '../jsutils/keyMap';
 import { typeFromAST } from '../utilities/typeFromAST';
 import { valueFromAST } from '../utilities/valueFromAST';
@@ -66,10 +67,10 @@ export function getArgumentValues(
     const name = argDef.name;
     const valueAST = argASTMap[name] ? argASTMap[name].value : null;
     let value = valueFromAST(valueAST, argDef.type, variableValues);
-    if (isNullish(value)) {
+    if (isInvalid(value)) {
       value = argDef.defaultValue;
     }
-    if (!isNullish(value)) {
+    if (!isInvalid(value)) {
       result[name] = value;
     }
     return result;
@@ -98,7 +99,7 @@ function getVariableValue(
   const inputType = ((type: any): GraphQLInputType);
   const errors = isValidJSValue(input, inputType);
   if (!errors.length) {
-    if (isNullish(input)) {
+    if (isInvalid(input)) {
       const defaultValue = definitionAST.defaultValue;
       if (defaultValue) {
         return valueFromAST(defaultValue, inputType);
@@ -134,10 +135,14 @@ function coerceValue(type: GraphQLInputType, value: mixed): mixed {
     return coerceValue(type.ofType, _value);
   }
 
-  if (isNullish(_value)) {
+  if (_value === null) {
     return null;
   }
 
+  if (isInvalid(_value)) {
+    return undefined;
+  }
+
   if (type instanceof GraphQLList) {
     const itemType = type.ofType;
     if (isCollection(_value)) {
@@ -158,10 +163,10 @@ function coerceValue(type: GraphQLInputType, value: mixed): mixed {
     return Object.keys(fields).reduce((obj, fieldName) => {
       const field = fields[fieldName];
       let fieldValue = coerceValue(field.type, _value[fieldName]);
-      if (isNullish(fieldValue)) {
+      if (isInvalid(fieldValue)) {
         fieldValue = field.defaultValue;
       }
-      if (!isNullish(fieldValue)) {
+      if (!isInvalid(fieldValue)) {
         obj[fieldName] = fieldValue;
       }
       return obj;

src/jsutils/isInvalid.js

@@ -0,0 +1,16 @@
+/* @flow */
+/**
+ *  Copyright (c) 2015, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+/**
+ * Returns true if a value is null, undefined, or NaN.
+ */
+export default function isInvalid(value: mixed): boolean {
+  return value === undefined || value !== value;
+}

src/language/__tests__/kitchen-sink.graphql

@@ -52,6 +52,6 @@ fragment frag on Friend {
 }
 
 {
-  unnamed(truthy: true, falsey: false),
+  unnamed(truthy: true, falsey: false, nullish: null),
   query
 }

src/language/__tests__/parser-test.js

@@ -91,12 +91,6 @@ fragment MissingOn Type
     ).to.throw('Syntax Error GraphQL (1:9) Expected Name, found }');
   });
 
-  it('does not allow null as value', async () => {
-    expect(
-      () => parse('{ fieldWithNullableStringInput(input: null) }')
-    ).to.throw('Syntax Error GraphQL (1:39) Unexpected Name "null"');
-  });
-
   it('parses multi-byte characters', async () => {
     // Note: \u0A0A could be naively interpretted as two line-feed chars.
     expect(
@@ -296,6 +290,13 @@ fragment ${fragmentName} on Type {
 
   describe('parseValue', () => {
 
+    it('parses null value', () => {
+      expect(parseValue('null')).to.containSubset({
+        kind: Kind.NULL,
+        loc: { start: 0, end: 4 }
+      });
+    });
+
     it('parses list values', () => {
       expect(parseValue('[123 "abc"]')).to.containSubset({
         kind: Kind.LIST,

src/language/__tests__/printer-test.js

@@ -132,7 +132,7 @@ fragment frag on Friend {
 }
 
 {
-  unnamed(truthy: true, falsey: false)
+  unnamed(truthy: true, falsey: false, nullish: null)
   query
 }
 `);

src/language/__tests__/schema-kitchen-sink.graphql

@@ -17,6 +17,7 @@ type Foo implements Bar {
   four(argument: String = "string"): String
   five(argument: [String] = ["string", "string"]): String
   six(argument: InputType = {key: "value"}): Type
+  seven(argument: Int = null): Type
 }
 
 type AnnotatedObject @onObject(arg: "value") {

src/language/__tests__/schema-printer-test.js

@@ -63,6 +63,7 @@ type Foo implements Bar {
   four(argument: String = "string"): String
   five(argument: [String] = ["string", "string"]): String
   six(argument: InputType = {key: "value"}): Type
+  seven(argument: Int = null): Type
 }
 
 type AnnotatedObject @onObject(arg: "value") {

src/language/__tests__/visitor-test.js

@@ -614,6 +614,12 @@ describe('Visitor', () => {
       [ 'enter', 'BooleanValue', 'value', 'Argument' ],
       [ 'leave', 'BooleanValue', 'value', 'Argument' ],
       [ 'leave', 'Argument', 1, undefined ],
+      [ 'enter', 'Argument', 2, undefined ],
+      [ 'enter', 'Name', 'name', 'Argument' ],
+      [ 'leave', 'Name', 'name', 'Argument' ],
+      [ 'enter', 'NullValue', 'value', 'Argument' ],
+      [ 'leave', 'NullValue', 'value', 'Argument' ],
+      [ 'leave', 'Argument', 2, undefined ],
       [ 'leave', 'Field', 0, undefined ],
       [ 'enter', 'Field', 1, undefined ],
       [ 'enter', 'Name', 'name', 'Field' ],

src/language/ast.js

@@ -126,6 +126,7 @@ export type Node =
   | FloatValue
   | StringValue
   | BooleanValue
+  | NullValue
   | EnumValue
   | ListValue
   | ObjectValue
@@ -260,6 +261,7 @@ export type Value =
   | FloatValue
   | StringValue
   | BooleanValue
+  | NullValue
   | EnumValue
   | ListValue
   | ObjectValue;
@@ -288,6 +290,11 @@ export type BooleanValue = {
   value: boolean;
 };
 
+export type NullValue = {
+  kind: 'NullValue';
+  loc?: Location;
+};
+
 export type EnumValue = {
   kind: 'EnumValue';
   loc?: Location;

src/language/kinds.js

@@ -34,6 +34,7 @@ export const INT = 'IntValue';
 export const FLOAT = 'FloatValue';
 export const STRING = 'StringValue';
 export const BOOLEAN = 'BooleanValue';
+export const NULL = 'NullValue';
 export const ENUM = 'EnumValue';
 export const LIST = 'ListValue';
 export const OBJECT = 'ObjectValue';

src/language/parser.js

@@ -89,6 +89,7 @@ import {
   FLOAT,
   STRING,
   BOOLEAN,
+  NULL,
   ENUM,
   LIST,
   OBJECT,
@@ -503,12 +504,15 @@ function parseFragmentName(lexer: Lexer<*>): Name {
  *   - FloatValue
  *   - StringValue
  *   - BooleanValue
+ *   - NullValue
  *   - EnumValue
  *   - ListValue[?Const]
  *   - ObjectValue[?Const]
  *
  * BooleanValue : one of `true` `false`
  *
+ * NullValue : `null`
+ *
  * EnumValue : Name but not `true`, `false` or `null`
  */
 function parseValueLiteral(lexer: Lexer<*>, isConst: boolean): Value {
@@ -547,15 +551,19 @@ function parseValueLiteral(lexer: Lexer<*>, isConst: boolean): Value {
           value: token.value === 'true',
           loc: loc(lexer, token)
         };
-      } else if (token.value !== 'null') {
+      } else if (token.value === 'null') {
         lexer.advance();
         return {
-          kind: (ENUM: 'EnumValue'),
-          value: ((token.value: any): string),
+          kind: (NULL: 'NullValue'),
           loc: loc(lexer, token)
         };
       }
-      break;
+      lexer.advance();
+      return {
+        kind: (ENUM: 'EnumValue'),
+        value: ((token.value: any): string),
+        loc: loc(lexer, token)
+      };
     case TokenKind.DOLLAR:
       if (!isConst) {
         return parseVariable(lexer);

src/language/printer.js

@@ -76,6 +76,7 @@ const printDocASTReducer = {
   FloatValue: ({ value }) => value,
   StringValue: ({ value }) => JSON.stringify(value),
   BooleanValue: ({ value }) => JSON.stringify(value),
+  NullValue: () => 'null',
   EnumValue: ({ value }) => value,
   ListValue: ({ values }) => '[' + join(values, ', ') + ']',
   ObjectValue: ({ fields }) => '{' + join(fields, ', ') + '}',

src/language/visitor.js

@@ -27,6 +27,7 @@ export const QueryDocumentKeys = {
   FloatValue: [],
   StringValue: [],
   BooleanValue: [],
+  NullValue: [],
   EnumValue: [],
   ListValue: [ 'values' ],
   ObjectValue: [ 'fields' ],

src/type/definition.js

@@ -446,7 +446,7 @@ function defineFieldMap(
           name: argName,
           description: arg.description === undefined ? null : arg.description,
           type: arg.type,
-          defaultValue: arg.defaultValue === undefined ? null : arg.defaultValue
+          defaultValue: arg.defaultValue
         };
       });
     }

src/type/directives.js

@@ -84,7 +84,7 @@ export class GraphQLDirective {
           name: argName,
           description: arg.description === undefined ? null : arg.description,
           type: arg.type,
-          defaultValue: arg.defaultValue === undefined ? null : arg.defaultValue
+          defaultValue: arg.defaultValue
         };
       });
     }

src/utilities/__tests__/astFromValue-test.js

@@ -19,6 +19,7 @@ import {
   GraphQLString,
   GraphQLBoolean,
   GraphQLID,
+  GraphQLNonNull,
 } from '../../type';
 
 
@@ -33,17 +34,26 @@ describe('astFromValue', () => {
       { kind: 'BooleanValue', value: false }
     );
 
-    expect(astFromValue(null, GraphQLBoolean)).to.deep.equal(
+    expect(astFromValue(undefined, GraphQLBoolean)).to.deep.equal(
       null
     );
 
+    expect(astFromValue(null, GraphQLBoolean)).to.deep.equal(
+      { kind: 'NullValue' }
+    );
+
     expect(astFromValue(0, GraphQLBoolean)).to.deep.equal(
       { kind: 'BooleanValue', value: false }
     );
 
     expect(astFromValue(1, GraphQLBoolean)).to.deep.equal(
       { kind: 'BooleanValue', value: true }
     );
+
+    const NonNullBoolean = new GraphQLNonNull(GraphQLBoolean);
+    expect(astFromValue(0, NonNullBoolean)).to.deep.equal(
+      { kind: 'BooleanValue', value: false }
+    );
   });
 
   it('converts Int values to Int ASTs', () => {
@@ -105,6 +115,10 @@ describe('astFromValue', () => {
     );
 
     expect(astFromValue(null, GraphQLString)).to.deep.equal(
+      { kind: 'NullValue' }
+    );
+
+    expect(astFromValue(undefined, GraphQLString)).to.deep.equal(
       null
     );
   });
@@ -133,6 +147,17 @@ describe('astFromValue', () => {
     );
 
     expect(astFromValue(null, GraphQLID)).to.deep.equal(
+      { kind: 'NullValue' }
+    );
+
+    expect(astFromValue(undefined, GraphQLID)).to.deep.equal(
+      null
+    );
+  });
+
+  it('does not converts NonNull values to NullValue', () => {
+    const NonNullBoolean = new GraphQLNonNull(GraphQLBoolean);
+    expect(astFromValue(null, NonNullBoolean)).to.deep.equal(
       null
     );
   });
@@ -220,4 +245,26 @@ describe('astFromValue', () => {
             value: { kind: 'EnumValue', value: 'HELLO' } } ] }
     );
   });
+
+  it('converts input objects with explicit nulls', () => {
+    const inputObj = new GraphQLInputObjectType({
+      name: 'MyInputObj',
+      fields: {
+        foo: { type: GraphQLFloat },
+        bar: { type: myEnum },
+      }
+    });
+
+    expect(astFromValue(
+      { foo: null },
+      inputObj
+    )).to.deep.equal(
+      { kind: 'ObjectValue',
+        fields: [
+          { kind: 'ObjectField',
+            name: { kind: 'Name', value: 'foo' },
+            value: { kind: 'NullValue' } } ] }
+    );
+  });
+
 });