NPE fix for undefined value

Author: gary-nosto

gradle.properties

@@ -5,4 +5,4 @@ org.gradle.daemon=true
 org.gradle.parallel=true
 org.gradle.jvmargs=-Dfile.encoding=UTF-8
 
-version = 8.3-nosto
+version = 8.3-nosto1

src/main/java/graphql/annotations/annotationTypes/GraphQLUndefinable.java

@@ -28,6 +28,7 @@
 import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -145,14 +146,22 @@ private Object buildArg(Type p, GraphQLType graphQLType, Optional<Object> arg) {
             Constructor<?> constructor = getBuildArgConstructor(constructors);
             Parameter[] parameters = constructor.getParameters();
 
-            if (parameters.length == 1 && parameters[0].getType().isAssignableFrom(arg.get().getClass())) {
-                return constructNewInstance(constructor, arg.get());
+            if (parameters.length == 1 && parameters[0].getType().isAssignableFrom((Class<?>) p)) {
+                if (parameters[0].getType().isAssignableFrom(Optional.class)) {
+                    return constructNewInstance(constructor, arg);
+                } else {
+                    return constructNewInstance(constructor, arg.orElse(null));
+                }
             } else {
                 List<Object> objects = new ArrayList<>();
-                Map map = (Map) arg.get();
+                Map map = (Map) arg.orElseGet(Collections::emptyMap);
                 for (Parameter parameter : parameters) {
                     String name = toGraphqlName(parameter.getAnnotation(GraphQLName.class) != null ? parameter.getAnnotation(GraphQLName.class).value() : parameter.getName());
-                    objects.add(buildArg(parameter.getParameterizedType(), ((GraphQLInputObjectType) graphQLType).getField(name).getType(), map.containsKey(name) ? Optional.ofNullable(map.get(name)) : null));
+                    if (!map.containsKey(name)) {
+                        objects.add(null);
+                    } else {
+                        objects.add(buildArg(parameter.getParameterizedType(), ((GraphQLInputObjectType) graphQLType).getField(name).getType(), Optional.ofNullable(map.get(name))));
+                    }
                 }
                 return constructNewInstance(constructor, objects.toArray(new Object[objects.size()]));
             }
@@ -169,7 +178,7 @@ private Object buildArg(Type p, GraphQLType graphQLType, Optional<Object> arg) {
                 Type subType = ((ParameterizedType) p).getActualTypeArguments()[0];
                 GraphQLType wrappedType = ((GraphQLList) graphQLType).getWrappedType();
 
-                for (Object item : ((List) arg.get())) {
+                for (Object item : ((List) arg.orElseGet(Collections::emptyList))) {
                     list.add(buildArg(subType, wrappedType, Optional.ofNullable(item)));
                 }
                 return list;
@@ -182,7 +191,7 @@ private Object buildArg(Type p, GraphQLType graphQLType, Optional<Object> arg) {
                 return Optional.ofNullable(buildArg(subType, new GraphQLUndefined(), arg));
             }
         } else {
-            return arg.get();
+            return arg.orElse(null);
         }
     }
 

src/main/java/graphql/annotations/dataFetchers/MethodDataFetcher.java

@@ -144,6 +144,17 @@ public AnotherCode(@GraphQLName("firstField") Optional<String> one, @GraphQLName
         private final String secondField;
     }
 
+    @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
+    public static class AnotherCodeWithSingleField {
+
+        public AnotherCodeWithSingleField(@GraphQLName("one") Optional<String> one) {
+            this.field = one;
+        }
+
+        @GraphQLField
+        public Optional<String> field;
+    }
+
     public static class Code {
         public Code(@GraphQLName("map") HashMap map) {
             this.firstField = (String) map.get("firstField");
@@ -164,6 +175,12 @@ public String something(@GraphQLName("code") AnotherCode code) {
             return (code.firstField != null ? code.firstField.orElse("") : "") + code.secondField;
         }
 
+        @SuppressWarnings({"unused", "OptionalAssignedToNull"})
+        @GraphQLField
+        public String somethingWithOneField(@GraphQLName("code") AnotherCodeWithSingleField code) {
+            return code.field != null ? code.field.orElse("") : "was undefined";
+        }
+
         @SuppressWarnings({"unused", "OptionalAssignedToNull"})
         @GraphQLField
         public String otherthing(@GraphQLName("code") AnotherCode code) {
@@ -238,11 +255,12 @@ public void queryWithUndefinableParameters() {
         GraphQLSchema schema = newAnnotationsSchema().query(QueryUndefinedParameter.class).build();
 
         GraphQL graphQL = GraphQL.newGraphQL(schema).build();
-        ExecutionResult result = graphQL.execute("{ something(code: {firstField:\"a\",secondField:\"b\"}) otherthing(code: {secondField:\"c\"}) listthings  }", new QueryUndefinedParameter());
+        ExecutionResult result = graphQL.execute("{ something(code: {firstField:\"a\",secondField:\"b\"}) otherthing(code: {secondField:\"c\"}) listthings somethingWithOneField(code: {}) }", new QueryUndefinedParameter());
         assertTrue(result.getErrors().isEmpty());
         assertEquals(((Map<String, String>) result.getData()).get("something"), "ab");
         assertEquals(((Map<String, String>) result.getData()).get("otherthing"), "c");
         assertEquals(((Map<String, String>) result.getData()).get("listthings"), "was null");
+        assertEquals(((Map<String, String>) result.getData()).get("somethingWithOneField"), "was undefined");
     }
 
     @Test