fix(#529): refactor altair resources

Author: oliemansm

README.md

@@ -109,22 +109,22 @@ repositories {
 }
 
 dependencies {
-  implementation 'com.graphql-java-kickstart:graphql-spring-boot-starter:11.0.0'
+  implementation 'com.graphql-java-kickstart:graphql-spring-boot-starter:12.0.0'
   
   // to embed Altair tool
-  runtimeOnly 'com.graphql-java-kickstart:altair-spring-boot-starter:11.0.0'
+  runtimeOnly 'com.graphql-java-kickstart:altair-spring-boot-starter:12.0.0'
 
   // to embed GraphiQL tool
-  runtimeOnly 'com.graphql-java-kickstart:graphiql-spring-boot-starter:11.0.0'
+  runtimeOnly 'com.graphql-java-kickstart:graphiql-spring-boot-starter:12.0.0'
 
   // to embed GraphQL Playground tool
-  runtimeOnly 'com.graphql-java-kickstart:playground-spring-boot-starter:11.0.0'
+  runtimeOnly 'com.graphql-java-kickstart:playground-spring-boot-starter:12.0.0'
 
   // to embed Voyager tool
-  runtimeOnly 'com.graphql-java-kickstart:voyager-spring-boot-starter:11.0.0'
+  runtimeOnly 'com.graphql-java-kickstart:voyager-spring-boot-starter:12.0.0'
   
   // testing facilities
-  testImplementation 'com.graphql-java-kickstart:graphql-spring-boot-starter-test:11.0.0'
+  testImplementation 'com.graphql-java-kickstart:graphql-spring-boot-starter-test:12.0.0'
 }
 ```
 
@@ -134,46 +134,46 @@ Maven:
 <dependency>
     <groupId>com.graphql-java-kickstart</groupId>
     <artifactId>graphql-spring-boot-starter</artifactId>
-    <version>11.0.0</version>
+    <version>12.0.0</version>
 </dependency>
 
 <!-- to embed Altair tool -->
 <dependency>
     <groupId>com.graphql-java-kickstart</groupId>
     <artifactId>altair-spring-boot-starter</artifactId>
-    <version>11.0.0</version>
+    <version>12.0.0</version>
     <scope>runtime</scope>
 </dependency>
 
 <!-- to embed GraphiQL tool -->
 <dependency>
     <groupId>com.graphql-java-kickstart</groupId>
     <artifactId>graphiql-spring-boot-starter</artifactId>
-    <version>11.0.0</version>
+    <version>12.0.0</version>
     <scope>runtime</scope>
 </dependency>
 
 <!-- to embed GraphQL Playground tool -->
 <dependency>
     <groupId>com.graphql-java-kickstart</groupId>
     <artifactId>playground-spring-boot-starter</artifactId>
-    <version>11.0.0</version>
+    <version>12.0.0</version>
     <scope>runtime</scope>
 </dependency>
 
 <!-- to embed Voyager tool -->
 <dependency>
     <groupId>com.graphql-java-kickstart</groupId>
     <artifactId>voyager-spring-boot-starter</artifactId>
-    <version>11.0.0</version>
+    <version>12.0.0</version>
     <scope>runtime</scope>
 </dependency>
 
 <!-- testing facilities -->
 <dependency>
     <groupId>com.graphql-java-kickstart</groupId>
     <artifactId>graphql-spring-boot-starter-test</artifactId>
-    <version>11.0.0</version>
+    <version>12.0.0</version>
     <scope>test</scope>
 </dependency>
 
@@ -298,37 +298,37 @@ or `application.properties`):
 
 ```yaml
 altair:
-    mapping: /altair
-    endpoint:
-      graphql: /graphql
-      subscriptions: /subscriptions
-    subscriptions:
-      timeout: 30
-      reconnect: false
-    static:
-      basePath: /
-    enabled: true
-    pageTitle: Altair
-    cdn:
-        enabled: false
-        version: 4.0.2
-    options:
-      initial-settings:
-        theme: dracula
-    props:
-        resources:
-            defaultQuery: defaultQuery.graphql
-            variables: variables.graphql
-    headers:
-        Authorization: "Bearer <your-token>"
+  enabled: true
+  mapping: /altair
+  subscriptions:
+    timeout: 30
+    reconnect: false
+  static:
+    base-path: /
+  page-title: Altair
+  cdn:
+    enabled: false
+    version: 4.0.2
+  options:
+    endpoint-url: /graphql
+    subscriptions-endpoint: /subscriptions
+    initial-settings:
+      theme: dracula
+    initial-headers:
+      Authorization: "Bearer <your-token>"
+  resources:
+    initial-query: defaultQuery.graphql
+    initial-variables: variables.graphql
+    initial-pre-request-script: pre-request.graphql
+    initial-post-request-script: post-request.graphql
 ```
 
 By default Altair is served from within the package. This can be configured to be served from CDN
-instead, by setting the property `altair.cdn.enabled` to `true`.
+instead, by setting the property `graphql.altair.cdn.enabled` to `true`.
 
-You are able to set the Altair options as well using the `altair.options` group. Since setting (
+You are able to set the Altair options as well using the `graphql.altair.options` group. Since setting (
 large) queries in the properties like this isn't very readable, you can use the properties in
-the `altair.props.resources` group to set the classpath resources that should be loaded.
+the `graphql.altair.resources` group to set the classpath resources that should be loaded.
 
 # Enable GraphQL Playground
 

example/src/main/resources/application.yml

@@ -32,7 +32,6 @@ graphql:
         theme: dracula
       endpoint-url: /graphql
 
-
   graphiql:
     enabled: true
     cdn:

graphql-spring-boot-autoconfigure/src/main/java/graphql/kickstart/autoconfigure/editor/altair/AltairAutoConfiguration.java

@@ -11,7 +11,7 @@
 /** @author Moncef AOUDIA */
 @Configuration
 @ConditionalOnWebApplication
-@EnableConfigurationProperties({AltairProperties.class, AltairOptions.class})
+@EnableConfigurationProperties({AltairProperties.class, AltairOptions.class, AltairResources.class})
 @ConditionalOnClass(DispatcherServlet.class)
 public class AltairAutoConfiguration {
 

graphql-spring-boot-autoconfigure/src/main/java/graphql/kickstart/autoconfigure/editor/altair/AltairController.java

@@ -5,32 +5,24 @@
 import static org.apache.commons.lang3.StringUtils.isNumeric;
 
 import com.fasterxml.jackson.annotation.JsonInclude.Include;
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import graphql.kickstart.autoconfigure.editor.PropertyGroupReader;
-import graphql.kickstart.autoconfigure.editor.PropsLoader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.Charset;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Properties;
 import javax.annotation.PostConstruct;
-import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import lombok.val;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.text.StringSubstitutor;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.core.env.Environment;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.stereotype.Controller;
 import org.springframework.util.StreamUtils;
 import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestParam;
 
 /** @author Moncef AOUDIA */
 @Slf4j
@@ -39,23 +31,18 @@ public class AltairController {
 
   private static final String CDN_JSDELIVR_NET_NPM = "//cdn.jsdelivr.net/npm/";
   private static final String ALTAIR = "altair-static";
-
+  private final ObjectMapper objectMapper = new ObjectMapper();
   @Autowired private AltairProperties altairProperties;
   @Autowired private AltairOptions altairOptions;
-  private final ObjectMapper objectMapper = new ObjectMapper();
-
-  @Autowired private Environment environment;
+  @Autowired private AltairResources altairResources;
 
   private String template;
-  private String props;
-  private String headers;
 
   @PostConstruct
   public void onceConstructed() throws IOException {
     objectMapper.setSerializationInclusion(Include.NON_NULL);
+    altairResources.load(altairOptions);
     loadTemplate();
-    loadProps();
-    loadHeaders();
   }
 
   private void loadTemplate() throws IOException {
@@ -65,57 +52,33 @@ private void loadTemplate() throws IOException {
     }
   }
 
-  private void loadProps() throws IOException {
-    props = new PropsLoader(environment, "graphql.altair.props.resources.", "graphql.altair.props.variables.").load();
-  }
-
-  private void loadHeaders() throws JsonProcessingException {
-    PropertyGroupReader propertyReader = new PropertyGroupReader(environment, "graphql.altair.headers.");
-    Properties headerProperties = propertyReader.load();
-    this.headers = new ObjectMapper().writeValueAsString(headerProperties);
-  }
-
   @GetMapping(value = "${graphql.altair.mapping:/altair}")
-  public void altair(
-      HttpServletRequest request,
-      HttpServletResponse response,
-      @PathVariable Map<String, String> params)
-      throws IOException {
+  public void altair(HttpServletResponse response) throws IOException {
     response.setContentType("text/html; charset=UTF-8");
-
-    Map<String, String> replacements =
-        getReplacements(
-            constructGraphQlEndpoint(request, params),
-            request.getContextPath() + altairProperties.getEndpoint().getSubscriptions());
-
-    String populatedTemplate = StringSubstitutor.replace(template, replacements);
+    String populatedTemplate = StringSubstitutor.replace(template, getReplacements());
     response.getOutputStream().write(populatedTemplate.getBytes(Charset.defaultCharset()));
   }
 
   @SneakyThrows
-  private Map<String, String> getReplacements(
-      String graphqlEndpoint, String subscriptionsEndpoint) {
+  private Map<String, String> getReplacements() {
     Map<String, String> replacements = new HashMap<>();
-    replacements.put("graphqlEndpoint", graphqlEndpoint);
-    replacements.put("subscriptionsEndpoint", subscriptionsEndpoint);
     replacements.put("pageTitle", altairProperties.getPageTitle());
     replacements.put("pageFavicon", getResourceUrl("favicon.ico", "favicon.ico"));
     replacements.put(
         "altairBaseUrl",
         getResourceUrl(
             StringUtils.join(altairProperties.getBasePath(), "/vendor/altair/"),
-            joinJsUnpkgPath(ALTAIR, altairProperties.getCdn().getVersion(), "build/dist/")));
+            joinJsdelivrPath(altairProperties.getCdn().getVersion())));
     replacements.put(
         "altairLogoUrl", getResourceUrl("assets/img/logo_350.svg", "assets/img/logo_350.svg"));
     replacements.put("altairCssUrl", getResourceUrl("styles.css", "styles.css"));
 
     val suffix = isJsSuffixAdded() ? "-es2018.js" : ".js";
     replacements.put("altairMainJsUrl", getResourceUrl("main-es2018.js", "main" + suffix));
-    replacements.put("altairPolyfillsJsUrl", getResourceUrl("polyfills-es2018.js", "polyfills" + suffix));
+    replacements.put(
+        "altairPolyfillsJsUrl", getResourceUrl("polyfills-es2018.js", "polyfills" + suffix));
     replacements.put("altairRuntimeJsUrl", getResourceUrl("runtime-es2018.js", "runtime" + suffix));
-    replacements.put("props", props);
     replacements.put("options", objectMapper.writeValueAsString(altairOptions));
-    replacements.put("headers", headers);
     return replacements;
   }
 
@@ -134,20 +97,7 @@ private String getResourceUrl(String staticFileName, String cdnUrl) {
     return staticFileName;
   }
 
-  private String joinJsUnpkgPath(String library, String cdnVersion, String cdnFileName) {
-    return CDN_JSDELIVR_NET_NPM + library + "@" + cdnVersion + "/" + cdnFileName;
-  }
-
-  private String constructGraphQlEndpoint(
-      HttpServletRequest request, @RequestParam Map<String, String> params) {
-    String endpoint = altairProperties.getEndpoint().getGraphql();
-    for (Map.Entry<String, String> param : params.entrySet()) {
-      endpoint = endpoint.replaceAll("\\{" + param.getKey() + "}", param.getValue());
-    }
-    if (StringUtils.isNotBlank(request.getContextPath())
-        && !endpoint.startsWith(request.getContextPath())) {
-      return request.getContextPath() + endpoint;
-    }
-    return endpoint;
+  private String joinJsdelivrPath(String cdnVersion) {
+    return CDN_JSDELIVR_NET_NPM + AltairController.ALTAIR + "@" + cdnVersion + "/build/dist/";
   }
 }

graphql-spring-boot-autoconfigure/src/main/java/graphql/kickstart/autoconfigure/editor/altair/AltairProperties.java

@@ -8,19 +8,11 @@
 public class AltairProperties {
 
   private boolean enabled = false;
-  private Endpoint endpoint = new Endpoint();
   private Cdn cdn = new Cdn();
   private String pageTitle = "Altair";
   private String mapping = "/altair";
   private String basePath = "";
 
-  @Data
-  static class Endpoint {
-
-    private String graphql = "/graphql";
-    private String subscriptions = "/subscriptions";
-  }
-
   @Data
   static class Cdn {
 

graphql-spring-boot-autoconfigure/src/main/java/graphql/kickstart/autoconfigure/editor/altair/AltairResources.java

@@ -0,0 +1,39 @@
+package graphql.kickstart.autoconfigure.editor.altair;
+
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Optional;
+import lombok.Data;
+import lombok.SneakyThrows;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
+import org.springframework.util.StreamUtils;
+
+@Data
+@ConfigurationProperties("graphql.altair.resources")
+public class AltairResources {
+
+  private String initialQuery;
+  private String initialVariables;
+  private String initialPreRequestScript;
+  private String initialPostRequestScript;
+
+  public void load(AltairOptions options) {
+    loadResource(initialQuery).ifPresent(options::setInitialQuery);
+    loadResource(initialVariables).ifPresent(options::setInitialVariables);
+    loadResource(initialPreRequestScript).ifPresent(options::setInitialPreRequestScript);
+    loadResource(initialPostRequestScript).ifPresent(options::setInitialPostRequestScript);
+  }
+
+  private Optional<String> loadResource(String property) {
+    return Optional.ofNullable(property).map(ClassPathResource::new).map(this::loadResource);
+  }
+
+  @SneakyThrows
+  private String loadResource(Resource resource) {
+    try (InputStream inputStream = resource.getInputStream()) {
+      return StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
+    }
+  }
+}

graphql-spring-boot-autoconfigure/src/main/resources/templates/altair.html

@@ -33,17 +33,8 @@
   </div>
 </app-root>
 <script>
-  let properties = JSON.parse(`${props}`)
-  let options = JSON.parse(`${options}`)
-  let altairConfig = Object.assign({
-    endpointURL: `${graphqlEndpoint}`,
-    subscriptionsEndpoint: `${subscriptionsEndpoint}`,
-    initialQuery: properties.defaultQuery || '',
-    initialVariables: properties.variables || '',
-    initialHeaders: JSON.parse(`${headers}`)
-  }, options || {})
   document.addEventListener('DOMContentLoaded', () => {
-    AltairGraphQL.init(altairConfig)
+    AltairGraphQL.init(JSON.parse(`${options}`))
   })
 </script>
 <script src="${altairRuntimeJsUrl}" type="text/javascript"></script>