Rename Web[Input|Output] to WebGraphQl[Request|Response]

See gh-332

Author: rstoyanchev

spring-graphql-docs/src/docs/asciidoc/index.adoc

@@ -130,12 +130,12 @@ transformation of the `graphql.ExecutionInput`:
 class MyInterceptor implements WebInterceptor {
 
 	@Override
-	public Mono<WebOutput> intercept(WebInput webInput, WebInterceptorChain chain) {
-		webInput.configureExecutionInput((executionInput, builder) -> {
+	public Mono<WebGraphQlResponse> intercept(WebGraphQlRequest request, WebInterceptorChain chain) {
+		request.configureExecutionInput((executionInput, builder) -> {
 			Map<String, Object> map = ... ;
 			return builder.extensions(map).build();
 		});
-		return chain.next(webInput);
+		return chain.next(request);
 	}
 }
 ----
@@ -148,12 +148,12 @@ the `graphql.ExecutionResult`:
 class MyInterceptor implements WebInterceptor {
 
 	@Override
-	public Mono<WebOutput> intercept(WebInput webInput, WebInterceptorChain chain) {
-		return chain.next(webInput)
-				.map(webOutput -> {
-					Object data = webOutput.getData();
+	public Mono<WebGraphQlResponse> intercept(WebGraphQlRequest request, WebInterceptorChain chain) {
+		return chain.next(request)
+				.map(response -> {
+					Object data = response.getData();
 					Object updatedData = ... ;
-					return webOutput.transform(builder -> builder.data(updatedData));
+					return response.transform(builder -> builder.data(updatedData));
 				});
 	}
 }

spring-graphql-test/src/main/java/org/springframework/graphql/test/tester/WebGraphQlHandlerTransport.java

@@ -18,15 +18,14 @@
 
 
 import java.net.URI;
+import java.util.Map;
 
 import reactor.core.publisher.Mono;
 
 import org.springframework.graphql.ExecutionGraphQlRequest;
 import org.springframework.graphql.ExecutionGraphQlResponse;
-import org.springframework.graphql.GraphQlRequest;
 import org.springframework.graphql.web.WebGraphQlHandler;
-import org.springframework.graphql.web.WebInput;
-import org.springframework.graphql.web.WebOutput;
+import org.springframework.graphql.web.WebGraphQlRequest;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.codec.CodecConfigurer;
 import org.springframework.lang.Nullable;
@@ -77,9 +76,15 @@ public CodecConfigurer getCodecConfigurer() {
 
 
 	@Override
-	protected Mono<ExecutionGraphQlResponse> executeInternal(ExecutionGraphQlRequest request) {
-		WebInput input = new WebInput(this.url, this.headers, request.toMap(), idGenerator.generateId().toString(), null);
-		return this.graphQlHandler.handleRequest(input).cast(ExecutionGraphQlResponse.class);
+	protected Mono<ExecutionGraphQlResponse> executeInternal(ExecutionGraphQlRequest executionRequest) {
+
+		String id = idGenerator.generateId().toString();
+		Map<String, Object> body = executionRequest.toMap();
+
+		WebGraphQlRequest webExecutionRequest =
+				new WebGraphQlRequest(this.url, this.headers, body, id, null);
+
+		return this.graphQlHandler.handleRequest(webExecutionRequest).cast(ExecutionGraphQlResponse.class);
 	}
 
 }

spring-graphql-test/src/test/java/org/springframework/graphql/test/tester/WebGraphQlTesterBuilderTests.java

@@ -37,10 +37,10 @@
 import org.springframework.graphql.ExecutionGraphQlResponse;
 import org.springframework.graphql.support.DefaultExecutionGraphQlResponse;
 import org.springframework.graphql.support.DocumentSource;
+import org.springframework.graphql.web.WebGraphQlRequest;
 import org.springframework.graphql.web.TestWebSocketClient;
 import org.springframework.graphql.web.TestWebSocketConnection;
 import org.springframework.graphql.web.WebGraphQlHandler;
-import org.springframework.graphql.web.WebInput;
 import org.springframework.graphql.web.WebInterceptor;
 import org.springframework.graphql.web.webflux.GraphQlHttpHandler;
 import org.springframework.graphql.web.webflux.GraphQlWebSocketHandler;
@@ -60,8 +60,8 @@
 
 /**
  * Tests for the builders of Web {@code GraphQlTester} extensions, using a
- * {@link WebInterceptor} to capture the WebInput on the server side, and
- * optionally returning a mock response, or an empty response.
+ * {@link WebInterceptor} to capture the WebGraphQlRequest on the server side,
+ * and optionally returning a mock response, or an empty response.
  *
  * <ul>
  * <li>{@link HttpGraphQlTester} via {@link WebTestClient} to {@link GraphQlHttpHandler}
@@ -95,24 +95,24 @@ void mutateUrlHeaders(TesterBuilderSetup builderSetup) {
 		WebGraphQlTester tester = builder.build();
 		tester.document(DOCUMENT).execute();
 
-		WebInput input = builderSetup.getWebInput();
-		assertThat(input.getUri().toString()).isEqualTo(url);
-		assertThat(input.getHeaders().get("h")).containsExactly("one");
+		WebGraphQlRequest request = builderSetup.getWebGraphQlRequest();
+		assertThat(request.getUri().toString()).isEqualTo(url);
+		assertThat(request.getHeaders().get("h")).containsExactly("one");
 
 		// Mutate to add header value
 		builder = tester.mutate().headers(headers -> headers.add("h", "two"));
 		tester = builder.build();
 		tester.document(DOCUMENT).execute();
-		assertThat(builderSetup.getWebInput().getHeaders().get("h")).containsExactly("one", "two");
+		assertThat(builderSetup.getWebGraphQlRequest().getHeaders().get("h")).containsExactly("one", "two");
 
 		// Mutate to replace header
 		builder = tester.mutate().header("h", "three", "four");
 		tester = builder.build();
 		tester.document(DOCUMENT).execute();
 
-		input = builderSetup.getWebInput();
-		assertThat(input.getUri().toString()).isEqualTo(url);
-		assertThat(input.getHeaders().get("h")).containsExactly("three", "four");
+		request = builderSetup.getWebGraphQlRequest();
+		assertThat(request.getUri().toString()).isEqualTo(url);
+		assertThat(request.getHeaders().get("h")).containsExactly("three", "four");
 	}
 
 	@Test
@@ -125,23 +125,23 @@ void mutateWebTestClientViaConsumer() {
 
 		HttpGraphQlTester tester = builder.build();
 		tester.document(DOCUMENT).execute();
-		assertThat(testerSetup.getWebInput().getHeaders().get("h")).containsExactly("one");
+		assertThat(testerSetup.getWebGraphQlRequest().getHeaders().get("h")).containsExactly("one");
 
 		// Mutate to add header value
 		HttpGraphQlTester.Builder<?> builder2 = tester.mutate()
 				.webTestClient(testClientBuilder -> testClientBuilder.defaultHeaders(h -> h.add("h", "two")));
 
 		tester = builder2.build();
 		tester.document(DOCUMENT).execute();
-		assertThat(testerSetup.getWebInput().getHeaders().get("h")).containsExactly("one", "two");
+		assertThat(testerSetup.getWebGraphQlRequest().getHeaders().get("h")).containsExactly("one", "two");
 
 		// Mutate to replace header
 		HttpGraphQlTester.Builder<?> builder3 = tester.mutate()
 				.webTestClient(testClientBuilder -> testClientBuilder.defaultHeader("h", "three"));
 
 		tester = builder3.build();
 		tester.document(DOCUMENT).execute();
-		assertThat(testerSetup.getWebInput().getHeaders().get("h")).containsExactly("three");
+		assertThat(testerSetup.getWebGraphQlRequest().getHeaders().get("h")).containsExactly("three");
 	}
 
 	@ParameterizedTest
@@ -156,14 +156,14 @@ void mutateDocumentSource(TesterBuilderSetup builderSetup) {
 		WebGraphQlTester tester = builder.build();
 		tester.documentName("name").execute();
 
-		WebInput input = builderSetup.getWebInput();
+		WebGraphQlRequest input = builderSetup.getWebGraphQlRequest();
 		assertThat(input.getDocument()).isEqualTo(DOCUMENT);
 
 		// Mutate
 		tester = tester.mutate().build();
 		tester.documentName("name").execute();
 
-		input = builderSetup.getWebInput();
+		input = builderSetup.getWebGraphQlRequest();
 		assertThat(input.getDocument()).isEqualTo(DOCUMENT);
 	}
 
@@ -202,14 +202,14 @@ private interface TesterBuilderSetup {
 
 		void setMockResponse(String document, ExecutionResult result);
 
-		WebInput getWebInput();
+		WebGraphQlRequest getWebGraphQlRequest();
 
 	}
 
 
 	private static class WebBuilderSetup implements TesterBuilderSetup {
 
-		private WebInput webInput;
+		private WebGraphQlRequest request;
 
 		private final Map<String, ExecutionGraphQlResponse> responses = new HashMap<>();
 
@@ -235,8 +235,8 @@ protected WebGraphQlHandler webGraphQlHandler() {
 						return Mono.just(response);
 					})
 					.interceptor((input, chain) -> {
-						this.webInput = input;
-						return chain.next(webInput);
+						this.request = input;
+						return chain.next(request);
 					})
 					.build();
 		}
@@ -248,8 +248,8 @@ public void setMockResponse(String document, ExecutionResult result) {
 		}
 
 		@Override
-		public WebInput getWebInput() {
-			return this.webInput;
+		public WebGraphQlRequest getWebGraphQlRequest() {
+			return this.request;
 		}
 
 	}

spring-graphql/src/main/java/org/springframework/graphql/ExecutionGraphQlRequest.java

@@ -82,8 +82,8 @@ public interface ExecutionGraphQlRequest extends GraphQlRequest {
 	/**
 	 * Provide a {@code BiFunction} to help initialize the {@link ExecutionInput}
 	 * passed to {@link graphql.GraphQL}. The {@code ExecutionInput} is first
-	 * pre-populated with values from "this" {@code RequestInput}, and is then
-	 * customized with the functions provided here.
+	 * pre-populated with values from "this" {@code ExecutionGraphQlRequest}, and
+	 * is then customized with the functions provided here.
 	 * @param configurer a {@code BiFunction} that accepts the
 	 * {@code ExecutionInput} initialized so far, and a builder to customize it.
 	 */
@@ -92,8 +92,8 @@ public interface ExecutionGraphQlRequest extends GraphQlRequest {
 	/**
 	 * Create the {@link ExecutionInput} to pass to {@link graphql.GraphQL}.
 	 * passed to {@link graphql.GraphQL}. The {@code ExecutionInput} is populated
-	 * with values from "this" {@code RequestInput}, and then customized with
-	 * functions provided via {@link #configureExecutionInput(BiFunction)}.
+	 * with values from "this" {@code ExecutionGraphQlRequest}, and then customized
+	 * with functions provided via {@link #configureExecutionInput(BiFunction)}.
 	 * @return the resulting {@code ExecutionInput}
 	 */
 	ExecutionInput toExecutionInput();

spring-graphql/src/main/java/org/springframework/graphql/data/query/QuerydslDataFetcher.java

@@ -341,8 +341,8 @@ public Builder<T, R> sortBy(Sort sort) {
 		 * {@link #autoRegistrationConfigurer(List, List) auto-registration}.
 		 * For manual registration, you will need to use this method to apply it.
 		 *
-		 * @param customizer to customize GraphQL request input to Querydsl
-		 * Predicate binding with
+		 * @param customizer to customize the binding of the GraphQL request to
+		 * Querydsl Predicate
 		 * @return a new {@link Builder} instance with all previously configured
 		 * options and {@code QuerydslBinderCustomizer} applied
 		 */

spring-graphql/src/main/java/org/springframework/graphql/support/DefaultExecutionGraphQlRequest.java

@@ -35,8 +35,8 @@
  * or WebSocket handler) assigned {@link #getId() id} and {@link #getLocale()
  * locale} in the addition to the {@code GraphQlRequest} inputs.
  *
- * <p>{@code RequestInput} supports the initialization of {@link ExecutionInput}
- * that is passed to {@link graphql.GraphQL}. You can customize that via
+ * <p>Supports the initialization of {@link ExecutionInput} that is passed to
+ * {@link graphql.GraphQL}. You can customize that via
  * {@link #configureExecutionInput(BiFunction)}.
  *
  * @author Rossen Stoyanchev

spring-graphql/src/main/java/org/springframework/graphql/web/DefaultWebGraphQlHandlerBuilder.java

@@ -89,18 +89,18 @@ public WebGraphQlHandler.Builder threadLocalAccessors(List<ThreadLocalAccessor>
 	public WebGraphQlHandler build() {
 
 		WebInterceptorChain endOfChain =
-				webInput -> this.service.execute(webInput).map(WebOutput::new);
+				request -> this.service.execute(request).map(WebGraphQlResponse::new);
 
 		WebInterceptorChain chain = this.interceptors.stream()
 				.reduce(WebInterceptor::andThen)
-				.map(interceptor -> (WebInterceptorChain) (input) -> interceptor.intercept(input, endOfChain))
+				.map(interceptor -> (WebInterceptorChain) (request) -> interceptor.intercept(request, endOfChain))
 				.orElse(endOfChain);
 
 		return new WebGraphQlHandler() {
 
 			@Override
-			public Mono<WebOutput> handleRequest(WebInput input) {
-				return chain.next(input)
+			public Mono<WebGraphQlResponse> handleRequest(WebGraphQlRequest request) {
+				return chain.next(request)
 						.contextWrite(context -> {
 							if (!CollectionUtils.isEmpty(accessors)) {
 								ThreadLocalAccessor accessor = ThreadLocalAccessor.composite(accessors);

spring-graphql/src/main/java/org/springframework/graphql/web/WebGraphQlHandler.java

@@ -35,11 +35,11 @@ public interface WebGraphQlHandler {
 
 
 	/**
-	 * Execute the given request and return the resulting output.
-	 * @param input the GraphQL request input container
-	 * @return the result from execution
+	 * Execute the given request and return the response.
+	 * @param request the request to execute
+	 * @return the response
 	 */
-	Mono<WebOutput> handleRequest(WebInput input);
+	Mono<WebGraphQlResponse> handleRequest(WebGraphQlRequest request);
 
 	/**
 	 * Return the single interceptor of type {@link WebSocketInterceptor} among

spring-graphql/src/main/java/org/springframework/graphql/web/WebInput.java renamed to spring-graphql/src/main/java/org/springframework/graphql/web/WebGraphQlRequest.java

@@ -20,6 +20,7 @@
 import java.util.Locale;
 import java.util.Map;
 
+import org.springframework.graphql.ExecutionGraphQlRequest;
 import org.springframework.graphql.support.DefaultExecutionGraphQlRequest;
 import org.springframework.http.HttpHeaders;
 import org.springframework.lang.Nullable;
@@ -30,41 +31,46 @@
 import org.springframework.web.util.UriComponentsBuilder;
 
 /**
- * Container for the input of a GraphQL request over HTTP or WebSocket, including
- * the URL and HTTP headers, along with the query, operation name, and variables
- * from the body of the request. For WebSocket, the URL and HTTP headers  are
- * those of the WebSocket handshake request.
+ * {@link org.springframework.graphql.GraphQlRequest} implementation for server
+ * handling over HTTP or WebSocket. Provides access to the URL and headers of
+ * the underlying request. For WebSocket, these are the URL and headers of the
+ * HTTP handshake request.
  *
  * @author Rossen Stoyanchev
  * @since 1.0.0
  */
-public class WebInput extends DefaultExecutionGraphQlRequest {
+public class WebGraphQlRequest extends DefaultExecutionGraphQlRequest implements ExecutionGraphQlRequest {
 
 	private final UriComponents uri;
 
 	private final HttpHeaders headers;
 
+
 	/**
 	 * Create an instance.
 	 * @param uri the URL for the HTTP request or WebSocket handshake
 	 * @param headers the HTTP request headers
 	 * @param body the deserialized content of the GraphQL request
 	 * @param id an identifier for the GraphQL request, e.g. a subscription id for
-* correlating request and response messages, or it could be an id associated with the
+	 * correlating request and response messages, or it could be an id associated with the
 	 * @param locale the locale from the HTTP request, if any
 	 */
-	public WebInput(URI uri, HttpHeaders headers, Map<String, Object> body, String id, @Nullable Locale locale) {
+	public WebGraphQlRequest(
+			URI uri, HttpHeaders headers, Map<String, Object> body, String id, @Nullable Locale locale) {
+
 		super(getKey("query", body), getKey("operationName", body), getKey("variables", body), id, locale);
+
 		Assert.notNull(uri, "URI is required'");
 		Assert.notNull(headers, "HttpHeaders is required'");
+
 		this.uri = UriComponentsBuilder.fromUri(uri).build(true);
 		this.headers = headers;
 	}
 
 	@SuppressWarnings("unchecked")
 	private static <T> T getKey(String key, Map<String, Object> body) {
 		if (key.equals("query") && !StringUtils.hasText((String) body.get(key))) {
-			throw new ServerWebInputException("No \"query\" in the request input");
+			throw new ServerWebInputException("No \"query\" in the request document");
 		}
 		return (T) body.get(key);
 	}