graphql-java#427 added null support but have not added optional arguments yet

Author: bbakerman

src/main/antlr/Graphql.g4

@@ -66,6 +66,7 @@ IntValue |
 FloatValue |
 StringValue |
 BooleanValue |
+NullValue |
 enumValue |
 arrayValue |
 objectValue;
@@ -76,6 +77,7 @@ IntValue |
 FloatValue |
 StringValue |
 BooleanValue |
+NullValue |
 enumValue |
 arrayValueWithVariable |
 objectValueWithVariable;
@@ -176,6 +178,8 @@ directiveLocations '|' directiveLocation
 
 BooleanValue: 'true' | 'false';
 
+NullValue: 'null';
+
 FRAGMENT: 'fragment';
 QUERY: 'query';
 MUTATION: 'mutation';

src/main/java/graphql/execution/ValuesResolver.java

@@ -129,6 +129,9 @@ private Object coerceValueAst(GraphQLType type, Value inputValue, Map<String, Ob
         if (inputValue instanceof VariableReference) {
             return variables.get(((VariableReference) inputValue).getName());
         }
+        if (inputValue instanceof NullValue) {
+            return null;
+        }
         if (type instanceof GraphQLScalarType) {
             return ((GraphQLScalarType) type).getCoercing().parseLiteral(inputValue);
         }

src/main/java/graphql/language/AstPrinter.java

@@ -26,6 +26,7 @@ public class AstPrinter {
         printers.put(Argument.class, argument());
         printers.put(ArrayValue.class, value());
         printers.put(BooleanValue.class, value());
+        printers.put(NullValue.class, value());
         printers.put(Directive.class, directive());
         printers.put(DirectiveDefinition.class, directiveDefinition());
         printers.put(DirectiveLocation.class, directiveLocation());
@@ -378,6 +379,8 @@ static private String value(Value value) {
             return valueOf(((EnumValue) value).getName());
         } else if (value instanceof BooleanValue) {
             return valueOf(((BooleanValue) value).isValue());
+        } else if (value instanceof NullValue) {
+            return "null";
         } else if (value instanceof ArrayValue) {
             return "[" + join(((ArrayValue) value).getValues(), ", ") + "]";
         } else if (value instanceof ObjectValue) {

src/main/java/graphql/language/NullValue.java

@@ -0,0 +1,33 @@
+package graphql.language;
+
+
+import java.util.Collections;
+import java.util.List;
+
+public class NullValue extends AbstractNode implements Value {
+
+    public static NullValue Null = new NullValue();
+
+    private NullValue() {
+    }
+
+    @Override
+    public List<Node> getChildren() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public boolean isEqualTo(Node o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        return true;
+
+    }
+
+    @Override
+    public String toString() {
+        return "NullValue{" +
+                '}';
+    }
+}

src/main/java/graphql/parser/GraphqlAntlrToLanguage.java

@@ -58,7 +58,10 @@
 import java.util.Deque;
 import java.util.List;
 
+import static graphql.language.NullValue.Null;
+
 @Internal
+
 public class GraphqlAntlrToLanguage extends GraphqlBaseVisitor<Void> {
 
     private final CommonTokenStream tokens;
@@ -668,6 +671,9 @@ private Value getValue(GraphqlParser.ValueWithVariableContext ctx) {
             BooleanValue booleanValue = new BooleanValue(Boolean.parseBoolean(ctx.BooleanValue().getText()));
             newNode(booleanValue, ctx);
             return booleanValue;
+        } else if (ctx.NullValue() != null) {
+            newNode(Null, ctx);
+            return Null;
         } else if (ctx.StringValue() != null) {
             StringValue stringValue = new StringValue(parseString(ctx.StringValue().getText()));
             newNode(stringValue, ctx);
@@ -713,6 +719,9 @@ private Value getValue(GraphqlParser.ValueContext ctx) {
             BooleanValue booleanValue = new BooleanValue(Boolean.parseBoolean(ctx.BooleanValue().getText()));
             newNode(booleanValue, ctx);
             return booleanValue;
+        } else if (ctx.NullValue() != null) {
+            newNode(Null, ctx);
+            return Null;
         } else if (ctx.StringValue() != null) {
             StringValue stringValue = new StringValue(parseString(ctx.StringValue().getText()));
             newNode(stringValue, ctx);

src/main/java/graphql/schema/idl/SchemaGenerator.java

@@ -13,6 +13,7 @@
 import graphql.language.IntValue;
 import graphql.language.InterfaceTypeDefinition;
 import graphql.language.Node;
+import graphql.language.NullValue;
 import graphql.language.ObjectTypeDefinition;
 import graphql.language.ObjectValue;
 import graphql.language.OperationTypeDefinition;
@@ -462,6 +463,8 @@ private Object buildValue(Value value) {
             result = arrayValue.getValues().stream().map(this::buildValue).toArray();
         } else if (value instanceof ObjectValue) {
             result = buildObjectValue((ObjectValue) value);
+        } else if (value instanceof NullValue) {
+            result = null;
         }
         return result;
 

src/main/java/graphql/validation/ValidationUtil.java

@@ -25,6 +25,9 @@ public boolean isValidLiteralValue(Value value, GraphQLType type) {
         if (value == null) {
             return !(type instanceof GraphQLNonNull);
         }
+        if (value instanceof NullValue) {
+            return !(type instanceof GraphQLNonNull);
+        }
         if (value instanceof VariableReference) {
             return true;
         }

src/test/groovy/graphql/execution/ValuesResolverTest.groovy

@@ -383,4 +383,26 @@ class ValuesResolverTest extends Specification {
         [intKey: 10]                      | _
         [intKey: 10, requiredField: null] | _
     }
+
+    def "getVariableValues: simple types with values not provided in variables map"() {
+        given:
+
+        def schema = TestUtil.schemaWithInputType(GraphQLString)
+        VariableDefinition fooVarDef = new VariableDefinition("foo", new TypeName("String"))
+        VariableDefinition barVarDef = new VariableDefinition("bar", new TypeName("String"))
+
+        when:
+        def resolvedValues = resolver.getVariableValues(schema, [fooVarDef, barVarDef], InputValue)
+
+        then:
+        resolvedValues == outputValue
+
+        where:
+        InputValue                || outputValue
+        [foo: "added", bar: null] || [foo: "added", bar: null]
+
+        // later this will be true once we apply missing value code
+        //[foo: "added"]            || [foo: "added"]
+    }
+
 }

src/test/groovy/graphql/language/AstPrinterTest.groovy

@@ -323,4 +323,53 @@ query HeroNameAndFriends($episode: Episode = "JEDI") {
 '''
     }
 
+//-------------------------------------------------
+    def "ast printing of null"() {
+        def query = '''
+query NullEpisodeQuery {
+  hero(episode: null) {
+    name
+  }
+}
+'''
+        def document = parse(query)
+        String output = printAst(document)
+
+        expect:
+        output == '''query NullEpisodeQuery {
+  hero(episode: null) {
+    name
+  }
+}
+'''
+    }
+
+    //-------------------------------------------------
+    def "ast printing of default variables with null"() {
+        def query = '''
+query NullVariableDefaultValueQuery($episode: Episode = null) {
+  hero(episode: $episode) {
+    name
+    friends {
+      name
+    }
+  }
+}
+'''
+        def document = parse(query)
+        String output = printAst(document)
+
+        expect:
+        output == '''query NullVariableDefaultValueQuery($episode: Episode = null) {
+  hero(episode: $episode) {
+    name
+    friends {
+      name
+    }
+  }
+}
+'''
+    }
+
+
 }

src/test/groovy/graphql/validation/ValidationUtilTest.groovy

@@ -39,6 +39,11 @@ class ValidationUtilTest extends Specification {
         !validationUtil.isValidLiteralValue(null, nonNull(GraphQLString))
     }
 
+    def "NullValue and NonNull is invalid"() {
+        expect:
+        !validationUtil.isValidLiteralValue(NullValue.Null, nonNull(GraphQLString))
+    }
+
     def "a nonNull value for a NonNull type is valid"() {
         expect:
         validationUtil.isValidLiteralValue(new StringValue("string"), nonNull(GraphQLString))
@@ -49,6 +54,11 @@ class ValidationUtilTest extends Specification {
         validationUtil.isValidLiteralValue(null, GraphQLString)
     }
 
+    def "NullValue is valid when type is NonNull"() {
+        expect:
+        validationUtil.isValidLiteralValue(NullValue.Null, GraphQLString)
+    }
+
     def "variables are valid"() {
         expect:
         validationUtil.isValidLiteralValue(new VariableReference("var"), GraphQLBoolean)