Merge remote-tracking branch 'origin/master'

# Conflicts:
#	graphiql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphiql/boot/GraphiQLController.java

Author: oliemansm

README.md

@@ -106,7 +106,11 @@ Available Spring Boot configuration parameters (either `application.yml` or `app
 ```yaml
 graphiql:
     mapping: /graphiql
-    endpoint: /graphql
+    endpoint:
+      graphql: /graphql
+      subscriptions: /subscriptions
+    static:
+      basePath: /
     enabled: true
     pageTitle: GraphiQL
     cdn:

gradle.properties

@@ -40,8 +40,8 @@ LIB_GRAPHQL_JAVA_VER = 9.2
 LIB_JUNIT_VER = 4.12
 LIB_SPRING_CORE_VER = 5.0.4.RELEASE
 LIB_SPRING_BOOT_VER = 2.0.4.RELEASE
-LIB_GRAPHQL_SERVLET_VER = 6.1.3-SNAPSHOT
-LIB_GRAPHQL_JAVA_TOOLS_VER = 5.2.3
+LIB_GRAPHQL_SERVLET_VER = 6.1.3
+LIB_GRAPHQL_JAVA_TOOLS_VER = 5.2.4
 LIB_COMMONS_IO_VER = 2.6
 
 GRADLE_WRAPPER_VER = 4.7

graphiql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphiql/boot/GraphiQLController.java

@@ -33,9 +33,15 @@ public class GraphiQLController {
 
     private static final String CDNJS_CLOUDFLARE_COM_AJAX_LIBS_GRAPHIQL = "//cdnjs.cloudflare.com/ajax/libs/graphiql/";
 
-    @Value("${graphiql.endpoint:/graphql}")
+    @Value("${graphiql.endpoint.graphql:/graphql}")
     private String graphqlEndpoint;
 
+    @Value("${graphiql.endpoint.subscriptions:/subscriptions}")
+    private String subscriptionsEndpoint;
+
+    @Value("${graphiql.static.basePath:/}")
+    private String staticBasePath;
+
     @Value("${graphiql.pageTitle:GraphiQL}")
     private String pageTitle;
 
@@ -87,17 +93,21 @@ private void addIfAbsent(Properties headerProperties, String header) {
     public void graphiql(HttpServletRequest request, HttpServletResponse response, @PathVariable Map<String, String> params) throws IOException {
         response.setContentType("text/html; charset=UTF-8");
 
-        String endpoint = constructGraphQlEndpoint(request, params);
-        Map<String, String> replacements = getReplacements(endpoint);
+        Map<String, String> replacements = getReplacements(
+                constructGraphQlEndpoint(request, params),
+                request.getContextPath() + subscriptionsEndpoint,
+                request.getContextPath() + staticBasePath
+        );
 
         String populatedTemplate = StrSubstitutor.replace(template, replacements);
-        populatedTemplate = addContextPathIfEnabled(request, populatedTemplate);
         response.getOutputStream().write(populatedTemplate.getBytes(Charset.defaultCharset()));
     }
 
-    private Map<String, String> getReplacements(String endpoint) {
+    private Map<String, String> getReplacements(String graphqlEndpoint, String subscriptionsEndpoint, String staticBasePath) {
         Map<String, String> replacements = new HashMap<>();
-        replacements.put("graphqlEndpoint", endpoint);
+        replacements.put("graphqlEndpoint", graphqlEndpoint);
+        replacements.put("subscriptionsEndpoint", subscriptionsEndpoint);
+        replacements.put("staticBasePath", staticBasePath);
         replacements.put("pageTitle", pageTitle);
         replacements.put("graphiqlCssUrl", graphiqlUrl("graphiql.min.css"));
         replacements.put("graphiqlJsUrl", graphiqlUrl("graphiql.min.js"));
@@ -110,17 +120,7 @@ private String graphiqlUrl(String filename) {
         if (graphiqlCdnEnabled && StringUtils.isNotBlank(graphiqlCdnVersion)) {
             return CDNJS_CLOUDFLARE_COM_AJAX_LIBS_GRAPHIQL + graphiqlCdnVersion + "/" + filename;
         }
-        return "/vendor/" + filename;
-    }
-
-    private String addContextPathIfEnabled(HttpServletRequest request, String populatedTemplate) {
-        if (StringUtils.isNotBlank(request.getContextPath())) {
-            String vendorPathWithContext = String.format("%s/vendor", request.getContextPath());
-            populatedTemplate = populatedTemplate
-                    .replaceAll("src=\"/vendor", "src=\"" + vendorPathWithContext)
-                    .replaceAll("href=\"/vendor", "href=\"" + vendorPathWithContext);
-        }
-        return populatedTemplate;
+        return staticBasePath + "vendor/" + filename;
     }
 
     private String constructGraphQlEndpoint(HttpServletRequest request, @RequestParam Map<String, String> params) {

graphiql-spring-boot-autoconfigure/src/main/resources/graphiql.html

@@ -24,10 +24,10 @@
         }
     </style>
 
-    <script src="/vendor/es6-promise.auto.min.js"></script>
-    <script src="/vendor/fetch.min.js"></script>
-    <script src="/vendor/react.min.js"></script>
-    <script src="/vendor/react-dom.min.js"></script>
+    <script src="${staticBasePath}vendor/es6-promise.auto.min.js"></script>
+    <script src="${staticBasePath}vendor/fetch.min.js"></script>
+    <script src="${staticBasePath}vendor/react.min.js"></script>
+    <script src="${staticBasePath}vendor/react-dom.min.js"></script>
 
     <link rel="stylesheet" href="${graphiqlCssUrl}"/>
     <script src="${graphiqlJsUrl}"></script>
@@ -121,7 +121,7 @@
         newUri = "ws:";
     }
     newUri += "//" + loc.host;
-    newUri += "/subscriptions";
+    newUri += "${subscriptionsEndpoint}";
 
     var subscriptionsClient = new window.SubscriptionsTransportWs.SubscriptionClient(newUri, { reconnect: true });
     var subscriptionsFetcher = window.GraphiQLSubscriptionsFetcher.graphQLFetcher(subscriptionsClient, graphQLFetcher);

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/GraphQLJavaToolsAutoConfiguration.java

@@ -1,18 +1,26 @@
 package com.oembedler.moon.graphql.boot;
 
 import com.coxautodev.graphql.tools.*;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
+import com.fasterxml.jackson.module.kotlin.KotlinModule;
+import graphql.language.FieldDefinition;
 import graphql.schema.GraphQLScalarType;
 import graphql.schema.GraphQLSchema;
 import graphql.servlet.GraphQLSchemaProvider;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 import java.io.IOException;
 import java.util.List;
+import java.util.Optional;
+
+import static com.coxautodev.graphql.tools.SchemaParserOptions.newOptions;
 
 /**
  * @author Andrew Potter
@@ -39,7 +47,11 @@ public SchemaStringProvider schemaStringProvider() {
     @Bean
     @ConditionalOnBean({GraphQLResolver.class})
     @ConditionalOnMissingBean
-    public SchemaParser schemaParser(List<GraphQLResolver<?>> resolvers, SchemaStringProvider schemaStringProvider) throws IOException {
+    public SchemaParser schemaParser(
+            List<GraphQLResolver<?>> resolvers,
+            SchemaStringProvider schemaStringProvider,
+            Optional<PerFieldObjectMapperProvider> perFieldObjectMapperProvider
+    ) throws IOException {
         SchemaParserBuilder builder = dictionary != null ? new SchemaParserBuilder(dictionary) : new SchemaParserBuilder();
 
         List<String> schemaStrings = schemaStringProvider.schemaStrings();
@@ -51,12 +63,26 @@ public SchemaParser schemaParser(List<GraphQLResolver<?>> resolvers, SchemaStrin
 
         if (options != null) {
             builder.options(options);
+        }else if(perFieldObjectMapperProvider.isPresent()) {
+            final SchemaParserOptions.Builder optionsBuilder =
+                    newOptions().objectMapperProvider(perFieldObjectMapperProvider.get());
+            builder.options(optionsBuilder.build());
         }
 
         return builder.resolvers(resolvers)
                 .build();
     }
 
+    @Bean
+    @ConditionalOnMissingBean
+    @ConditionalOnProperty(value="graphql.tools.use-default-objectmapper", havingValue = "true", matchIfMissing = true)
+    public PerFieldObjectMapperProvider perFieldObjectMapperProvider(ObjectMapper objectMapper) {
+        objectMapper
+                .registerModule(new Jdk8Module())
+                .registerModule(new KotlinModule());
+        return fieldDefinition -> objectMapper;
+    }
+
 
     @Bean
     @ConditionalOnBean(SchemaParser.class)

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/GraphQLWebAutoConfiguration.java

@@ -19,18 +19,38 @@
 
 package com.oembedler.moon.graphql.boot;
 
+import com.coxautodev.graphql.tools.PerFieldObjectMapperProvider;
+import com.fasterxml.jackson.databind.InjectableValues;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import graphql.execution.AsyncExecutionStrategy;
 import graphql.execution.ExecutionStrategy;
 import graphql.execution.SubscriptionExecutionStrategy;
 import graphql.execution.instrumentation.ChainedInstrumentation;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.execution.preparsed.PreparsedDocumentProvider;
 import graphql.schema.GraphQLSchema;
-import graphql.servlet.*;
+import graphql.servlet.AbstractGraphQLHttpServlet;
+import graphql.servlet.DefaultExecutionStrategyProvider;
+import graphql.servlet.DefaultGraphQLSchemaProvider;
+import graphql.servlet.ExecutionStrategyProvider;
+import graphql.servlet.GraphQLContextBuilder;
+import graphql.servlet.GraphQLErrorHandler;
+import graphql.servlet.GraphQLInvocationInputFactory;
+import graphql.servlet.GraphQLObjectMapper;
+import graphql.servlet.GraphQLQueryInvoker;
+import graphql.servlet.GraphQLRootObjectBuilder;
+import graphql.servlet.GraphQLSchemaProvider;
+import graphql.servlet.GraphQLServletListener;
+import graphql.servlet.ObjectMapperConfigurer;
+import graphql.servlet.ObjectMapperProvider;
+import graphql.servlet.SimpleGraphQLHttpServlet;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
-import org.springframework.boot.autoconfigure.condition.*;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.boot.web.servlet.ServletRegistrationBean;
 import org.springframework.context.annotation.Bean;
@@ -45,6 +65,8 @@
 import java.util.Map;
 import java.util.Optional;
 
+import static graphql.servlet.GraphQLObjectMapper.newBuilder;
+
 
 /**
  * @author <a href="mailto:java.lang.RuntimeException@gmail.com">oEmbedler Inc.</a>
@@ -182,20 +204,35 @@ public GraphQLQueryInvoker queryInvoker(ExecutionStrategyProvider executionStrat
 
     @Bean
     @ConditionalOnMissingBean
-    public GraphQLObjectMapper graphQLObjectMapper() {
-        GraphQLObjectMapper.Builder builder = GraphQLObjectMapper.newBuilder();
+    public GraphQLObjectMapper graphQLObjectMapper(Optional<ObjectMapperProvider> objectMapperProvider) {
+        GraphQLObjectMapper.Builder builder = newBuilder();
 
         if (errorHandler != null) {
             builder.withGraphQLErrorHandler(errorHandler);
         }
 
-        if (objectMapperConfigurer != null) {
+        if (objectMapperProvider.isPresent()){
+            builder.withObjectMapperProvider(objectMapperProvider.get());
+        } else if (objectMapperConfigurer != null) {
             builder.withObjectMapperConfigurer(objectMapperConfigurer);
         }
 
         return builder.build();
     }
 
+    @Bean
+    @ConditionalOnMissingBean
+    @ConditionalOnProperty(value="graphql.servlet.use-default-objectmapper", havingValue = "true",
+            matchIfMissing = true)
+    public ObjectMapperProvider objectMapperProvider(ObjectMapper objectMapper) {
+
+        InjectableValues.Std injectableValues = new InjectableValues.Std();
+        injectableValues.addValue(ObjectMapper.class, objectMapper);
+        objectMapper.setInjectableValues(injectableValues);
+        return () -> objectMapper;
+    }
+
+
 
     @Bean
     @ConditionalOnMissingBean