Limit use of GraphQLQueryInvoker

Author: oliemansm

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

@@ -1,29 +1,16 @@
 package graphql.kickstart.execution;
 
-import graphql.ExecutionInput;
-import graphql.ExecutionResult;
-import graphql.GraphQL;
 import graphql.execution.instrumentation.ChainedInstrumentation;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.execution.instrumentation.SimpleInstrumentation;
-import graphql.execution.instrumentation.dataloader.DataLoaderDispatcherInstrumentation;
 import graphql.execution.instrumentation.dataloader.DataLoaderDispatcherInstrumentationOptions;
 import graphql.execution.preparsed.NoOpPreparsedDocumentProvider;
 import graphql.execution.preparsed.PreparsedDocumentProvider;
-import graphql.schema.GraphQLSchema;
 import graphql.kickstart.execution.config.DefaultExecutionStrategyProvider;
 import graphql.kickstart.execution.config.ExecutionStrategyProvider;
-import graphql.kickstart.execution.context.ContextSetting;
-import graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;
-import graphql.kickstart.execution.input.GraphQLInvocationInput;
-import graphql.kickstart.execution.input.GraphQLSingleInvocationInput;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
+import graphql.kickstart.execution.config.GraphQLBuilder;
 import java.util.List;
-import java.util.concurrent.CompletableFuture;
 import java.util.function.Supplier;
-import java.util.stream.Collectors;
-import javax.security.auth.Subject;
 
 /**
  * @author Andrew Potter
@@ -49,81 +36,12 @@ public static Builder newBuilder() {
     return new Builder();
   }
 
-  public GraphQLQueryResult query(GraphQLInvocationInput invocationInput) {
-    if (invocationInput instanceof GraphQLSingleInvocationInput) {
-      return GraphQLQueryResult.create(query((GraphQLSingleInvocationInput) invocationInput));
-    }
-    GraphQLBatchedInvocationInput batchedInvocationInput = (GraphQLBatchedInvocationInput) invocationInput;
-    return GraphQLQueryResult.create(query(batchedInvocationInput.getInvocationInputs(), batchedInvocationInput.getContextSetting()));
-  }
-
-  public ExecutionResult query(GraphQLSingleInvocationInput singleInvocationInput) {
-    return queryAsync(singleInvocationInput, getInstrumentation).join();
-  }
-
-  private CompletableFuture<ExecutionResult> queryAsync(GraphQLSingleInvocationInput singleInvocationInput,
-      Supplier<Instrumentation> configuredInstrumentation) {
-    return query(singleInvocationInput, configuredInstrumentation, singleInvocationInput.getExecutionInput());
-  }
-
-  public 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(input -> this.queryAsync(input, configuredInstrumentation))
-        //We want eager eval
-        .collect(Collectors.toList())
-        .stream()
-        .map(CompletableFuture::join)
-        .collect(Collectors.toList());
-  }
-
-  private GraphQL newGraphQL(GraphQLSchema schema, Supplier<Instrumentation> configuredInstrumentation) {
-    ExecutionStrategyProvider executionStrategyProvider = getExecutionStrategyProvider.get();
-    GraphQL.Builder builder = GraphQL.newGraphQL(schema)
-        .queryExecutionStrategy(executionStrategyProvider.getQueryExecutionStrategy())
-        .mutationExecutionStrategy(executionStrategyProvider.getMutationExecutionStrategy())
-        .subscriptionExecutionStrategy(executionStrategyProvider.getSubscriptionExecutionStrategy())
-        .preparsedDocumentProvider(getPreparsedDocumentProvider.get());
-    Instrumentation instrumentation = configuredInstrumentation.get();
-    builder.instrumentation(instrumentation);
-    if (containsDispatchInstrumentation(instrumentation)) {
-      builder.doNotAddDefaultInstrumentations();
-    }
-    return builder.build();
-  }
-
-  private boolean containsDispatchInstrumentation(Instrumentation instrumentation) {
-    if (instrumentation instanceof ChainedInstrumentation) {
-      return ((ChainedInstrumentation) instrumentation).getInstrumentations().stream()
-          .anyMatch(this::containsDispatchInstrumentation);
-    }
-    return instrumentation instanceof DataLoaderDispatcherInstrumentation;
-  }
-
-  private CompletableFuture<ExecutionResult> query(GraphQLSingleInvocationInput invocationInput,
-      Supplier<Instrumentation> configuredInstrumentation, ExecutionInput executionInput) {
-    if (Subject.getSubject(AccessController.getContext()) == null && invocationInput.getSubject().isPresent()) {
-      return Subject
-          .doAs(invocationInput.getSubject().get(), (PrivilegedAction<CompletableFuture<ExecutionResult>>) () -> {
-            try {
-              return query(invocationInput.getSchema(), executionInput, configuredInstrumentation);
-            } catch (Exception e) {
-              throw new RuntimeException(e);
-            }
-          });
-    }
-
-    return query(invocationInput.getSchema(), executionInput, configuredInstrumentation);
-  }
-
-  private CompletableFuture<ExecutionResult> query(GraphQLSchema schema, ExecutionInput executionInput,
-      Supplier<Instrumentation> configuredInstrumentation) {
-    return newGraphQL(schema, configuredInstrumentation).executeAsync(executionInput);
+  public GraphQLInvoker toGraphQLInvoker() {
+    GraphQLBuilder graphQLBuilder = new GraphQLBuilder()
+        .executionStrategyProvider(getExecutionStrategyProvider)
+        .instrumentation(getInstrumentation)
+        .preparsedDocumentProvider(getPreparsedDocumentProvider);
+    return new GraphQLInvoker(graphQLBuilder, new BatchedDataLoaderGraphQLBuilder(optionsSupplier));
   }
 
   public static class Builder {

graphql-java-servlet/src/main/java/graphql/servlet/AbstractGraphQLHttpServlet.java

@@ -1,14 +1,17 @@
 package graphql.servlet;
 
-import graphql.schema.GraphQLFieldDefinition;
-import graphql.servlet.core.GraphQLMBean;
+import static graphql.kickstart.execution.GraphQLRequest.createQueryOnlyRequest;
+
+import graphql.ExecutionResult;
 import graphql.kickstart.execution.GraphQLObjectMapper;
 import graphql.kickstart.execution.GraphQLQueryInvoker;
-import graphql.servlet.core.GraphQLServletListener;
 import graphql.kickstart.execution.GraphQLRequest;
+import graphql.kickstart.execution.input.GraphQLSingleInvocationInput;
+import graphql.schema.GraphQLFieldDefinition;
+import graphql.servlet.core.GraphQLMBean;
+import graphql.servlet.core.GraphQLServletListener;
 import graphql.servlet.input.GraphQLInvocationInputFactory;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Consumer;
@@ -115,8 +118,10 @@ public String[] getMutations() {
   @Override
   public String executeQuery(String query) {
     try {
-      return configuration.getObjectMapper().serializeResultAsJson(configuration.getQueryInvoker()
-          .query(configuration.getInvocationInputFactory().create(new GraphQLRequest(query, new HashMap<>(), null))));
+      GraphQLRequest graphQLRequest = createQueryOnlyRequest(query);
+      GraphQLSingleInvocationInput invocationInput = configuration.getInvocationInputFactory().create(graphQLRequest);
+      ExecutionResult result = configuration.getGraphQLInvoker().query(invocationInput).getResult();
+      return configuration.getObjectMapper().serializeResultAsJson(result);
     } catch (Exception e) {
       return e.getMessage();
     }

graphql-java-servlet/src/main/java/graphql/servlet/GraphQLConfiguration.java

@@ -1,5 +1,6 @@
 package graphql.servlet;
 
+import graphql.kickstart.execution.GraphQLInvoker;
 import graphql.kickstart.execution.GraphQLObjectMapper;
 import graphql.kickstart.execution.GraphQLQueryInvoker;
 import graphql.kickstart.execution.context.ContextSetting;
@@ -24,19 +25,22 @@ public class GraphQLConfiguration {
   private final GraphQLInvocationInputFactory invocationInputFactory;
   private final Supplier<BatchInputPreProcessor> batchInputPreProcessor;
   private final GraphQLQueryInvoker queryInvoker;
+  private final GraphQLInvoker graphQLInvoker;
   private final GraphQLObjectMapper objectMapper;
   private final List<GraphQLServletListener> listeners;
   private final boolean asyncServletModeEnabled;
   private final Executor asyncExecutor;
   private final long subscriptionTimeout;
   private final ContextSetting contextSetting;
 
-  private GraphQLConfiguration(GraphQLInvocationInputFactory invocationInputFactory, GraphQLQueryInvoker queryInvoker,
+  private GraphQLConfiguration(GraphQLInvocationInputFactory invocationInputFactory,
+      GraphQLQueryInvoker queryInvoker,
       GraphQLObjectMapper objectMapper, List<GraphQLServletListener> listeners, boolean asyncServletModeEnabled,
       Executor asyncExecutor, long subscriptionTimeout, ContextSetting contextSetting,
       Supplier<BatchInputPreProcessor> batchInputPreProcessor) {
     this.invocationInputFactory = invocationInputFactory;
     this.queryInvoker = queryInvoker;
+    this.graphQLInvoker = queryInvoker.toGraphQLInvoker();
     this.objectMapper = objectMapper;
     this.listeners = listeners;
     this.asyncServletModeEnabled = asyncServletModeEnabled;
@@ -62,8 +66,10 @@ public GraphQLInvocationInputFactory getInvocationInputFactory() {
     return invocationInputFactory;
   }
 
-  public GraphQLQueryInvoker getQueryInvoker() {
-    return queryInvoker;
+  public GraphQLQueryInvoker getQueryInvoker() { return queryInvoker; }
+
+  public GraphQLInvoker getGraphQLInvoker() {
+    return graphQLInvoker;
   }
 
   public GraphQLObjectMapper getObjectMapper() {

graphql-java-servlet/src/main/java/graphql/servlet/HttpRequestHandlerImpl.java

@@ -3,8 +3,8 @@
 import static graphql.servlet.QueryResponseWriter.createWriter;
 
 import graphql.GraphQLException;
+import graphql.kickstart.execution.GraphQLInvoker;
 import graphql.kickstart.execution.GraphQLQueryResult;
-import graphql.kickstart.execution.GraphQLQueryInvoker;
 import graphql.servlet.input.BatchInputPreProcessResult;
 import graphql.servlet.input.BatchInputPreProcessor;
 import graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;
@@ -19,11 +19,11 @@
 class HttpRequestHandlerImpl implements HttpRequestHandler {
 
   private final GraphQLConfiguration configuration;
-  private final GraphQLQueryInvoker queryInvoker;
+  private final GraphQLInvoker graphQLInvoker;
 
   HttpRequestHandlerImpl(GraphQLConfiguration configuration) {
     this.configuration = configuration;
-    queryInvoker = configuration.getQueryInvoker();
+    graphQLInvoker = configuration.getGraphQLInvoker();
   }
 
   @Override
@@ -65,7 +65,7 @@ private void execute(GraphQLInvocationInput invocationInput, HttpServletRequest
   private GraphQLQueryResult invoke(GraphQLInvocationInput invocationInput, HttpServletRequest request,
       HttpServletResponse response) {
     if (invocationInput instanceof GraphQLSingleInvocationInput) {
-      return queryInvoker.query(invocationInput);
+      return graphQLInvoker.query(invocationInput);
     }
     return invokeBatched((GraphQLBatchedInvocationInput) invocationInput, request, response);
   }
@@ -76,7 +76,7 @@ private GraphQLQueryResult invokeBatched(GraphQLBatchedInvocationInput batchedIn
     BatchInputPreProcessor preprocessor = configuration.getBatchInputPreProcessor();
     BatchInputPreProcessResult result = preprocessor.preProcessBatch(batchedInvocationInput, request, response);
     if (result.isExecutable()) {
-      return queryInvoker.query(result.getBatchedInvocationInput());
+      return graphQLInvoker.query(result.getBatchedInvocationInput());
     }
 
     return GraphQLQueryResult.createError(result.getStatusCode(), result.getStatusMessage());

graphql-java-servlet/src/main/java/graphql/servlet/input/GraphQLInvocationInputFactory.java

@@ -108,16 +108,6 @@ private GraphQLBatchedInvocationInput create(ContextSetting contextSetting, List
     );
   }
 
-  public GraphQLSingleInvocationInput create(GraphQLRequest graphQLRequest, Session session) {
-    HandshakeRequest request = (HandshakeRequest) session.getUserProperties().get(HandshakeRequest.class.getName());
-    return new GraphQLSingleInvocationInput(
-        graphQLRequest,
-        schemaProviderSupplier.get().getSchema(request),
-        contextBuilderSupplier.get().build(session, request),
-        rootObjectBuilderSupplier.get().build(request)
-    );
-  }
-
   @Override
   public GraphQLSingleInvocationInput create(GraphQLRequest graphQLRequest, SubscriptionSession session) {
     HandshakeRequest request = (HandshakeRequest) session.getUserProperties().get(HandshakeRequest.class.getName());