Introduce GraphQlResponse

Replace the use of ExecutionResult on the client side where we are
dealing with a response map rather, and also incorporate it into the
server-side hierarchy where it wraps an ExecutionResult instead.

See gh-10

Author: rstoyanchev

Diff for: spring-graphql-test/src/main/java/org/springframework/graphql/test/tester/AbstractDirectTransport.java

@@ -25,6 +25,7 @@
 import reactor.core.publisher.Mono;
 
 import org.springframework.graphql.GraphQlRequest;
+import org.springframework.graphql.GraphQlResponse;
 import org.springframework.graphql.RequestOutput;
 import org.springframework.graphql.client.GraphQlTransport;
 import org.springframework.test.util.AssertionErrors;
@@ -45,22 +46,23 @@ abstract class AbstractDirectTransport implements GraphQlTransport {
 
 
 	@Override
-	public Mono<ExecutionResult> execute(GraphQlRequest request) {
-		return executeInternal(request).cast(ExecutionResult.class);
+	public Mono<GraphQlResponse> execute(GraphQlRequest request) {
+		return executeInternal(request).cast(GraphQlResponse.class);
 	}
 
 	@SuppressWarnings({"ConstantConditions", "unchecked"})
 	@Override
-	public Flux<ExecutionResult> executeSubscription(GraphQlRequest request) {
-		return executeInternal(request).flatMapMany(result -> {
+	public Flux<GraphQlResponse> executeSubscription(GraphQlRequest request) {
+		return executeInternal(request).flatMapMany(output -> {
 			try {
-				Object data = result.getData();
+				Object data = output.getData();
 				AssertionErrors.assertTrue("Not a Publisher: " + data, data instanceof Publisher);
 
-				List<GraphQLError> errors = result.getErrors();
+				List<GraphQLError> errors = output.getErrors();
 				AssertionErrors.assertTrue("Subscription errors: " + errors, CollectionUtils.isEmpty(errors));
 
-				return Flux.from((Publisher<ExecutionResult>) data);
+				return Flux.from((Publisher<ExecutionResult>) data)
+						.map(result -> new RequestOutput(output.getExecutionInput(), result));
 			}
 			catch (AssertionError ex) {
 				throw new AssertionError(ex.getMessage() + "\nRequest: " + request, ex);

Diff for: spring-graphql-test/src/main/java/org/springframework/graphql/test/tester/DefaultGraphQlTester.java

@@ -31,12 +31,12 @@
 import com.jayway.jsonpath.DocumentContext;
 import com.jayway.jsonpath.JsonPath;
 import com.jayway.jsonpath.TypeRef;
-import graphql.ExecutionResult;
 import graphql.GraphQLError;
 
 import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.core.ResolvableType;
 import org.springframework.graphql.GraphQlRequest;
+import org.springframework.graphql.GraphQlResponse;
 import org.springframework.graphql.client.GraphQlTransport;
 import org.springframework.graphql.support.DocumentSource;
 import org.springframework.lang.Nullable;
@@ -165,7 +165,7 @@ public DefaultRequest variable(String name, @Nullable Object value) {
 		@SuppressWarnings("ConstantConditions")
 		@Override
 		public Response execute() {
-			return transport.execute(request()).map(result -> response(result, request())).block(responseTimeout);
+			return transport.execute(request()).map(response -> mapResponse(response, request())).block(responseTimeout);
 		}
 
 		@Override
@@ -175,15 +175,15 @@ public void executeAndVerify() {
 
 		@Override
 		public Subscription executeSubscription() {
-			return () -> transport.executeSubscription(request()).map(result -> response(result, request()));
+			return () -> transport.executeSubscription(request()).map(result -> mapResponse(result, request()));
 		}
 
 		private GraphQlRequest request() {
 			return new GraphQlRequest(this.document, this.operationName, this.variables);
 		}
 
-		private DefaultResponse response(ExecutionResult result, GraphQlRequest request) {
-			return new DefaultResponse(result, errorFilter, assertDecorator(request), jsonPathConfig);
+		private DefaultResponse mapResponse(GraphQlResponse response, GraphQlRequest request) {
+			return new DefaultResponse(response, errorFilter, assertDecorator(request), jsonPathConfig);
 		}
 
 		private Consumer<Runnable> assertDecorator(GraphQlRequest request) {
@@ -217,12 +217,12 @@ private final static class ResponseDelegate {
 
 
 		private ResponseDelegate(
-				ExecutionResult result, @Nullable Predicate<GraphQLError> errorFilter,
+				GraphQlResponse response, @Nullable Predicate<GraphQLError> errorFilter,
 				Consumer<Runnable> assertDecorator, Configuration jsonPathConfig) {
 
-			this.jsonDoc = JsonPath.parse(result.toSpecification(), jsonPathConfig);
+			this.jsonDoc = JsonPath.parse(response.toMap(), jsonPathConfig);
 			this.jsonContent = this.jsonDoc::jsonString;
-			this.errors = result.getErrors();
+			this.errors = response.getErrors();
 			this.unexpectedErrors = new ArrayList<>(this.errors);
 			this.assertDecorator = assertDecorator;
 
@@ -293,10 +293,10 @@ private static final class DefaultResponse implements Response, Errors {
 		private final ResponseDelegate delegate;
 
 		private DefaultResponse(
-				ExecutionResult result, @Nullable Predicate<GraphQLError> errorFilter,
+				GraphQlResponse response, @Nullable Predicate<GraphQLError> errorFilter,
 				Consumer<Runnable> assertDecorator, Configuration jsonPathConfig) {
 
-			this.delegate = new ResponseDelegate(result, errorFilter, assertDecorator, jsonPathConfig);
+			this.delegate = new ResponseDelegate(response, errorFilter, assertDecorator, jsonPathConfig);
 		}
 
 		@Override

Diff for: spring-graphql-test/src/main/java/org/springframework/graphql/test/tester/DefaultWebSocketGraphQlTester.java

@@ -20,11 +20,11 @@
 import java.net.URI;
 import java.util.function.Consumer;
 
-import graphql.ExecutionResult;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import org.springframework.graphql.GraphQlRequest;
+import org.springframework.graphql.GraphQlResponse;
 import org.springframework.graphql.client.CodecMappingProvider;
 import org.springframework.graphql.client.GraphQlClient;
 import org.springframework.graphql.client.GraphQlTransport;
@@ -164,7 +164,7 @@ private static GraphQlTransport asTransport(GraphQlClient client) {
 			return new GraphQlTransport() {
 
 				@Override
-				public Mono<ExecutionResult> execute(GraphQlRequest request) {
+				public Mono<GraphQlResponse> execute(GraphQlRequest request) {
 					return client
 							.document(request.getDocument())
 							.operationName(request.getOperationName())
@@ -174,7 +174,7 @@ public Mono<ExecutionResult> execute(GraphQlRequest request) {
 				}
 
 				@Override
-				public Flux<ExecutionResult> executeSubscription(GraphQlRequest request) {
+				public Flux<GraphQlResponse> executeSubscription(GraphQlRequest request) {
 					return client
 							.document(request.getDocument())
 							.operationName(request.getOperationName())

Diff for: spring-graphql-test/src/main/java/org/springframework/graphql/test/tester/WebTestClientTransport.java

@@ -19,14 +19,14 @@
 import java.util.Collections;
 import java.util.Map;
 
-import graphql.ExecutionResult;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.graphql.GraphQlRequest;
+import org.springframework.graphql.GraphQlResponse;
 import org.springframework.graphql.client.GraphQlTransport;
-import org.springframework.graphql.support.MapExecutionResult;
+import org.springframework.graphql.support.MapGraphQlResponse;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.reactive.server.WebTestClient;
 import org.springframework.util.Assert;
@@ -53,9 +53,9 @@ final class WebTestClientTransport implements GraphQlTransport {
 
 
 	@Override
-	public Mono<ExecutionResult> execute(GraphQlRequest request) {
+	public Mono<GraphQlResponse> execute(GraphQlRequest request) {
 
-		Map<String, Object> resultMap = this.webTestClient.post()
+		Map<String, Object> responseMap = this.webTestClient.post()
 				.contentType(MediaType.APPLICATION_JSON)
 				.accept(MediaType.APPLICATION_JSON)
 				.bodyValue(request.toMap())
@@ -66,13 +66,13 @@ public Mono<ExecutionResult> execute(GraphQlRequest request) {
 				.returnResult()
 				.getResponseBody();
 
-		resultMap = (resultMap != null ? resultMap : Collections.emptyMap());
-		ExecutionResult result = MapExecutionResult.from(resultMap);
-		return Mono.just(result);
+		responseMap = (responseMap != null ? responseMap : Collections.emptyMap());
+		GraphQlResponse response = MapGraphQlResponse.forResponse(responseMap);
+		return Mono.just(response);
 	}
 
 	@Override
-	public Flux<ExecutionResult> executeSubscription(GraphQlRequest request) {
+	public Flux<GraphQlResponse> executeSubscription(GraphQlRequest request) {
 		throw new UnsupportedOperationException("Subscriptions not supported over HTTP");
 	}
 

Diff for: spring-graphql/src/main/java/org/springframework/graphql/GraphQlResponse.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.graphql;
+
+
+import java.util.List;
+import java.util.Map;
+
+import graphql.GraphQLError;
+
+import org.springframework.lang.Nullable;
+
+/**
+ * Represents a GraphQL response with the result of executing a request operation.
+ *
+ * @author Rossen Stoyanchev
+ * @since 1.0.0
+ */
+public interface GraphQlResponse {
+
+	/**
+	 * Whether the response is valid. A response is invalid in one of the
+	 * following two cases:
+	 * <ul>
+	 * <li>the {@link #toMap() response map} has no "data" entry indicating
+	 * errors before execution, e.g. grammar parse and validation
+	 * <li>the "data" entry has a {@code null} value indicating errors during
+	 * execution that prevented a valid response
+	 * </ul>
+	 * <p>A valid response has a "data" key with a {@code non-null} value, but
+	 * it may still be partial and have some fields set to {@code null} due to
+	 * field errors.
+	 * <p>For more details, see section 7 "Response" in the GraphQL spec.
+	 */
+	boolean isValid();
+
+	/**
+	 * Return the data part of the response, or {@code null} when the response
+	 * is not {@link #isValid() valid}.
+	 * @param <T> a map or a list
+	 */
+	@Nullable
+	<T> T getData();
+
+	/**
+	 * Return errors for the response. This contains "request errors" when the
+	 * response is not {@link #isValid() valid} and/or "field errors" for a
+	 * partial response.
+	 */
+	List<GraphQLError> getErrors();
+
+	/**
+	 * Return implementor specific, protocol extensions, if any.
+	 */
+	Map<Object, Object> getExtensions();
+
+	/**
+	 * Return a map representation of the response, formatted as required in the
+	 * "Response" section of the GraphQL spec.
+	 */
+	Map<String, Object> toMap();
+
+}

Diff for: spring-graphql/src/main/java/org/springframework/graphql/RequestOutput.java

@@ -15,6 +15,7 @@
  */
 package org.springframework.graphql;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -26,29 +27,37 @@
 import org.springframework.util.Assert;
 
 /**
- * Wraps an {@link ExecutionResult} and also exposes the {@link ExecutionInput}
- * prepared for the request.
+ * {@link GraphQlResponse} for server use that wraps the {@link ExecutionResult}
+ * returned from {@link graphql.GraphQL} and also exposes the actual
+ * {@link ExecutionInput} instance passed into it.
  *
  * @author Rossen Stoyanchev
  * @since 1.0.0
  */
-public class RequestOutput implements ExecutionResult {
+public class RequestOutput implements GraphQlResponse {
 
-	private final ExecutionInput executionInput;
+	private final ExecutionInput input;
 
-	private final ExecutionResult executionResult;
+	private final ExecutionResult result;
 
 
 	/**
-	 * Create an instance.
-	 * @param executionInput the input prepared for the request
-	 * @param executionResult the result from performing the request
+	 * Constructor to create initial instance.
 	 */
-	public RequestOutput(ExecutionInput executionInput, ExecutionResult executionResult) {
-		Assert.notNull(executionInput, "ExecutionInput is required.");
-		Assert.notNull(executionResult, "ExecutionResult is required.");
-		this.executionInput = executionInput;
-		this.executionResult = executionResult;
+	public RequestOutput(ExecutionInput input, ExecutionResult result) {
+		Assert.notNull(input, "ExecutionInput is required.");
+		Assert.notNull(result, "ExecutionResult is required.");
+		this.input = input;
+		this.result = result;
+	}
+
+	/**
+	 * Constructor to re-wrap from transport specific subclass.
+	 */
+	protected RequestOutput(RequestOutput requestOutput) {
+		Assert.notNull(requestOutput, "RequestOutput is required.");
+		this.input = requestOutput.getExecutionInput();
+		this.result = requestOutput.result;
 	}
 
 
@@ -57,37 +66,40 @@ public RequestOutput(ExecutionInput executionInput, ExecutionResult executionRes
 	 * {@link RequestInput} and passed to {@link graphql.GraphQL}.
 	 */
 	public ExecutionInput getExecutionInput() {
-		return this.executionInput;
+		return this.input;
+	}
+
+	protected ExecutionResult getExecutionResult() {
+		return this.result;
 	}
 
-	@Nullable
 	@Override
-	public <T> T getData() {
-		return this.executionResult.getData();
+	public boolean isValid() {
+		return (this.result.isDataPresent() && this.result.getData() != null);
 	}
 
+	@Nullable
 	@Override
-	public boolean isDataPresent() {
-		return this.executionResult.isDataPresent();
+	public <T> T getData() {
+		return this.result.getData();
 	}
 
 	public List<GraphQLError> getErrors() {
-		return this.executionResult.getErrors();
+		return this.result.getErrors();
 	}
 
-	@Nullable
 	public Map<Object, Object> getExtensions() {
-		return this.executionResult.getExtensions();
+		return (this.result.getExtensions() != null ? this.result.getExtensions() : Collections.emptyMap());
 	}
 
 	@Override
-	public Map<String, Object> toSpecification() {
-		return this.executionResult.toSpecification();
+	public Map<String, Object> toMap() {
+		return this.result.toSpecification();
 	}
 
 	@Override
 	public String toString() {
-		return this.executionResult.toString();
+		return this.result.toString();
 	}
 
 }

Diff for: spring-graphql/src/main/java/org/springframework/graphql/client/AbstractGraphQlClientBuilder.java

@@ -116,7 +116,7 @@ private static class Jackson2Configurer {
 				Configuration.defaultConfiguration().mappingProvider().getClass();
 
 		// We only need a MappingProvider:
-		// GraphQlTransport returns ExecutionResult with JSON parsed to Map/List
+		// GraphQlTransport returns GraphQlResponse with already parsed JSON
 
 		static Configuration configure(Configuration config) {
 			MappingProvider provider = config.mappingProvider();