Move object conversion into response object

Author: oliemansm

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

@@ -1,7 +1,12 @@
 package graphql.kickstart.spring.webclient.boot;
 
-public class GraphQLClientException extends RuntimeException {
+import lombok.NoArgsConstructor;
 
+@NoArgsConstructor
+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,26 +1,86 @@
 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 java.util.Optional;
 import lombok.Data;
 
 @Data
 public class GraphQLResponse {
 
-  private Map<String, Object> data;
-  private List<GraphQLError> errors;
+  private final JsonNode data;
+  private final List<GraphQLError> errors;
+  private final String rawResponse;
+  private final ObjectMapper objectMapper;
 
-  Object getFirstObject() {
-    validateNoErrors();
+  GraphQLResponse(String rawResponse, ObjectMapper objectMapper) {
+    this.rawResponse = rawResponse;
+    this.objectMapper = objectMapper;
 
-    if (data != null && !data.isEmpty()) {
-      return data.entrySet().stream().findFirst().map(Entry::getValue).orElse(null);
+    JsonNode tree = readTree(rawResponse);
+    errors = readErrors(tree);
+    data = tree.get("data");
+  }
+
+  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.has("errors")) {
+      return objectMapper.convertValue(tree.get("errors"), constructListType(GraphQLError.class));
+    }
+    return emptyList();
+  }
+
+  public <T> T get(String fieldName, Class<T> type) {
+    if (data != null && data.has(fieldName) && data.get(fieldName) != null) {
+      return objectMapper.convertValue(data.get(fieldName), type);
     }
     return null;
   }
 
-  private void validateNoErrors() {
+  public <T> T getFirstObject(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.has(fieldName) && data.get(fieldName) != null) {
+      return objectMapper.convertValue(data.get(fieldName), constructListType(type));
+    }
+    return emptyList();
+  }
+
+  @SuppressWarnings("unchecked")
+  public <T> List<T> getFirstList(Class<T> type) {
+    return getFirstDataEntry()
+        .map(it -> objectMapper.convertValue(it, constructListType(type)))
+        .map(List.class::cast)
+        .orElseGet(Collections::emptyList);
+  }
+
+  private JavaType constructListType(Class<?> type) {
+    return objectMapper.getTypeFactory().constructCollectionType(List.class, type);
+  }
+
+  public void validateNoErrors() {
     if (errors != null && !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.getFirstObject(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);
   }
 
 }