Merge pull request #163 from graphql-java-kickstart/feature/162-exception-handler

Feature/162 exception handler

Author: oliemansm

README.md

@@ -118,9 +118,11 @@ Available Spring Boot configuration parameters (either `application.yml` or `app
 ```yaml
 graphql:
       servlet:
-               mapping: /graphql
-               enabled: true
-               corsEnabled: true
+           mapping: /graphql
+           enabled: true
+           corsEnabled: true
+           # if you want to @ExceptionHandler annotation for custom GraphQLErrors
+           exception-handlers-enabled: true
 ```
 
 By default a global CORS filter is enabled for `/graphql/**` context.

gradle.properties

@@ -17,7 +17,7 @@
 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 
-version = 5.2.1-SNAPSHOT
+version = 5.3-SNAPSHOT
 PROJECT_GROUP = com.graphql-java-kickstart
 PROJECT_NAME = graphql-spring-boot
 PROJECT_DESC = GraphQL Spring Framework Boot
@@ -39,10 +39,11 @@ TARGET_COMPATIBILITY = 1.8
 LIB_GRAPHQL_JAVA_VER = 11.0
 LIB_JUNIT_VER = 4.12
 LIB_SPRING_CORE_VER = 5.0.4.RELEASE
-LIB_SPRING_BOOT_VER = 2.0.5.RELEASE
-LIB_GRAPHQL_SERVLET_VER = 7.0.0
+LIB_SPRING_BOOT_VER = 2.1.0.RELEASE
+LIB_GRAPHQL_SERVLET_VER = 7.1.0
 LIB_GRAPHQL_JAVA_TOOLS_VER = 5.4.0
 LIB_COMMONS_IO_VER = 2.6
+kotlin.version=1.3.10
 
 GRADLE_WRAPPER_VER = 4.10.2
 

graphql-spring-boot-autoconfigure/build.gradle

@@ -19,7 +19,7 @@
 
 dependencies {
     compileOnly "org.springframework.boot:spring-boot-configuration-processor:$LIB_SPRING_BOOT_VER"
-    
+
     compile "org.springframework.boot:spring-boot-autoconfigure:$LIB_SPRING_BOOT_VER"
     compile "org.springframework.boot:spring-boot-starter-websocket:$LIB_SPRING_BOOT_VER"
     compile "com.graphql-java-kickstart:graphql-java-servlet:$LIB_GRAPHQL_SERVLET_VER"
@@ -31,6 +31,7 @@ dependencies {
     testCompile "com.graphql-java:graphql-java:$LIB_GRAPHQL_JAVA_VER"
     testCompile "org.springframework.boot:spring-boot-starter-web:$LIB_SPRING_BOOT_VER"
     testCompile "org.springframework.boot:spring-boot-starter-test:$LIB_SPRING_BOOT_VER"
+    testCompile(project(":graphql-spring-boot-test"))
 }
 
 compileJava.dependsOn(processResources)

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/GraphQLJavaToolsAutoConfiguration.java

@@ -4,9 +4,10 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
 import com.fasterxml.jackson.module.kotlin.KotlinModule;
+import com.oembedler.moon.graphql.boot.error.GraphQLErrorHandlerFactory;
 import graphql.schema.GraphQLScalarType;
 import graphql.schema.GraphQLSchema;
-import graphql.schema.idl.SchemaDirectiveWiring;
+import graphql.servlet.GraphQLErrorHandler;
 import graphql.servlet.GraphQLSchemaProvider;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
@@ -22,8 +23,6 @@
 import java.io.IOException;
 import java.util.List;
 
-import static com.coxautodev.graphql.tools.SchemaParserOptions.newOptions;
-
 /**
  * @author Andrew Potter
  */

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/GraphQLServletProperties.java

@@ -34,6 +34,8 @@ public class GraphQLServletProperties {
 
     private boolean asyncModeEnabled = false;
 
+    private boolean exceptionHandlersEnabled = false;
+
     public String getMapping() {
         return mapping != null ? mapping : "/graphql";
     }
@@ -85,4 +87,12 @@ public boolean isAsyncModeEnabled() {
     public void setAsyncModeEnabled(boolean asyncModeEnabled) {
         this.asyncModeEnabled = asyncModeEnabled;
     }
+
+    public boolean isExceptionHandlersEnabled() {
+        return exceptionHandlersEnabled;
+    }
+
+    public void setExceptionHandlersEnabled(boolean exceptionHandlersEnabled) {
+        this.exceptionHandlersEnabled = exceptionHandlersEnabled;
+    }
 }

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/GraphQLWebAutoConfiguration.java

@@ -21,6 +21,7 @@
 
 import com.fasterxml.jackson.databind.InjectableValues;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.oembedler.moon.graphql.boot.error.GraphQLErrorHandlerFactory;
 import graphql.execution.AsyncExecutionStrategy;
 import graphql.execution.ExecutionStrategy;
 import graphql.execution.SubscriptionExecutionStrategy;
@@ -29,12 +30,16 @@
 import graphql.execution.preparsed.PreparsedDocumentProvider;
 import graphql.schema.GraphQLSchema;
 import graphql.servlet.*;
+import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.condition.*;
 import org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.boot.web.servlet.ServletRegistrationBean;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
@@ -60,7 +65,7 @@
 @ConditionalOnProperty(value = "graphql.servlet.enabled", havingValue = "true", matchIfMissing = true)
 @AutoConfigureAfter({GraphQLJavaToolsAutoConfiguration.class, JacksonAutoConfiguration.class})
 @EnableConfigurationProperties({GraphQLServletProperties.class})
-public class GraphQLWebAutoConfiguration {
+public class GraphQLWebAutoConfiguration implements ApplicationContextAware {
 
     public static final String QUERY_EXECUTION_STRATEGY = "queryExecutionStrategy";
     public static final String MUTATION_EXECUTION_STRATEGY = "mutationExecutionStrategy";
@@ -96,6 +101,15 @@ public class GraphQLWebAutoConfiguration {
     @Autowired(required = false)
     private MultipartConfigElement multipartConfigElement;
 
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        if (!applicationContext.containsBean(GraphQLErrorHandler.class.getSimpleName())) {
+            ConfigurableApplicationContext context = (ConfigurableApplicationContext) applicationContext;
+            errorHandler = new GraphQLErrorHandlerFactory().create(context, graphQLServletProperties.isExceptionHandlersEnabled());
+            context.getBeanFactory().registerSingleton(errorHandler.getClass().getCanonicalName(), errorHandler);
+        }
+    }
+
     @Bean
     @ConditionalOnClass(CorsFilter.class)
     @ConditionalOnProperty(value = "graphql.servlet.corsEnabled", havingValue = "true", matchIfMissing = true)
@@ -236,5 +250,4 @@ public ServletRegistrationBean<AbstractGraphQLHttpServlet> graphQLServletRegistr
     private MultipartConfigElement multipartConfigElement() {
         return Optional.ofNullable(multipartConfigElement).orElse(new MultipartConfigElement(""));
     }
-
 }

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/error/GraphQLErrorFactory.java

@@ -0,0 +1,18 @@
+package com.oembedler.moon.graphql.boot.error;
+
+import graphql.GraphQLError;
+
+import java.lang.reflect.Method;
+import java.util.Optional;
+
+interface GraphQLErrorFactory {
+
+    Optional<Class<? extends Throwable>> mostConcrete(Throwable t);
+
+    GraphQLError create(Throwable t);
+
+    static GraphQLErrorFactory withReflection(Object object, Method method) {
+        return new ReflectiveGraphQLErrorFactory(object, method);
+    }
+
+}

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/error/GraphQLErrorFromExceptionHandler.java

@@ -0,0 +1,63 @@
+package com.oembedler.moon.graphql.boot.error;
+
+import graphql.ErrorType;
+import graphql.ExceptionWhileDataFetching;
+import graphql.GraphQLError;
+import graphql.SerializationError;
+import graphql.servlet.DefaultGraphQLErrorHandler;
+import graphql.servlet.GenericGraphQLError;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+class GraphQLErrorFromExceptionHandler extends DefaultGraphQLErrorHandler {
+
+    private List<GraphQLErrorFactory> factories;
+
+    GraphQLErrorFromExceptionHandler(List<GraphQLErrorFactory> factories) {
+        this.factories = factories;
+    }
+
+    protected List<GraphQLError> filterGraphQLErrors(List<GraphQLError> errors) {
+        return errors.stream().map(this::transform).collect(Collectors.toList());
+    }
+
+    private GraphQLError transform(GraphQLError error) {
+        if (error.getErrorType() == ErrorType.DataFetchingException) {
+            return extractException(error).map(this::transform).orElse(defaultError(error.getMessage()));
+        }
+
+        return defaultError(error.getMessage());
+    }
+
+    private Optional<Throwable> extractException(GraphQLError error) {
+        if (error instanceof ExceptionWhileDataFetching) {
+            return Optional.of(((ExceptionWhileDataFetching) error).getException());
+        } else if (error instanceof SerializationError) {
+            return Optional.of(((SerializationError) error).getException());
+        }
+        return Optional.empty();
+    }
+
+    private GraphQLError transform(Throwable throwable) {
+        Map<Class<? extends Throwable>, GraphQLErrorFactory> applicables = new HashMap<>();
+        factories.forEach(factory -> factory.mostConcrete(throwable).ifPresent(t -> applicables.put(t, factory)));
+        return applicables.keySet().stream()
+                .min(new ThrowableComparator())
+                .map(applicables::get)
+                .map(factory -> factory.create(throwable))
+                .orElse(this.defaultError(throwable));
+    }
+
+    private GraphQLError defaultError(Throwable throwable) {
+        return new ThrowableGraphQLError(throwable);
+    }
+
+    private GraphQLError defaultError(String message) {
+        return new GenericGraphQLError(message);
+    }
+
+}

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/error/GraphQLErrorHandlerFactory.java

@@ -0,0 +1,52 @@
+package com.oembedler.moon.graphql.boot.error;
+
+import graphql.servlet.DefaultGraphQLErrorHandler;
+import graphql.servlet.GraphQLErrorHandler;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+@Slf4j
+public class GraphQLErrorHandlerFactory {
+
+    public GraphQLErrorHandler create(ConfigurableApplicationContext applicationContext, boolean exceptionHandlersEnabled) {
+        ConfigurableListableBeanFactory beanFactory = applicationContext.getBeanFactory();
+        List<GraphQLErrorFactory> factories = Arrays.stream(beanFactory.getBeanDefinitionNames())
+                .map(beanFactory::getBeanDefinition)
+                .map(BeanDefinition::getBeanClassName)
+                .filter(Objects::nonNull)
+                .map(name -> scanForExceptionHandlers(applicationContext, beanFactory, name))
+                .flatMap(List::stream)
+                .collect(Collectors.toList());
+
+        if (!factories.isEmpty() || exceptionHandlersEnabled) {
+            return new GraphQLErrorFromExceptionHandler(factories);
+        }
+
+        return new DefaultGraphQLErrorHandler();
+    }
+
+    private List<GraphQLErrorFactory> scanForExceptionHandlers(ApplicationContext context, ConfigurableListableBeanFactory beanFactory, String className) {
+        try {
+            Class<?> objClz = beanFactory.getBeanClassLoader().loadClass(className);
+            // todo: need to handle proxies?
+            return Arrays.stream(objClz.getDeclaredMethods())
+                    .filter(method -> method.isAnnotationPresent(ExceptionHandler.class))
+                    .map(method -> GraphQLErrorFactory.withReflection(context.getBean(className), method))
+                    .collect(Collectors.toList());
+        } catch (ClassNotFoundException e) {
+            log.error("Cannot load class " + className + ". " + e.getMessage());
+            return Collections.emptyList();
+        }
+    }
+
+}

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/error/ReflectiveGraphQLErrorFactory.java

@@ -0,0 +1,42 @@
+package com.oembedler.moon.graphql.boot.error;
+
+import graphql.GraphQLError;
+import graphql.servlet.GenericGraphQLError;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Optional;
+
+@Slf4j
+class ReflectiveGraphQLErrorFactory implements GraphQLErrorFactory {
+
+    private Object object;
+    private Method method;
+    private Throwables throwables;
+
+    ReflectiveGraphQLErrorFactory(Object object, Method method) {
+        this.object = object;
+        this.method = method;
+
+        throwables = new Throwables(method.getAnnotation(ExceptionHandler.class).value());
+    }
+
+    @Override
+    public Optional<Class<? extends Throwable>> mostConcrete(Throwable t) {
+        return throwables.mostConcrete(t);
+    }
+
+    @Override
+    public GraphQLError create(Throwable t) {
+        try {
+            method.setAccessible(true);
+            return (GraphQLError) method.invoke(object, t);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            log.error("Cannot create GraphQLError from throwable {}", t.getClass().getSimpleName(), e);
+            return new GenericGraphQLError(t.getMessage());
+        }
+    }
+
+}