handle null values in valueFromAST

Author: langpavel

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/utilities/valueFromAST.js

@@ -42,6 +42,7 @@ import type {
  * | String               | String        |
  * | Int / Float          | Number        |
  * | Enum Value           | Mixed         |
+ * | NullValue            | null          |
  *
  */
 export function valueFromAST(
@@ -57,13 +58,17 @@ export function valueFromAST(
   }
 
   if (!valueAST) {
+    return;
+  }
+
+  if (valueAST.kind === Kind.NULL) {
     return null;
   }
 
   if (valueAST.kind === Kind.VARIABLE) {
     const variableName = (valueAST: Variable).name.value;
     if (!variables || !variables.hasOwnProperty(variableName)) {
-      return null;
+      return;
     }
     // Note: we're not doing any checking that this variable is correct. We're
     // assuming that this query has been validated and the variable usage here
@@ -83,7 +88,7 @@ export function valueFromAST(
 
   if (type instanceof GraphQLInputObjectType) {
     if (valueAST.kind !== Kind.OBJECT) {
-      return null;
+      return;
     }
     const fields = type.getFields();
     const fieldASTs = keyMap(
@@ -93,13 +98,14 @@ export function valueFromAST(
     return Object.keys(fields).reduce((obj, fieldName) => {
       const field = fields[fieldName];
       const fieldAST = fieldASTs[fieldName];
-      let fieldValue =
+      const fieldValue =
         valueFromAST(fieldAST && fieldAST.value, field.type, variables);
-      if (isNullish(fieldValue)) {
-        fieldValue = field.defaultValue;
-      }
-      if (!isNullish(fieldValue)) {
+      if (fieldValue === null) {
+        obj[fieldName] = fieldValue;
+      } else if (!isNullish(fieldValue)) {
         obj[fieldName] = fieldValue;
+      } else if (fieldValue !== null) {
+        obj[fieldName] = field.defaultValue;
       }
       return obj;
     }, {});
@@ -111,6 +117,7 @@ export function valueFromAST(
   );
 
   const parsed = type.parseLiteral(valueAST);
+  // TODO: Should be this condition ommited?
   if (!isNullish(parsed)) {
     return parsed;
   }