Build GraphQL on the fly after all

Author: oliemansm

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/BatchedDataLoaderGraphQLBuilder.java

@@ -0,0 +1,42 @@
+package graphql.kickstart.execution;
+
+import graphql.ExecutionInput;
+import graphql.GraphQL;
+import graphql.execution.instrumentation.Instrumentation;
+import graphql.execution.instrumentation.dataloader.DataLoaderDispatcherInstrumentationOptions;
+import graphql.kickstart.execution.config.GraphQLBuilder;
+import graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;
+import graphql.kickstart.execution.input.GraphQLSingleInvocationInput;
+import java.util.List;
+import java.util.function.Supplier;
+
+public class BatchedDataLoaderGraphQLBuilder {
+
+  private final Supplier<DataLoaderDispatcherInstrumentationOptions> optionsSupplier;
+
+  public BatchedDataLoaderGraphQLBuilder(Supplier<DataLoaderDispatcherInstrumentationOptions> optionsSupplier) {
+    if (optionsSupplier != null) {
+      this.optionsSupplier = optionsSupplier;
+    } else {
+      this.optionsSupplier = DataLoaderDispatcherInstrumentationOptions::newOptions;
+    }
+  }
+
+  GraphQL newGraphQL(GraphQLBatchedInvocationInput invocationInput, GraphQLBuilder graphQLBuilder) {
+    Supplier<Instrumentation> supplier = augment(invocationInput, graphQLBuilder.getInstrumentationSupplier());
+    return invocationInput.getInvocationInputs().stream().findFirst()
+        .map(GraphQLSingleInvocationInput::getSchema)
+        .map(schema -> graphQLBuilder.build(schema, supplier))
+        .orElseThrow(() -> new IllegalArgumentException("Batched invocation input must contain at least one query"));
+  }
+
+  private Supplier<Instrumentation> augment(
+      GraphQLBatchedInvocationInput batchedInvocationInput,
+      Supplier<Instrumentation> instrumentationSupplier
+  ) {
+    List<ExecutionInput> executionInputs = batchedInvocationInput.getExecutionInputs();
+    return batchedInvocationInput.getContextSetting()
+        .configureInstrumentationForContext(instrumentationSupplier, executionInputs, optionsSupplier.get());
+  }
+
+}

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLInvoker.java

@@ -4,24 +4,25 @@
 
 import graphql.ExecutionResult;
 import graphql.GraphQL;
-import graphql.kickstart.execution.context.ContextSetting;
+import graphql.kickstart.execution.config.GraphQLBuilder;
 import graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;
 import graphql.kickstart.execution.input.GraphQLInvocationInput;
 import graphql.kickstart.execution.input.GraphQLSingleInvocationInput;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
-import java.util.stream.Collectors;
 import lombok.AllArgsConstructor;
 import lombok.RequiredArgsConstructor;
 
 @AllArgsConstructor
 @RequiredArgsConstructor
 public class GraphQLInvoker {
 
-  private final GraphQL graphQL;
+  private final GraphQLBuilder graphQLBuilder;
+  private final BatchedDataLoaderGraphQLBuilder batchedDataLoaderGraphQLBuilder;
   private GraphQLInvokerProxy proxy = GraphQL::executeAsync;
 
   public CompletableFuture<ExecutionResult> executeAsync(GraphQLSingleInvocationInput invocationInput) {
+    GraphQL graphQL = graphQLBuilder.build(invocationInput.getSchema());
     return proxy.executeAsync(graphQL, invocationInput.getExecutionInput());
   }
 
@@ -30,24 +31,19 @@ public GraphQLQueryResult query(GraphQLInvocationInput invocationInput) {
       return GraphQLQueryResult.create(query((GraphQLSingleInvocationInput) invocationInput));
     }
     GraphQLBatchedInvocationInput batchedInvocationInput = (GraphQLBatchedInvocationInput) invocationInput;
-    return GraphQLQueryResult
-        .create(query(batchedInvocationInput.getExecutionInputs(), batchedInvocationInput.getContextSetting()));
+    return GraphQLQueryResult.create(query(batchedInvocationInput));
   }
 
   private ExecutionResult query(GraphQLSingleInvocationInput singleInvocationInput) {
     return executeAsync(singleInvocationInput).join();
   }
 
-  private List<ExecutionResult> query(List<GraphQLSingleInvocationInput> batchedInvocationInput,
-      ContextSetting contextSetting) {
-//    List<ExecutionInput> executionIds = batchedInvocationInput.stream()
-//        .map(GraphQLSingleInvocationInput::getExecutionInput)
-//        .collect(Collectors.toList());
-//    Supplier<Instrumentation> configuredInstrumentation = contextSetting
-//        .configureInstrumentationForContext(getInstrumentation, executionIds, optionsSupplier.get());
-    return batchedInvocationInput.stream()
-        .map(this::executeAsync)
+  private List<ExecutionResult> query(GraphQLBatchedInvocationInput batchedInvocationInput) {
+    GraphQL graphQL = batchedDataLoaderGraphQLBuilder.newGraphQL(batchedInvocationInput, graphQLBuilder);
+    return batchedInvocationInput.getExecutionInputs().stream()
+        .map(executionInput -> proxy.executeAsync(graphQL, executionInput))
         .map(CompletableFuture::join)
         .collect(toList());
   }
 }
+

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLQueryInvoker.java

@@ -54,7 +54,7 @@ public GraphQLQueryResult query(GraphQLInvocationInput invocationInput) {
       return GraphQLQueryResult.create(query((GraphQLSingleInvocationInput) invocationInput));
     }
     GraphQLBatchedInvocationInput batchedInvocationInput = (GraphQLBatchedInvocationInput) invocationInput;
-    return GraphQLQueryResult.create(query(batchedInvocationInput.getExecutionInputs(), batchedInvocationInput.getContextSetting()));
+    return GraphQLQueryResult.create(query(batchedInvocationInput.getInvocationInputs(), batchedInvocationInput.getContextSetting()));
   }
 
   public ExecutionResult query(GraphQLSingleInvocationInput singleInvocationInput) {

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLBuilder.java

@@ -9,25 +9,33 @@
 import graphql.execution.preparsed.PreparsedDocumentProvider;
 import graphql.schema.GraphQLSchema;
 import java.util.function.Supplier;
+import lombok.Getter;
 
 public class GraphQLBuilder {
 
   private Supplier<ExecutionStrategyProvider> executionStrategyProviderSupplier = DefaultExecutionStrategyProvider::new;
   private Supplier<PreparsedDocumentProvider> preparsedDocumentProviderSupplier = () -> NoOpPreparsedDocumentProvider.INSTANCE;
+  @Getter
   private Supplier<Instrumentation> instrumentationSupplier = () -> SimpleInstrumentation.INSTANCE;
 
   public GraphQLBuilder executionStrategyProvider(Supplier<ExecutionStrategyProvider> supplier) {
-    executionStrategyProviderSupplier = supplier;
+    if (supplier != null) {
+      executionStrategyProviderSupplier = supplier;
+    }
     return this;
   }
 
   public GraphQLBuilder preparsedDocumentProvider(Supplier<PreparsedDocumentProvider> supplier) {
-    preparsedDocumentProviderSupplier = supplier;
+    if (supplier != null) {
+      preparsedDocumentProviderSupplier = supplier;
+    }
     return this;
   }
 
   public GraphQLBuilder instrumentation(Supplier<Instrumentation> supplier) {
-    instrumentationSupplier = supplier;
+    if (supplier != null) {
+      instrumentationSupplier = supplier;
+    }
     return this;
   }
 
@@ -36,13 +44,17 @@ public GraphQL build(GraphQLSchemaProvider schemaProvider) {
   }
 
   public GraphQL build(GraphQLSchema schema) {
+    return build(schema, instrumentationSupplier);
+  }
+
+  public GraphQL build(GraphQLSchema schema, Supplier<Instrumentation> configuredInstrumentationSupplier) {
     ExecutionStrategyProvider executionStrategyProvider = executionStrategyProviderSupplier.get();
     GraphQL.Builder builder = GraphQL.newGraphQL(schema)
         .queryExecutionStrategy(executionStrategyProvider.getQueryExecutionStrategy())
         .mutationExecutionStrategy(executionStrategyProvider.getMutationExecutionStrategy())
         .subscriptionExecutionStrategy(executionStrategyProvider.getSubscriptionExecutionStrategy())
         .preparsedDocumentProvider(preparsedDocumentProviderSupplier.get());
-    Instrumentation instrumentation = instrumentationSupplier.get();
+    Instrumentation instrumentation = configuredInstrumentationSupplier.get();
     builder.instrumentation(instrumentation);
     if (containsDispatchInstrumentation(instrumentation)) {
       builder.doNotAddDefaultInstrumentations();

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/GraphQLBatchedInvocationInput.java

@@ -1,20 +1,27 @@
 package graphql.kickstart.execution.input;
 
+import static java.util.stream.Collectors.toList;
+
+import graphql.ExecutionInput;
 import graphql.kickstart.execution.context.ContextSetting;
-import graphql.kickstart.execution.input.GraphQLInvocationInput;
-import graphql.kickstart.execution.input.GraphQLSingleInvocationInput;
 import java.util.List;
 
 /**
  * Interface representing a batched input.
  */
 public interface GraphQLBatchedInvocationInput extends GraphQLInvocationInput {
 
-    /**
-     * @return each individual input in the batch, configured with a context.
-     */
-    List<GraphQLSingleInvocationInput> getExecutionInputs();
+  /**
+   * @return each individual input in the batch, configured with a context.
+   */
+  List<GraphQLSingleInvocationInput> getInvocationInputs();
+
+  default List<ExecutionInput> getExecutionInputs() {
+    return getInvocationInputs().stream()
+        .map(GraphQLSingleInvocationInput::getExecutionInput)
+        .collect(toList());
+  }
 
-    ContextSetting getContextSetting();
+  ContextSetting getContextSetting();
 
 }

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/PerQueryBatchedInvocationInput.java

@@ -15,11 +15,12 @@
  */
 @Getter
 public class PerQueryBatchedInvocationInput implements GraphQLBatchedInvocationInput {
-    private final List<GraphQLSingleInvocationInput> executionInputs;
+
+    private final List<GraphQLSingleInvocationInput> invocationInputs;
     private final ContextSetting contextSetting;
 
     public PerQueryBatchedInvocationInput(List<GraphQLRequest> requests, GraphQLSchema schema, Supplier<GraphQLContext> contextSupplier, Object root, ContextSetting contextSetting) {
-        executionInputs = requests.stream()
+        invocationInputs = requests.stream()
             .map(request -> new GraphQLSingleInvocationInput(request, schema, contextSupplier.get(), root)).collect(Collectors.toList());
         this.contextSetting = contextSetting;
     }

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/PerRequestBatchedInvocationInput.java

@@ -15,13 +15,13 @@
 @Getter
 public class PerRequestBatchedInvocationInput implements GraphQLBatchedInvocationInput {
 
-  private final List<GraphQLSingleInvocationInput> executionInputs;
+  private final List<GraphQLSingleInvocationInput> invocationInputs;
   private final ContextSetting contextSetting;
 
   public PerRequestBatchedInvocationInput(List<GraphQLRequest> requests, GraphQLSchema schema,
       Supplier<GraphQLContext> contextSupplier, Object root, ContextSetting contextSetting) {
     GraphQLContext context = contextSupplier.get();
-    executionInputs = requests.stream().map(request -> new GraphQLSingleInvocationInput(request, schema, context, root))
+    invocationInputs = requests.stream().map(request -> new GraphQLSingleInvocationInput(request, schema, context, root))
         .collect(Collectors.toList());
     this.contextSetting = contextSetting;
   }

graphql-java-servlet/src/test/groovy/graphql/servlet/TestBatchInputPreProcessor.java

@@ -1,25 +1,25 @@
 package graphql.servlet;
 
+import graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;
 import graphql.servlet.input.BatchInputPreProcessResult;
 import graphql.servlet.input.BatchInputPreProcessor;
-import graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;
-
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 public class TestBatchInputPreProcessor implements BatchInputPreProcessor {
 
-    public static String BATCH_ERROR_MESSAGE = "Batch limit exceeded";
+  public static String BATCH_ERROR_MESSAGE = "Batch limit exceeded";
 
-    @Override
-    public BatchInputPreProcessResult preProcessBatch(GraphQLBatchedInvocationInput batchedInvocationInput, HttpServletRequest request,
-                                                      HttpServletResponse response) {
-        BatchInputPreProcessResult preProcessResult;
-        if (batchedInvocationInput.getExecutionInputs().size() > 2) {
-            preProcessResult = new BatchInputPreProcessResult(400, BATCH_ERROR_MESSAGE);
-        } else {
-            preProcessResult = new BatchInputPreProcessResult(batchedInvocationInput);
-        }
-        return preProcessResult;
+  @Override
+  public BatchInputPreProcessResult preProcessBatch(GraphQLBatchedInvocationInput batchedInvocationInput,
+      HttpServletRequest request,
+      HttpServletResponse response) {
+    BatchInputPreProcessResult preProcessResult;
+    if (batchedInvocationInput.getExecutionInputs().size() > 2) {
+      preProcessResult = new BatchInputPreProcessResult(400, BATCH_ERROR_MESSAGE);
+    } else {
+      preProcessResult = new BatchInputPreProcessResult(batchedInvocationInput);
     }
+    return preProcessResult;
+  }
 }