Merge pull request #454 from tfij/AddSupportForLocationAndPathInErrorHandler

Add suport for location and path to error handler

Author: oliemansm

graphql-kickstart-spring-support/src/main/java/graphql/kickstart/spring/error/ErrorContext.java

@@ -0,0 +1,23 @@
+package graphql.kickstart.spring.error;
+
+import graphql.language.SourceLocation;
+
+import java.util.List;
+
+public class ErrorContext {
+    private final List<SourceLocation> locations;
+    private final List<Object> path;
+
+    public ErrorContext(List<SourceLocation> locations, List<Object> path) {
+        this.locations = locations;
+        this.path = path;
+    }
+
+    public List<SourceLocation> getLocations() {
+        return locations;
+    }
+
+    public List<Object> getPath() {
+        return path;
+    }
+}

graphql-kickstart-spring-support/src/main/java/graphql/kickstart/spring/error/GraphQLErrorFactory.java

@@ -10,7 +10,7 @@ interface GraphQLErrorFactory {
 
     Optional<Class<? extends Throwable>> mostConcrete(Throwable t);
 
-    Collection<GraphQLError> create(Throwable t);
+    Collection<GraphQLError> create(Throwable t, ErrorContext errorContext);
 
     static GraphQLErrorFactory withReflection(Object object, Method method) {
         return new ReflectiveGraphQLErrorFactory(object, method);

graphql-kickstart-spring-support/src/main/java/graphql/kickstart/spring/error/GraphQLErrorFromExceptionHandler.java

@@ -32,7 +32,8 @@ protected List<GraphQLError> filterGraphQLErrors(List<GraphQLError> errors) {
   }
 
   private Collection<GraphQLError> transform(GraphQLError error) {
-    return extractException(error).map(this::transform)
+    ErrorContext errorContext = new ErrorContext(error.getLocations(), error.getPath());
+    return extractException(error).map(throwable -> transform(throwable, errorContext))
         .orElse(singletonList(new GenericGraphQLError(error.getMessage())));
   }
 
@@ -47,13 +48,13 @@ private Optional<Throwable> extractException(GraphQLError error) {
     return Optional.empty();
   }
 
-  private Collection<GraphQLError> transform(Throwable throwable) {
+  private Collection<GraphQLError> transform(Throwable throwable, ErrorContext errorContext) {
     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))
+        .map(factory -> factory.create(throwable, errorContext))
         .orElse(singletonList(new ThrowableGraphQLError(throwable)));
   }
 

graphql-kickstart-spring-support/src/main/java/graphql/kickstart/spring/error/ReflectiveGraphQLErrorFactory.java

@@ -15,6 +15,7 @@
 class ReflectiveGraphQLErrorFactory implements GraphQLErrorFactory {
 
   private final boolean singularReturnType;
+  private final boolean withErrorContext;
   private Object object;
   private Method method;
   private Throwables throwables;
@@ -23,7 +24,7 @@ class ReflectiveGraphQLErrorFactory implements GraphQLErrorFactory {
     this.object = object;
     this.method = method;
     singularReturnType = GraphQLError.class.isAssignableFrom(method.getReturnType());
-
+    withErrorContext = method.getParameterCount() == 2;
     throwables = new Throwables(method.getAnnotation(ExceptionHandler.class).value());
   }
 
@@ -33,17 +34,25 @@ public Optional<Class<? extends Throwable>> mostConcrete(Throwable t) {
   }
 
   @Override
-  public Collection<GraphQLError> create(Throwable t) {
+  public Collection<GraphQLError> create(Throwable t, ErrorContext errorContext) {
     try {
       method.setAccessible(true);
       if (singularReturnType) {
-        return singletonList((GraphQLError) method.invoke(object, t));
+        return singletonList((GraphQLError) invoke(t, errorContext));
       }
-      return (Collection<GraphQLError>) method.invoke(object, t);
+      return (Collection<GraphQLError>) invoke(t, errorContext);
     } catch (IllegalAccessException | InvocationTargetException e) {
       log.error("Cannot create GraphQLError from throwable {}", t.getClass().getSimpleName(), e);
       return singletonList(new GenericGraphQLError(t.getMessage()));
     }
   }
 
+  private Object invoke(Throwable t, ErrorContext errorContext) throws IllegalAccessException, InvocationTargetException {
+    if (withErrorContext) {
+      return method.invoke(object, t, errorContext);
+    } else {
+      return method.invoke(object, t);
+    }
+  }
+
 }