Introduced GraphQLInvoker to allow invocation from webflux version

Author: oliemansm

build.gradle

@@ -34,7 +34,7 @@ buildscript {
 
 plugins {
  id 'net.researchgate.release' version '2.7.0'
- id 'io.franzbecker.gradle-lombok' version '3.1.0' apply false
+ id 'io.franzbecker.gradle-lombok' version '3.2.0' apply false
  id "com.jfrog.artifactory" version "4.8.1" apply false
 }
 

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

@@ -0,0 +1,9 @@
+package graphql.kickstart.execution;
+
+public class DefaultGraphQLRootObjectBuilder extends StaticGraphQLRootObjectBuilder {
+
+ public DefaultGraphQLRootObjectBuilder() {
+ super(new Object());
+ }
+
+}

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

@@ -0,0 +1,69 @@
+package graphql.kickstart.execution;
+
+import graphql.ExecutionInput;
+import graphql.ExecutionResult;
+import graphql.GraphQL;
+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 java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+import javax.security.auth.Subject;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+public class GraphQLInvoker {
+
+ private final GraphQL graphQL;
+
+ public GraphQLQueryResult query(GraphQLInvocationInput invocationInput) {
+ if (invocationInput instanceof GraphQLSingleInvocationInput) {
+ return GraphQLQueryResult.create(query((GraphQLSingleInvocationInput) invocationInput));
+ }
+ GraphQLBatchedInvocationInput batchedInvocationInput = (GraphQLBatchedInvocationInput) invocationInput;
+ return GraphQLQueryResult.create(query(batchedInvocationInput.getExecutionInputs(), batchedInvocationInput.getContextSetting()));
+ }
+
+ private ExecutionResult query(GraphQLSingleInvocationInput singleInvocationInput) {
+ return executeAsync(singleInvocationInput).join();
+ }
+
+ public CompletableFuture<ExecutionResult> executeAsync(GraphQLSingleInvocationInput invocationInput) {
+ if (Subject.getSubject(AccessController.getContext()) == null && invocationInput.getSubject().isPresent()) {
+ return Subject
+ .doAs(invocationInput.getSubject().get(), (PrivilegedAction<CompletableFuture<ExecutionResult>>) () -> {
+ try {
+ return query(invocationInput.getExecutionInput());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ });
+ }
+
+ return query(invocationInput.getExecutionInput());
+ }
+
+ private CompletableFuture<ExecutionResult> query(ExecutionInput executionInput) {
+ return graphQL.executeAsync(executionInput);
+ }
+
+ 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)
+ //We want eager eval
+ .collect(Collectors.toList())
+ .stream()
+ .map(CompletableFuture::join)
+ .collect(Collectors.toList());
+ }
+}

graphql-java-servlet/src/main/java/graphql/servlet/core/GraphQLObjectMapper.java renamed to graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLObjectMapper.java

@@ -1,4 +1,4 @@
-package graphql.servlet.core;
+package graphql.kickstart.execution;
 
 import static java.util.stream.Collectors.toList;
 
@@ -13,13 +13,11 @@
 import graphql.ExecutionResultImpl;
 import graphql.GraphQLError;
 import graphql.execution.ExecutionPath;
-import graphql.kickstart.execution.error.DefaultGraphQLErrorHandler;
-import graphql.kickstart.execution.error.GraphQLErrorHandler;
 import graphql.kickstart.execution.config.ConfiguringObjectMapperProvider;
 import graphql.kickstart.execution.config.ObjectMapperConfigurer;
 import graphql.kickstart.execution.config.ObjectMapperProvider;
-import graphql.kickstart.execution.GraphQLRequest;
-import graphql.kickstart.execution.VariablesDeserializer;
+import graphql.kickstart.execution.error.DefaultGraphQLErrorHandler;
+import graphql.kickstart.execution.error.GraphQLErrorHandler;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.Writer;
@@ -28,7 +26,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.function.Supplier;
-import javax.servlet.http.Part;
 
 /**
  * @author Andrew Potter
@@ -182,9 +179,9 @@ public Map<String, Object> deserializeVariables(String variables) {
  }
  }
 
- public Map<String, List<String>> deserializeMultipartMap(Part part) {
+ public Map<String, List<String>> deserializeMultipartMap(InputStream inputStream) {
  try {
- return getJacksonMapper().readValue(part.getInputStream(), MULTIPART_MAP_TYPE_REFERENCE);
+ return getJacksonMapper().readValue(inputStream, MULTIPART_MAP_TYPE_REFERENCE);
  } catch (IOException e) {
  throw new RuntimeException(e);
  }

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

@@ -72,8 +72,7 @@ public List<ExecutionResult> query(List<GraphQLSingleInvocationInput> batchedInv
  .map(GraphQLSingleInvocationInput::getExecutionInput)
  .collect(Collectors.toList());
  Supplier<Instrumentation> configuredInstrumentation = contextSetting
- .configureInstrumentationForContext(getInstrumentation, executionIds,
- optionsSupplier.get());
+ .configureInstrumentationForContext(getInstrumentation, executionIds, optionsSupplier.get());
  return batchedInvocationInput.stream()
  .map(input -> this.queryAsync(input, configuredInstrumentation))
  //We want eager eval

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

@@ -0,0 +1,10 @@
+package graphql.kickstart.execution;
+
+public interface GraphQLRootObjectBuilder {
+
+ /**
+ * @return the graphql root object
+ */
+ Object build();
+
+}

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

@@ -0,0 +1,20 @@
+package graphql.kickstart.execution;
+
+public class StaticGraphQLRootObjectBuilder implements GraphQLRootObjectBuilder {
+
+ private final Object rootObject;
+
+ public StaticGraphQLRootObjectBuilder(Object rootObject) {
+ this.rootObject = rootObject;
+ }
+
+ @Override
+ public Object build() {
+ return rootObject;
+ }
+
+ protected Object getRootObject() {
+ return rootObject;
+ }
+
+}

graphql-java-servlet/src/main/java/graphql/servlet/config/DefaultGraphQLSchemaProvider.java renamed to graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/DefaultGraphQLSchemaProvider.java

@@ -1,8 +1,6 @@
-package graphql.servlet.config;
+package graphql.kickstart.execution.config;
 
 import graphql.schema.GraphQLSchema;
-import javax.servlet.http.HttpServletRequest;
-import javax.websocket.server.HandshakeRequest;
 
 /**
  * @author Andrew Potter
@@ -21,24 +19,14 @@ public DefaultGraphQLSchemaProvider(GraphQLSchema schema, GraphQLSchema readOnly
  this.readOnlySchema = readOnlySchema;
  }
 
-
- @Override
- public GraphQLSchema getSchema(HttpServletRequest request) {
- return getSchema();
- }
-
- @Override
- public GraphQLSchema getSchema(HandshakeRequest request) {
- return getSchema();
- }
-
  @Override
  public GraphQLSchema getSchema() {
  return schema;
  }
 
  @Override
- public GraphQLSchema getReadOnlySchema(HttpServletRequest request) {
+ public GraphQLSchema getReadOnlySchema() {
  return readOnlySchema;
  }
+
 }

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

@@ -0,0 +1,61 @@
+package graphql.kickstart.execution.config;
+
+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.preparsed.NoOpPreparsedDocumentProvider;
+import graphql.execution.preparsed.PreparsedDocumentProvider;
+import graphql.schema.GraphQLSchema;
+import java.util.function.Supplier;
+
+public class GraphQLBuilder {
+
+ private Supplier<ExecutionStrategyProvider> executionStrategyProviderSupplier = DefaultExecutionStrategyProvider::new;
+ private Supplier<PreparsedDocumentProvider> preparsedDocumentProviderSupplier = () -> NoOpPreparsedDocumentProvider.INSTANCE;
+ private Supplier<Instrumentation> instrumentationSupplier = () -> SimpleInstrumentation.INSTANCE;
+
+ public GraphQLBuilder executionStrategyProvider(Supplier<ExecutionStrategyProvider> supplier) {
+ executionStrategyProviderSupplier = supplier;
+ return this;
+ }
+
+ public GraphQLBuilder preparsedDocumentProvider(Supplier<PreparsedDocumentProvider> supplier) {
+ preparsedDocumentProviderSupplier = supplier;
+ return this;
+ }
+
+ public GraphQLBuilder instrumentation(Supplier<Instrumentation> supplier) {
+ instrumentationSupplier = supplier;
+ return this;
+ }
+
+ public GraphQL build(GraphQLSchemaProvider schemaProvider) {
+ return build(schemaProvider.getSchema());
+ }
+
+ public GraphQL build(GraphQLSchema schema) {
+ 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();
+ 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;
+ }
+
+}

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

@@ -0,0 +1,21 @@
+package graphql.kickstart.execution.config;
+
+import graphql.schema.GraphQLObjectType;
+import graphql.schema.GraphQLSchema;
+
+public interface GraphQLSchemaProvider {
+
+ static GraphQLSchema copyReadOnly(GraphQLSchema schema) {
+ return GraphQLSchema.newSchema(schema)
+ .mutation((GraphQLObjectType) null)
+ .build();
+ }
+
+ /**
+ * @return a schema for handling mbean calls.
+ */
+ GraphQLSchema getSchema();
+
+ GraphQLSchema getReadOnlySchema();
+
+}