Merge pull request #15 from graphql-java-kickstart/object-conversion-in-response

Move object conversion into response object

Author: oliemansm

.github/workflows/pull-request.yml

@@ -1,8 +1,5 @@
 name: "Pull request"
 on:
-  push:
-    branches-ignore:
-      - master
   pull_request:
     types: [opened, synchronize, reopened]
 

README.md

@@ -15,13 +15,13 @@ When using Maven:
 <dependency>
   <groupId>com.graphql-java-kickstart</groupId>
   <artifactId>graphql-webclient-spring-boot-starter</artifactId>
-  <version>0.2.0</version>
+  <version>0.3.0</version>
 </dependency>
 ```
 
 When using gradle:
 ```groovy
-implementation "com.graphql-java-kickstart:graphql-webclient-spring-boot-starter:0.2.0"
+implementation "com.graphql-java-kickstart:graphql-webclient-spring-boot-starter:0.3.0"
 ```
 
 Configure at least the URL of the GraphQL API to consume:
@@ -31,6 +31,27 @@ graphql:
     url: https://graphql.github.com/graphql
 ```
 
+The starter creates a Spring bean of type `GraphQLWebClient` that you can use in your
+classes to send queries. A simplified example might look like this:
+
+```java
+@Component
+class MyClass {
+  
+  private final GraphQLWebClient graphQLWebClient;
+  
+  MyClass(GraphQLWebClient graphQLWebClient) {
+    this.graphQLWebClient = graphQLWebClient;
+  }
+  
+  void executeSomeQuery() {
+    GraphQLRequest request = GraphQLRequest.builder().query("query { hello }").build();
+    GraphQLResponse response = graphQLWebClient.post(request).block();
+    String value = response.get("hello", String.class);
+  }
+}
+```
+
 ### Using latest Snapshots
 
 You can use the latest Snapshots by configuring the Snapshot repository, see https://www.graphql-java-kickstart.com/servlet/#using-the-latest-development-build.

gradle.properties

@@ -1,4 +1,4 @@
-version=0.3.1-SNAPSHOT
+version=1.0.0-SNAPSHOT
 
 PROJECT_GROUP = com.graphql-java-kickstart
 PROJECT_NAME = graphql-spring-webclient
@@ -15,13 +15,13 @@ LIB_PROJECT_REACTOR_VER = 1.0.1
 
 ### Test libraries
 
-LIB_GRAPHQL_TOOLS_VER = 6.0.0
-LIB_GRAPHQL_SPRING_VER = 7.0.0
-LIB_GRAPHQL_JAVA_VER = 14.0
-LIB_GRAPHQL_SERVLET_VER = 9.0.1
+LIB_GRAPHQL_TOOLS_VER = 6.3.0
+LIB_GRAPHQL_SPRING_VER = 8.1.1
+LIB_GRAPHQL_JAVA_VER = 15.0
+LIB_GRAPHQL_SERVLET_VER = 10.1.0
 
 ### Gradle Plugins
 
-LIB_SPRING_BOOT_VER = 2.2.5.RELEASE
+LIB_SPRING_BOOT_VER = 2.3.6.RELEASE
 LIB_BINTRAY_PLUGIN_VER = 1.8.4
 LIB_RELEASE_PLUGIN_VER = 2.8.1

graphql-webclient/src/main/java/graphql/kickstart/spring/webclient/boot/GraphQLClientException.java

@@ -2,6 +2,8 @@
 
 public class GraphQLClientException extends RuntimeException {
 
-
+  GraphQLClientException(String message, Throwable cause) {
+    super(message, cause);
+  }
 
 }

graphql-webclient/src/main/java/graphql/kickstart/spring/webclient/boot/GraphQLRequest.java

@@ -2,20 +2,14 @@
 
 import org.springframework.http.HttpHeaders;
 
-public interface GraphQLRequest<T> {
+public interface GraphQLRequest {
 
-  static GraphQLRequestBuilder<Object> builder() {
-    return new GraphQLRequestBuilder<>(Object.class);
-  }
-
-  static <T> GraphQLRequestBuilder<T> builder(Class<T> returnType) {
-    return new GraphQLRequestBuilder<>(returnType);
+  static GraphQLRequestBuilder builder() {
+    return new GraphQLRequestBuilder();
   }
 
   GraphQLRequestBody getRequestBody();
 
   HttpHeaders getHeaders();
 
-  Class<T> getReturnType();
-
 }

graphql-webclient/src/main/java/graphql/kickstart/spring/webclient/boot/GraphQLRequestBuilder.java

@@ -10,27 +10,25 @@
 import org.springframework.http.HttpHeaders;
 import org.springframework.util.StreamUtils;
 
-public class GraphQLRequestBuilder<T> {
+public class GraphQLRequestBuilder {
 
   private final HttpHeaders headers = new HttpHeaders();
   private final GraphQLRequestBody.GraphQLRequestBodyBuilder bodyBuilder = GraphQLRequestBody.builder();
-  private final Class<T> returnType;
 
-  GraphQLRequestBuilder(Class<T> returnType) {
-    this.returnType = returnType;
+  GraphQLRequestBuilder() {
   }
 
-  public GraphQLRequestBuilder<T> header(String name, String value) {
+  public GraphQLRequestBuilder header(String name, String value) {
     headers.add(name, value);
     return this;
   }
 
-  public GraphQLRequestBuilder<T> header(String name, String... values) {
+  public GraphQLRequestBuilder header(String name, String... values) {
     headers.addAll(name, Arrays.asList(values));
     return this;
   }
 
-  public GraphQLRequestBuilder<T> resource(String resource) {
+  public GraphQLRequestBuilder resource(String resource) {
     return query(loadQuery(resource));
   }
 
@@ -45,23 +43,23 @@ private String loadResource(Resource resource) throws IOException {
     }
   }
 
-  public GraphQLRequestBuilder<T> query(String query) {
+  public GraphQLRequestBuilder query(String query) {
     bodyBuilder.query(query);
     return this;
   }
 
-  public GraphQLRequestBuilder<T> variables(Object variables) {
+  public GraphQLRequestBuilder variables(Object variables) {
     bodyBuilder.variables(variables);
     return this;
   }
 
-  public GraphQLRequestBuilder<T> operationName(String operationName) {
+  public GraphQLRequestBuilder operationName(String operationName) {
     bodyBuilder.operationName(operationName);
     return this;
   }
 
-  public GraphQLRequest<T> build() {
-    return new GraphQLRequestImpl<>(headers, bodyBuilder.build(), returnType);
+  public GraphQLRequest build() {
+    return new GraphQLRequestImpl(headers, bodyBuilder.build());
   }
 
 }

graphql-webclient/src/main/java/graphql/kickstart/spring/webclient/boot/GraphQLRequestImpl.java

@@ -4,10 +4,9 @@
 import org.springframework.http.HttpHeaders;
 
 @Value
-class GraphQLRequestImpl<T> implements GraphQLRequest<T> {
+class GraphQLRequestImpl implements GraphQLRequest {
 
   HttpHeaders headers;
   GraphQLRequestBody requestBody;
-  Class<T> returnType;
 
 }

graphql-webclient/src/main/java/graphql/kickstart/spring/webclient/boot/GraphQLResponse.java

@@ -1,27 +1,91 @@
 package graphql.kickstart.spring.webclient.boot;
 
+import static java.util.Collections.emptyList;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.Collections;
 import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import lombok.Data;
+import java.util.Optional;
+import lombok.Getter;
 
-@Data
 public class GraphQLResponse {
 
-  private Map<String, Object> data;
-  private List<GraphQLError> errors;
+  public static final String ERRORS_FIELD = "errors";
 
-  Object getFirstObject() {
-    validateNoErrors();
+  private final JsonNode data;
+  @Getter
+  private final List<GraphQLError> errors;
+  private final ObjectMapper objectMapper;
 
-    if (data != null && !data.isEmpty()) {
-      return data.entrySet().stream().findFirst().map(Entry::getValue).orElse(null);
+  GraphQLResponse(String rawResponse, ObjectMapper objectMapper) {
+    this.objectMapper = objectMapper;
+
+    JsonNode tree = readTree(rawResponse);
+    errors = readErrors(tree);
+    data = tree.hasNonNull("data") ? tree.get("data") : null;
+  }
+
+  private JsonNode readTree(String rawResponse) {
+    try {
+      return objectMapper.readTree(rawResponse);
+    } catch (JsonProcessingException e) {
+      throw new GraphQLClientException("Cannot read response '" + rawResponse + "'", e);
+    }
+  }
+
+  private List<GraphQLError> readErrors(JsonNode tree) {
+    if (tree.hasNonNull(ERRORS_FIELD)) {
+      return convertList(tree.get(ERRORS_FIELD), GraphQLError.class);
+    }
+    return emptyList();
+  }
+
+  private <T> List<T> convertList(JsonNode node, Class<T> type) {
+    return objectMapper.convertValue(node, constructListType(type));
+  }
+
+  private JavaType constructListType(Class<?> type) {
+    return objectMapper.getTypeFactory().constructCollectionType(List.class, type);
+  }
+
+  public <T> T get(String fieldName, Class<T> type) {
+    if (data != null && data.hasNonNull(fieldName)) {
+      return objectMapper.convertValue(data.get(fieldName), type);
     }
     return null;
   }
 
-  private void validateNoErrors() {
-    if (errors != null && !errors.isEmpty()) {
+  public <T> T getFirst(Class<T> type) {
+    return getFirstDataEntry().map(it -> objectMapper.convertValue(it, type)).orElse(null);
+  }
+
+  private Optional<JsonNode> getFirstDataEntry() {
+    if (data != null && !data.isEmpty()) {
+      return Optional.ofNullable(data.fields().next().getValue());
+    }
+    return Optional.empty();
+  }
+
+  public <T> List<T> getList(String fieldName, Class<T> type) {
+    if (data != null && data.hasNonNull(fieldName)) {
+      return convertList(data.get(fieldName), type);
+    }
+    return emptyList();
+  }
+
+  @SuppressWarnings("unchecked")
+  public <T> List<T> getFirstList(Class<T> type) {
+    return getFirstDataEntry()
+        .map(it -> convertList(it, type))
+        .map(List.class::cast)
+        .orElseGet(Collections::emptyList);
+  }
+
+  public void validateNoErrors() {
+    if (!errors.isEmpty()) {
       throw new GraphQLErrorsException(errors);
     }
   }

graphql-webclient/src/main/java/graphql/kickstart/spring/webclient/boot/GraphQLWebClient.java

@@ -16,12 +16,10 @@ static GraphQLWebClient newInstance(WebClient webClient, ObjectMapper objectMapp
 
   <T> Mono<T> post(String resource, Map<String, Object> variables, Class<T> returnType);
 
-  Mono<GraphQLResponse> post(GraphQLRequest<?> request);
+  Mono<GraphQLResponse> post(GraphQLRequest request);
 
   <T> Flux<T> flux(String resource, Class<T> returnType);
 
   <T> Flux<T> flux(String resource, Map<String, Object> variables, Class<T> returnType);
 
-  @SuppressWarnings("unchecked")
-  <T> Flux<T> flux(GraphQLRequest<T> request);
 }

graphql-webclient/src/main/java/graphql/kickstart/spring/webclient/boot/GraphQLWebClientImpl.java

@@ -1,10 +1,8 @@
 package graphql.kickstart.spring.webclient.boot;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import java.util.List;
 import java.util.Map;
 import lombok.RequiredArgsConstructor;
-import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.MediaType;
 import org.springframework.web.reactive.function.client.WebClient;
@@ -25,23 +23,22 @@ public <T> Mono<T> post(String resource, Class<T> returnType) {
 
   @Override
   public <T> Mono<T> post(String resource, Map<String, Object> variables, Class<T> returnType) {
-    return execute(resource, variables).map(it -> readValue(it, returnType));
-  }
-
-  @SneakyThrows
-  private <T> T readValue(Object value, Class<T> returnType) {
-    log.trace("Read value: {}", value);
-    return objectMapper.convertValue(value, returnType);
+    return post(resource, variables)
+        .flatMap(it -> {
+          it.validateNoErrors();
+          return Mono.justOrEmpty(it.getFirst(returnType));
+        });
   }
 
   @Override
-  public Mono<GraphQLResponse> post(GraphQLRequest<?> request) {
-    WebClient.RequestBodySpec spec = webClient.post()
-            .contentType(MediaType.APPLICATION_JSON);
-    request.getHeaders().forEach((header, values) -> spec.header(header, values.toArray(new String[0])));
+  public Mono<GraphQLResponse> post(GraphQLRequest request) {
+    WebClient.RequestBodySpec spec = webClient.post().contentType(MediaType.APPLICATION_JSON);
+    request.getHeaders()
+        .forEach((header, values) -> spec.header(header, values.toArray(new String[0])));
     return spec.bodyValue(request.getRequestBody())
-            .retrieve()
-            .bodyToMono(GraphQLResponse.class);
+        .retrieve()
+        .bodyToMono(String.class)
+        .map(it -> new GraphQLResponse(it, objectMapper));
   }
 
   @Override
@@ -52,38 +49,17 @@ public <T> Flux<T> flux(String resource, Class<T> returnType) {
   @Override
   @SuppressWarnings("unchecked")
   public <T> Flux<T> flux(String resource, Map<String, Object> variables, Class<T> returnType) {
-    Mono<Object> responseObject = execute(resource, variables);
-
-    return responseObject.map(List.class::cast)
-        .flatMapMany(Flux::fromIterable)
-        .map(it -> readValue(it, returnType));
-  }
-
-  @Override
-  @SuppressWarnings("unchecked")
-  public <T> Flux<T> flux(GraphQLRequest<T> request) {
-    Mono<Object> responseObject = execute(request);
-    return responseObject.map(List.class::cast)
-        .flatMapMany(Flux::fromIterable)
-        .map(it -> readValue(it, request.getReturnType()));
+    return post(resource, variables)
+        .map(it -> it.getFirstList(returnType))
+        .flatMapMany(Flux::fromIterable);
   }
 
-  private Mono<Object> execute(String resource, Map<String, Object> variables) {
-    GraphQLRequest<?> request = GraphQLRequest.builder(Object.class)
+  private Mono<GraphQLResponse> post(String resource, Map<String, Object> variables) {
+    GraphQLRequest request = GraphQLRequest.builder()
         .resource(resource)
         .variables(variables)
         .build();
-    return execute(request);
-  }
-
-  private Mono<Object> execute(GraphQLRequest<?> request) {
-    WebClient.RequestBodySpec spec = webClient.post()
-        .contentType(MediaType.APPLICATION_JSON);
-    request.getHeaders().forEach((header, values) -> spec.header(header, values.toArray(new String[0])));
-    return spec.bodyValue(request.getRequestBody())
-        .retrieve()
-        .bodyToMono(GraphQLResponse.class)
-        .flatMap(it -> Mono.justOrEmpty(it.getFirstObject()));
+    return post(request);
   }
 
 }