First cut at supporting errors from data fetchers

mrdon-atlassian · bbakerman · commit c0ef9959ded1 · 2017-11-20T07:50:36.000+11:00
diff --git a/src/main/java/graphql/execution/DataFetcherResult.java b/src/main/java/graphql/execution/DataFetcherResult.java
@@ -0,0 +1,40 @@
+package graphql.execution;
+
+import graphql.GraphQLError;
+import graphql.schema.DataFetcher;
+
+import java.util.List;
+
+import static java.util.Objects.requireNonNull;
+
+
+/**
+ * An object that can be returned from a {@link DataFetcher} that contains both data and errors to be relativized and
+ * added to the final result.
+ *
+ * @param <T> The type of the data fetched
+ */
+public class DataFetcherResult<T> {
+
+    private final T data;
+    private final List<GraphQLError> errors;
+
+    public DataFetcherResult(T data, List<GraphQLError> errors) {
+        this.data = data;
+        this.errors = requireNonNull(errors);
+    }
+
+    /**
+     * @return The data fetched. May be null
+     */
+    public T getData() {
+        return data;
+    }
+
+    /**
+     * @return errors encountered when fetching data.  Must not be null.
+     */
+    public List<GraphQLError> getErrors() {
+        return errors;
+    }
+}
diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java
@@ -1,7 +1,9 @@
 package graphql.execution;
 
+import graphql.ErrorType;
 import graphql.ExecutionResult;
 import graphql.ExecutionResultImpl;
+import graphql.GraphQLError;
 import graphql.PublicSpi;
 import graphql.SerializationError;
 import graphql.TypeResolutionEnvironment;
@@ -12,6 +14,7 @@
 import graphql.execution.instrumentation.parameters.InstrumentationFieldParameters;
 import graphql.introspection.Introspection;
 import graphql.language.Field;
+import graphql.language.SourceLocation;
 import graphql.schema.CoercingSerializeException;
 import graphql.schema.DataFetcher;
 import graphql.schema.DataFetchingEnvironment;
@@ -37,6 +40,7 @@
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionException;
+import java.util.function.Function;
 import java.util.stream.IntStream;
 
 import static graphql.execution.ExecutionTypeInfo.newTypeInfo;
@@ -328,6 +332,15 @@ protected CompletableFuture<ExecutionResult> completeValue(ExecutionContext exec
         Object result = unboxPossibleOptional(parameters.source());
         GraphQLType fieldType = typeInfo.getType();
 
+        if (result != null && result instanceof DataFetcherResult) {
+            //noinspection unchecked
+            DataFetcherResult<Object> dataFetcherResult = (DataFetcherResult)result;
+            result = dataFetcherResult.getData();
+            dataFetcherResult.getErrors().stream()
+                    .map(relError -> new AbsoluteGraphQLError(parameters, relError))
+                    .forEach(e -> executionContext.addError(e, ExecutionPath.fromList(e.getPath())));
+        }
+
         if (result == null) {
             return completedFuture(new ExecutionResultImpl(parameters.nonNullFieldValidator().validate(parameters.path(), null), null));
         } else if (fieldType instanceof GraphQLList) {
diff --git a/src/main/java/graphql/execution/RelavitizedGraphQLError.java b/src/main/java/graphql/execution/RelavitizedGraphQLError.java
@@ -0,0 +1,69 @@
+package graphql.execution;
+
+import graphql.ErrorType;
+import graphql.GraphQLError;
+import graphql.language.SourceLocation;
+import graphql.schema.DataFetcher;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import static com.sun.tools.javac.util.Assert.checkNonNull;
+
+/**
+ * A {@link GraphQLError} that has been changed from a {@link DataFetcher} relative error to an absolute one.
+ */
+class AbsoluteGraphQLError implements GraphQLError {
+
+    private final List<SourceLocation> locations;
+    private final List<Object> absolutePath;
+    private final GraphQLError relativeError;
+
+    AbsoluteGraphQLError(ExecutionStrategyParameters executionStrategyParameters, GraphQLError relativeError) {
+        checkNonNull(executionStrategyParameters);
+        this.relativeError = checkNonNull(relativeError);
+        List<Object> path = new ArrayList<>();
+        path.addAll(executionStrategyParameters.path().toList());
+        path.addAll(relativeError.getPath());
+        this.absolutePath = path;
+
+        Optional<SourceLocation> baseLocation;
+        if (!executionStrategyParameters.field().isEmpty()) {
+            baseLocation = Optional.of(executionStrategyParameters.field().get(0).getSourceLocation());
+        } else {
+            baseLocation = Optional.empty();
+        }
+
+        this.locations = Optional.ofNullable(
+                relativeError.getLocations())
+                .map(locations -> locations.stream()
+                        .map(l ->
+                                baseLocation
+                                        .map(base -> new SourceLocation(base.getLine() + l.getLine(), base.getColumn() + l.getColumn()))
+                                        .orElse(null))
+                        .collect(Collectors.toList()))
+                .orElse(null);
+    }
+
+    @Override
+    public String getMessage() {
+        return relativeError.getMessage();
+    }
+
+    @Override
+    public List<SourceLocation> getLocations() {
+        return locations;
+    }
+
+    @Override
+    public ErrorType getErrorType() {
+        return relativeError.getErrorType();
+    }
+
+    @Override
+    public List<Object> getPath() {
+        return absolutePath;
+    }
+}
diff --git a/src/test/java/DataFetcherWithErrorsTest.java b/src/test/java/DataFetcherWithErrorsTest.java
@@ -0,0 +1,99 @@
+import graphql.ErrorType;
+import graphql.ExecutionResult;
+import graphql.GraphQL;
+import graphql.GraphQLError;
+import graphql.execution.DataFetcherResult;
+import graphql.language.SourceLocation;
+import graphql.schema.DataFetcher;
+import graphql.schema.DataFetchingEnvironment;
+import graphql.schema.GraphQLSchema;
+import graphql.schema.StaticDataFetcher;
+import graphql.schema.idl.RuntimeWiring;
+import graphql.schema.idl.SchemaGenerator;
+import graphql.schema.idl.SchemaParser;
+import graphql.schema.idl.TypeDefinitionRegistry;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static graphql.schema.idl.RuntimeWiring.newRuntimeWiring;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
+import static java.util.Collections.singletonList;
+import static java.util.Collections.singletonMap;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+
+public class DataFetcherWithErrorsTest {
+
+    @Test
+    public void testDataFetcherWithErrors() {
+        GraphQLError error = new GraphQLError() {
+
+            @Override
+            public String getMessage() {
+                return "badField is bad";
+            }
+
+            @Override
+            public List<SourceLocation> getLocations() {
+                return singletonList(new SourceLocation(2, 10));
+            }
+
+            @Override
+            public ErrorType getErrorType() {
+                return ErrorType.DataFetchingException;
+            }
+
+            @Override
+            public List<Object> getPath() {
+                return Arrays.asList("child", "badField");
+            }
+        };
+        DataFetcher dataFetcher = environment -> new DataFetcherResult<Map>(
+                singletonMap("child",
+                        new HashMap<String, Object>() {{
+                            put("goodField", "good");
+                            put("badField", null);
+                        }}
+                ),
+                singletonList(error)
+        );
+
+        String schema = "type Query{root: Root}\n" +
+                "type Root{ parent: Parent}\n" +
+                "type Parent{ child: Child}\n" +
+                "type Child{\n" +
+                "  goodField: String,\n" +
+                "  badField: String\n" +
+                "}";
+        SchemaParser schemaParser = new SchemaParser();
+        TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema);
+        RuntimeWiring runtimeWiring = newRuntimeWiring()
+                .type("Root", builder -> builder.dataFetcher("parent", dataFetcher))
+                .type("Query", builder -> builder.dataFetcher("root", new StaticDataFetcher(emptyMap())))
+                .build();
+
+        SchemaGenerator schemaGenerator = new SchemaGenerator();
+        GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);
+
+        GraphQL build = GraphQL.newGraphQL(graphQLSchema).build();
+        ExecutionResult executionResult = build.execute("{root{parent{child{goodField, badField}}}}");
+        System.out.println(executionResult.getData().toString());
+
+        assertEquals(1, executionResult.getErrors().size());
+        GraphQLError firstError = executionResult.getErrors().get(0);
+        assertEquals(Arrays.asList("root", "parent", "child", "badField"), firstError.getPath());
+        assertEquals("badField is bad", firstError.getMessage());
+        assertEquals(singletonList(new SourceLocation(3, 17)), firstError.getLocations());
+
+        Map<String, String> child = ((Map<String, Map<String, Map<String, Map<String, String>>>>) executionResult.getData()).get("root").get("parent").get("child");
+        assertEquals("good", child.get("goodField"));
+        assertEquals(null, child.get("badField"));
+
+    }
+}
