graphql-java · dminkovsky · Nov 15, 2016 · Jan 3, 2017 · Jan 4, 2017 · Jan 4, 2017
diff --git a/build.gradle b/build.gradle
@@ -1,5 +1,3 @@
-import java.text.SimpleDateFormat
-
 plugins {
     id "com.jfrog.bintray" version "1.2"
 }
@@ -10,10 +8,11 @@ apply plugin: 'maven-publish'
 apply plugin: 'antlr'
 apply plugin: 'jacoco'
 
-sourceCompatibility = 1.6
-targetCompatibility = 1.6
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
 def releaseVersion = System.properties.RELEASE_VERSION
-version = releaseVersion ? releaseVersion : new SimpleDateFormat('yyyy-MM-dd\'T\'HH-mm-ss').format(new Date())
+version = "3.0.0-SNAPSHOT"
+//version = releaseVersion ? releaseVersion : new SimpleDateFormat('yyyy-MM-dd\'T\'HH-mm-ss').format(new Date())
 group = 'com.graphql-java'
 
 
@@ -30,12 +29,14 @@ jar {
 dependencies {
     compile 'org.antlr:antlr4-runtime:4.5.1'
     compile 'org.slf4j:slf4j-api:1.7.12'
+    compile 'com.spotify:completable-futures:0.3.0'
     antlr "org.antlr:antlr4:4.5.1"
     testCompile group: 'junit', name: 'junit', version: '4.11'
     testCompile 'org.spockframework:spock-core:1.0-groovy-2.4'
     testCompile 'org.codehaus.groovy:groovy-all:2.4.4'
     testCompile 'cglib:cglib-nodep:3.1'
     testCompile 'org.objenesis:objenesis:2.1'
+    testCompile 'org.slf4j:slf4j-log4j12:1.7.21'
 }
 
 compileJava.source file("build/generated-src"), sourceSets.main.java

diff --git a/src/main/java/graphql/GraphQL.java b/src/main/java/graphql/GraphQL.java
@@ -20,6 +20,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletionStage;
 
 import static graphql.Assert.assertNotNull;
 
@@ -34,11 +35,10 @@ public ExecutionId provide(String query, String operationName, Object context) {
         }
     };
 
-    private final GraphQLSchema graphQLSchema;
-    private final ExecutionStrategy queryStrategy;
-    private final ExecutionStrategy mutationStrategy;
-    private final ExecutionIdProvider idProvider;
-
+    protected final GraphQLSchema graphQLSchema;
+    protected final ExecutionStrategy queryStrategy;
+    protected final ExecutionStrategy mutationStrategy;
+    protected final ExecutionIdProvider idProvider;
 
     /**
      * A GraphQL object ready to execute queries

diff --git a/src/main/java/graphql/GraphQLAsync.java b/src/main/java/graphql/GraphQLAsync.java
@@ -0,0 +1,86 @@
+package graphql;
+
+import graphql.execution.AsyncExecution;
+import graphql.execution.Execution;
+import graphql.execution.ExecutionStrategy;
+import graphql.language.Document;
+import graphql.language.SourceLocation;
+import graphql.parser.Parser;
+import graphql.schema.GraphQLSchema;
+import graphql.validation.ValidationError;
+import graphql.validation.Validator;
+import org.antlr.v4.runtime.RecognitionException;
+import org.antlr.v4.runtime.misc.ParseCancellationException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletionStage;
+
+import static graphql.Assert.assertNotNull;
+import static java.util.concurrent.CompletableFuture.completedFuture;
+
+public class GraphQLAsync extends GraphQL {
+
+    private static Logger log = LoggerFactory.getLogger(GraphQLAsync.class);
+
+    public GraphQLAsync(GraphQLSchema graphQLSchema) {
+        super(graphQLSchema);
+    }
+
+    public GraphQLAsync(GraphQLSchema graphQLSchema, ExecutionStrategy queryStrategy) {
+        super(graphQLSchema, queryStrategy);
+    }
+
+    public GraphQLAsync(GraphQLSchema graphQLSchema, ExecutionStrategy queryStrategy, ExecutionStrategy mutationStrategy) {
+        super(graphQLSchema, queryStrategy, mutationStrategy);
+    }
+
+    public CompletionStage<ExecutionResult> executeAsync(String requestString) {
+        return executeAsync(requestString, null);
+
+    }
+
+    public CompletionStage<ExecutionResult> executeAsync(String requestString, Object context) {
+        return executeAsync(requestString, context, Collections.emptyMap());
+
+    }
+
+    public CompletionStage<ExecutionResult> executeAsync(String requestString, String operationName, Object context) {
+        return executeAsync(requestString, operationName, context, Collections.emptyMap());
+
+    }
+
+    public CompletionStage<ExecutionResult> executeAsync(String requestString, Object context, Map<String, Object> arguments) {
+        return executeAsync(requestString, null, context, arguments);
+
+    }
+
+    @SuppressWarnings("unchecked")
+    public CompletionStage<ExecutionResult> executeAsync(String requestString, String operationName, Object context, Map<String, Object> arguments) {
+
+        assertNotNull(arguments, "arguments can't be null");
+        log.debug("Executing request. operation name: {}. Request: {} ", operationName, requestString);
+        Parser parser = new Parser();
+        Document document;
+        try {
+            document = parser.parseDocument(requestString);
+        } catch (ParseCancellationException e) {
+            RecognitionException recognitionException = (RecognitionException) e.getCause();
+            SourceLocation sourceLocation = new SourceLocation(recognitionException.getOffendingToken().getLine(), recognitionException.getOffendingToken().getCharPositionInLine());
+            InvalidSyntaxError invalidSyntaxError = new InvalidSyntaxError(sourceLocation);
+            return completedFuture(new ExecutionResultImpl(Arrays.asList(invalidSyntaxError)));
+        }
+
+        Validator validator = new Validator();
+        List<ValidationError> validationErrors = validator.validateDocument(graphQLSchema, document);
+        if (validationErrors.size() > 0) {
+            return completedFuture(new ExecutionResultImpl(validationErrors));
+        }
+        AsyncExecution execution = new AsyncExecution(queryStrategy, mutationStrategy);
+        return execution.executeAsync(graphQLSchema, context, document, operationName, arguments);
+    }
+}
diff --git a/src/main/java/graphql/NonNullException.java b/src/main/java/graphql/NonNullException.java
@@ -0,0 +1,8 @@
+package graphql;
+
+public class NonNullException extends GraphQLException {
+
+    public NonNullException(String s) {
+        super(s);
+    }
+}
diff --git a/src/main/java/graphql/execution/AsyncExecution.java b/src/main/java/graphql/execution/AsyncExecution.java
@@ -0,0 +1,46 @@
+package graphql.execution;
+
+import graphql.ExecutionResult;
+import graphql.execution.async.AsyncExecutionStrategy;
+import graphql.language.Document;
+import graphql.language.Field;
+import graphql.language.OperationDefinition;
+import graphql.schema.GraphQLObjectType;
+import graphql.schema.GraphQLSchema;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletionStage;
+
+public class AsyncExecution extends Execution {
+
+    public AsyncExecution(ExecutionStrategy queryStrategy, ExecutionStrategy mutationStrategy) {
+        super(queryStrategy, mutationStrategy);
+    }
+
+    public CompletionStage<ExecutionResult> executeAsync(GraphQLSchema graphQLSchema, Object root, Document document, String operationName, Map<String, Object> args) {
+        ExecutionContextBuilder executionContextBuilder = new ExecutionContextBuilder(new ValuesResolver());
+        ExecutionContext executionContext = executionContextBuilder
+          .executionId(ExecutionId.generate())
+          .build(graphQLSchema, queryStrategy, mutationStrategy, root, document, operationName, args);
+        return executeOperationAsync(executionContext, root, executionContext.getOperationDefinition());
+    }
+
+    private CompletionStage<ExecutionResult> executeOperationAsync(
+      ExecutionContext executionContext,
+      Object root,
+      OperationDefinition operationDefinition) {
+        GraphQLObjectType operationRootType = getOperationRootType(executionContext.getGraphQLSchema(), operationDefinition);
+
+        Map<String, List<Field>> fields = new LinkedHashMap<String, List<Field>>();
+        fieldCollector.collectFields(executionContext, operationRootType, operationDefinition.getSelectionSet(), new ArrayList<String>(), fields);
+
+        if (operationDefinition.getOperation() == OperationDefinition.Operation.MUTATION) {
+            return ((AsyncExecutionStrategy) mutationStrategy).executeAsync(executionContext, operationRootType, root, fields);
+        } else {
+            return ((AsyncExecutionStrategy) queryStrategy).executeAsync(executionContext, operationRootType, root, fields);
+        }
+    }
+}
diff --git a/src/main/java/graphql/execution/Execution.java b/src/main/java/graphql/execution/Execution.java
@@ -3,6 +3,7 @@
 
 import graphql.ExecutionResult;
 import graphql.GraphQLException;
+import graphql.execution.async.AsyncExecutionStrategy;
 import graphql.language.Document;
 import graphql.language.Field;
 import graphql.language.OperationDefinition;
@@ -13,12 +14,14 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletionStage;
+import java.util.stream.Stream;
 
 public class Execution {
 
-    private FieldCollector fieldCollector = new FieldCollector();
-    private ExecutionStrategy queryStrategy;
-    private ExecutionStrategy mutationStrategy;
+    protected FieldCollector fieldCollector = new FieldCollector();
+    protected ExecutionStrategy queryStrategy;
+    protected ExecutionStrategy mutationStrategy;
 
     public Execution(ExecutionStrategy queryStrategy, ExecutionStrategy mutationStrategy) {
         this.queryStrategy = queryStrategy != null ? queryStrategy : new SimpleExecutionStrategy();
@@ -33,7 +36,7 @@ public ExecutionResult execute(ExecutionId executionId, GraphQLSchema graphQLSch
         return executeOperation(executionContext, root, executionContext.getOperationDefinition());
     }
 
-    private GraphQLObjectType getOperationRootType(GraphQLSchema graphQLSchema, OperationDefinition operationDefinition) {
+    protected GraphQLObjectType getOperationRootType(GraphQLSchema graphQLSchema, OperationDefinition operationDefinition) {
         if (operationDefinition.getOperation() == OperationDefinition.Operation.MUTATION) {
             return graphQLSchema.getMutationType();