Serialize TypeInfo correctly but also hide Throwable errors by default (fixes #37)

Author: apottere

.gitignore

@@ -5,3 +5,4 @@ build/
 *.iws
 .idea/
 target/
+/out/

src/main/java/graphql/servlet/DefaultGraphQLErrorHandler.java

@@ -39,7 +39,13 @@ public List<GraphQLError> processErrors(List<GraphQLError> errors) {
 
             errors.stream()
                 .filter(error -> !isClientError(error))
-                .forEach(error -> log.error("Error executing query ({}): {}", error.getClass().getSimpleName(), error.getMessage()));
+                .forEach(error -> {
+                    if(error instanceof Throwable) {
+                        log.error("Error executing query!", (Throwable) error);
+                    } else {
+                        log.error("Error executing query ({}): {}", error.getClass().getSimpleName(), error.getMessage());
+                    }
+                });
         }
 
         return clientErrors;
@@ -52,6 +58,6 @@ protected List<GraphQLError> filterGraphQLErrors(List<GraphQLError> errors) {
     }
 
     protected boolean isClientError(GraphQLError error) {
-        return !(error instanceof ExceptionWhileDataFetching);
+        return !(error instanceof ExceptionWhileDataFetching || error instanceof Throwable);
     }
 }

src/main/java/graphql/servlet/GraphQLServlet.java

@@ -14,16 +14,23 @@
  */
 package graphql.servlet;
 
+import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.DeserializationContext;
 import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.JsonSerializer;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.RuntimeJsonMappingException;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.databind.SerializerProvider;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.module.SimpleModule;
 import graphql.ExecutionResult;
 import graphql.GraphQL;
 import graphql.GraphQLError;
+import graphql.execution.TypeInfo;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.introspection.IntrospectionQuery;
 import graphql.schema.GraphQLFieldDefinition;
@@ -68,7 +75,16 @@ public abstract class GraphQLServlet extends HttpServlet implements Servlet, Gra
     public static final int STATUS_OK = 200;
     public static final int STATUS_BAD_REQUEST = 400;
 
-    private static final ObjectMapper mapper = new ObjectMapper();
+    private static final ObjectMapper mapper = new ObjectMapper().disable(SerializationFeature.FAIL_ON_EMPTY_BEANS).registerModule(new SimpleModule().addSerializer(TypeInfo.class, new JsonSerializer<TypeInfo>() {
+        @Override
+        public void serialize(TypeInfo value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
+            gen.writeStartObject();
+            serializers.defaultSerializeField("type", value.type(), gen);
+            serializers.defaultSerializeField("parentTypeInfo", value.parentTypeInfo(), gen);
+            serializers.defaultSerializeField("typeIsNonNull", value.typeIsNonNull(), gen);
+            gen.writeEndObject();
+        }
+    }));
 
     protected abstract GraphQLSchemaProvider getSchemaProvider();
     protected abstract GraphQLContext createContext(Optional<HttpServletRequest> request, Optional<HttpServletResponse> response);

src/test/groovy/graphql/servlet/GraphQLServletSpec.groovy

@@ -15,20 +15,18 @@
 package graphql.servlet
 
 import com.fasterxml.jackson.databind.ObjectMapper
-import graphql.GraphQLError
 import graphql.Scalars
-import graphql.execution.SimpleExecutionStrategy
+import graphql.execution.TypeInfo
 import graphql.schema.DataFetcher
+import graphql.schema.GraphQLFieldDefinition
+import graphql.schema.GraphQLNonNull
 import graphql.schema.GraphQLObjectType
 import graphql.schema.GraphQLSchema
 import org.springframework.mock.web.MockHttpServletRequest
 import org.springframework.mock.web.MockHttpServletResponse
 import spock.lang.Shared
 import spock.lang.Specification
 
-import javax.servlet.http.HttpServletRequest
-import javax.servlet.http.HttpServletResponse
-
 /**
  * @author Andrew Potter
  */
@@ -55,29 +53,34 @@ class GraphQLServletSpec extends Specification {
     def createServlet(DataFetcher queryDataFetcher = { env -> env.arguments.arg }, DataFetcher mutationDataFetcher = { env -> env.arguments.arg }) {
         GraphQLObjectType query = GraphQLObjectType.newObject()
             .name("Query")
-            .field { field ->
-            field.name("echo")
-            field.type(Scalars.GraphQLString)
-            field.argument { argument ->
-                argument.name("arg")
-                argument.type(Scalars.GraphQLString)
+            .field { GraphQLFieldDefinition.Builder field ->
+                field.name("echo")
+                field.type(Scalars.GraphQLString)
+                field.argument { argument ->
+                    argument.name("arg")
+                    argument.type(Scalars.GraphQLString)
+                }
+                field.dataFetcher(queryDataFetcher)
             }
-            field.dataFetcher(queryDataFetcher)
-        }
-        .build()
+            .field { GraphQLFieldDefinition.Builder field ->
+                field.name("returnsNullIncorrectly")
+                field.type(new GraphQLNonNull(Scalars.GraphQLString))
+                field.dataFetcher({env -> null})
+            }
+            .build()
 
         GraphQLObjectType mutation = GraphQLObjectType.newObject()
             .name("Mutation")
             .field { field ->
-            field.name("echo")
-            field.type(Scalars.GraphQLString)
-            field.argument { argument ->
-                argument.name("arg")
-                argument.type(Scalars.GraphQLString)
+                field.name("echo")
+                field.type(Scalars.GraphQLString)
+                field.argument { argument ->
+                    argument.name("arg")
+                    argument.type(Scalars.GraphQLString)
+                }
+                field.dataFetcher(mutationDataFetcher)
             }
-            field.dataFetcher(mutationDataFetcher)
-        }
-        .build()
+            .build()
 
         return new SimpleGraphQLServlet(new GraphQLSchema(query, mutation, [query, mutation].toSet()))
     }
@@ -416,7 +419,25 @@ class GraphQLServletSpec extends Specification {
             resp.errors != null
     }
 
-    private byte[] createContent(String data) {
-        data.split('\\n').collect { it.replaceAll('^\\s+', '') }.join('\n').getBytes()
+    def "NonNullableFieldWasNullException is masked by default"() {
+        setup:
+            request.addParameter('query', 'query { returnsNullIncorrectly }')
+
+        when:
+            servlet.doGet(request, response)
+
+        then:
+            response.getStatus() == STATUS_OK
+            response.getContentType() == CONTENT_TYPE_JSON_UTF8
+            def resp = getResponseContent()
+            resp.containsKey("data")
+            resp.data == null
+            resp.errors != null
+            resp.errors.first().message.contains('Internal Server Error')
+    }
+
+    def "typeInfo is serialized correctly"() {
+        expect:
+            GraphQLServlet.mapper.writeValueAsString(TypeInfo.newTypeInfo().type(new GraphQLNonNull(Scalars.GraphQLString)).build()) != "{}"
     }
 }