Subscription support

build.gradle

@@ -50,7 +50,8 @@ dependencies {
     compileOnly 'biz.aQute.bnd:biz.aQute.bndlib:3.1.0'
 
     // Servlet
-    compile 'javax.servlet:javax.servlet-api:3.0.1'
+    compile 'javax.servlet:javax.servlet-api:4.0.0'
+    compile 'javax.websocket:javax.websocket-api:1.1'
 
     // GraphQL
     compile 'com.graphql-java:graphql-java:9.2'

gradle.properties

@@ -1,2 +1,2 @@
-version = 5.2.1
+version = 6.0.0
 group = com.graphql-java

gradlew

@@ -33,11 +33,11 @@ DEFAULT_JVM_OPTS=""
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
-warn ( ) {
+warn () {
     echo "$*"
 }
 
-die ( ) {
+die () {
     echo
     echo "$*"
     echo
@@ -155,7 +155,7 @@ if $cygwin ; then
 fi
 
 # Escape application args
-save ( ) {
+save () {
     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
     echo " "
 }

src/main/java/graphql/servlet/DefaultGraphQLContextBuilder.java

@@ -1,14 +1,22 @@
 package graphql.servlet;
 
 import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-import java.util.Optional;
+import javax.websocket.server.HandshakeRequest;
 
 public class DefaultGraphQLContextBuilder implements GraphQLContextBuilder {
 
     @Override
-    public GraphQLContext build(Optional<HttpServletRequest> req, Optional<HttpServletResponse> resp) {
-        return new GraphQLContext(req, resp);
+    public GraphQLContext build(HttpServletRequest httpServletRequest) {
+        return new GraphQLContext(httpServletRequest);
     }
 
+    @Override
+    public GraphQLContext build(HandshakeRequest handshakeRequest) {
+        return new GraphQLContext(handshakeRequest);
+    }
+
+    @Override
+    public GraphQLContext build() {
+        return new GraphQLContext();
+    }
 }

src/main/java/graphql/servlet/DefaultGraphQLSchemaProvider.java

@@ -3,6 +3,7 @@
 import graphql.schema.GraphQLSchema;
 
 import javax.servlet.http.HttpServletRequest;
+import javax.websocket.server.HandshakeRequest;
 
 /**
  * @author Andrew Potter
@@ -27,6 +28,11 @@ public GraphQLSchema getSchema(HttpServletRequest request) {
         return getSchema();
     }
 
+    @Override
+    public GraphQLSchema getSchema(HandshakeRequest request) {
+        return getSchema();
+    }
+
     @Override
     public GraphQLSchema getSchema() {
         return schema;

src/main/java/graphql/servlet/GraphQLBatchedInvocationInput.java

@@ -0,0 +1,30 @@
+package graphql.servlet;
+
+import graphql.ExecutionInput;
+import graphql.execution.ExecutionContext;
+import graphql.schema.GraphQLSchema;
+import graphql.servlet.internal.GraphQLRequest;
+
+import javax.security.auth.Subject;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * @author Andrew Potter
+ */
+public class GraphQLBatchedInvocationInput extends GraphQLInvocationInput {
+    private final List<GraphQLRequest> requests;
+
+    public GraphQLBatchedInvocationInput(List<GraphQLRequest> requests, GraphQLSchema schema, GraphQLContext context, Object root) {
+        super(schema, context, root);
+        this.requests = Collections.unmodifiableList(requests);
+    }
+
+    public List<ExecutionInput> getExecutionInputs() {
+        return requests.stream()
+            .map(this::createExecutionInput)
+            .collect(Collectors.toList());
+    }
+}

src/main/java/graphql/servlet/GraphQLContext.java

@@ -2,53 +2,54 @@
 
 import javax.security.auth.Subject;
 import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.Part;
+import javax.websocket.server.HandshakeRequest;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
 public class GraphQLContext {
-    private Optional<HttpServletRequest> request;
-    private Optional<HttpServletResponse> response;
+    private HttpServletRequest httpServletRequest;
+    private HandshakeRequest handshakeRequest;
 
-    private Optional<Subject> subject = Optional.empty();
-    private Optional<Map<String, List<Part>>> files = Optional.empty();
+    private Subject subject;
+    private Map<String, List<Part>> files;
 
-    public GraphQLContext(Optional<HttpServletRequest> request, Optional<HttpServletResponse> response) {
-        this.request = request;
-        this.response = response;
+    public GraphQLContext(HttpServletRequest httpServletRequest, HandshakeRequest handshakeRequest, Subject subject) {
+        this.httpServletRequest = httpServletRequest;
+        this.handshakeRequest = handshakeRequest;
+        this.subject = subject;
     }
 
-    public Optional<HttpServletRequest> getRequest() {
-        return request;
+    public GraphQLContext(HttpServletRequest httpServletRequest) {
+        this(httpServletRequest, null, null);
     }
 
-    public void setRequest(Optional<HttpServletRequest> request) {
-        this.request = request;
+    public GraphQLContext(HandshakeRequest handshakeRequest) {
+        this(null, handshakeRequest, null);
     }
 
-    public Optional<HttpServletResponse> getResponse() {
-        return response;
+    public GraphQLContext() {
+        this(null, null, null);
     }
 
-    public void setResponse(Optional<HttpServletResponse> response) {
-        this.response = response;
+    public Optional<HttpServletRequest> getHttpServletRequest() {
+        return Optional.ofNullable(httpServletRequest);
     }
 
     public Optional<Subject> getSubject() {
-        return subject;
+        return Optional.ofNullable(subject);
     }
 
-    public void setSubject(Optional<Subject> subject) {
-        this.subject = subject;
+    public Optional<HandshakeRequest> getHandshakeRequest() {
+        return Optional.ofNullable(handshakeRequest);
     }
 
     public Optional<Map<String, List<Part>>> getFiles() {
-        return files;
+        return Optional.ofNullable(files);
     }
 
-    public void setFiles(Optional<Map<String, List<Part>>> files) {
+    public void setFiles(Map<String, List<Part>> files) {
         this.files = files;
     }
 }

src/main/java/graphql/servlet/GraphQLContextBuilder.java

@@ -2,8 +2,16 @@
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+import javax.websocket.server.HandshakeRequest;
 import java.util.Optional;
 
 public interface GraphQLContextBuilder {
-    GraphQLContext build(Optional<HttpServletRequest> req, Optional<HttpServletResponse> resp);
+    GraphQLContext build(HttpServletRequest httpServletRequest);
+    GraphQLContext build(HandshakeRequest handshakeRequest);
+
+    /**
+     * Only used for MBean calls.
+     * @return the graphql context
+     */
+    GraphQLContext build();
 }

src/main/java/graphql/servlet/GraphQLInvocationInput.java

@@ -0,0 +1,50 @@
+package graphql.servlet;
+
+import graphql.ExecutionInput;
+import graphql.schema.GraphQLSchema;
+import graphql.servlet.internal.GraphQLRequest;
+
+import javax.security.auth.Subject;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author Andrew Potter
+ */
+public abstract class GraphQLInvocationInput {
+    private final GraphQLSchema schema;
+    private final GraphQLContext context;
+    private final Object root;
+
+    public GraphQLInvocationInput(GraphQLSchema schema, GraphQLContext context, Object root) {
+        this.schema = schema;
+        this.context = context;
+        this.root = root;
+    }
+
+    public GraphQLSchema getSchema() {
+        return schema;
+    }
+
+    public GraphQLContext getContext() {
+        return context;
+    }
+
+    public Object getRoot() {
+        return root;
+    }
+
+    public Optional<Subject> getSubject() {
+        return context.getSubject();
+    }
+
+    protected ExecutionInput createExecutionInput(GraphQLRequest graphQLRequest) {
+        return new ExecutionInput(
+            graphQLRequest.getQuery(),
+            graphQLRequest.getOperationName(),
+            context,
+            root,
+            graphQLRequest.getVariables()
+        );
+    }
+}

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

@@ -0,0 +1,137 @@
+package graphql.servlet;
+
+import graphql.schema.GraphQLSchema;
+import graphql.servlet.internal.GraphQLRequest;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.websocket.server.HandshakeRequest;
+import java.util.List;
+import java.util.function.Supplier;
+
+/**
+ * @author Andrew Potter
+ */
+public class GraphQLInvocationInputFactory {
+    private final Supplier<GraphQLSchemaProvider> schemaProviderSupplier;
+    private final Supplier<GraphQLContextBuilder> contextBuilderSupplier;
+    private final Supplier<GraphQLRootObjectBuilder> rootObjectBuilderSupplier;
+
+    protected GraphQLInvocationInputFactory(Supplier<GraphQLSchemaProvider> schemaProviderSupplier, Supplier<GraphQLContextBuilder> contextBuilderSupplier, Supplier<GraphQLRootObjectBuilder> rootObjectBuilderSupplier) {
+        this.schemaProviderSupplier = schemaProviderSupplier;
+        this.contextBuilderSupplier = contextBuilderSupplier;
+        this.rootObjectBuilderSupplier = rootObjectBuilderSupplier;
+    }
+
+    public GraphQLSchemaProvider getSchemaProvider() {
+        return schemaProviderSupplier.get();
+    }
+
+    public GraphQLSingleInvocationInput create(GraphQLRequest graphQLRequest, HttpServletRequest request) {
+        return create(graphQLRequest, request, false);
+    }
+
+    public GraphQLBatchedInvocationInput create(List<GraphQLRequest> graphQLRequests, HttpServletRequest request) {
+        return create(graphQLRequests, request, false);
+    }
+
+    public GraphQLSingleInvocationInput createReadOnly(GraphQLRequest graphQLRequest, HttpServletRequest request) {
+        return create(graphQLRequest, request, true);
+    }
+
+    public GraphQLBatchedInvocationInput createReadOnly(List<GraphQLRequest> graphQLRequests, HttpServletRequest request) {
+        return create(graphQLRequests, request, true);
+    }
+
+    public GraphQLSingleInvocationInput create(GraphQLRequest graphQLRequest) {
+        return new GraphQLSingleInvocationInput(
+            graphQLRequest,
+            schemaProviderSupplier.get().getSchema(),
+            contextBuilderSupplier.get().build(),
+            rootObjectBuilderSupplier.get().build()
+        );
+    }
+
+    private GraphQLSingleInvocationInput create(GraphQLRequest graphQLRequest, HttpServletRequest request, boolean readOnly) {
+        return new GraphQLSingleInvocationInput(
+            graphQLRequest,
+            readOnly ? schemaProviderSupplier.get().getReadOnlySchema(request) : schemaProviderSupplier.get().getSchema(request),
+            contextBuilderSupplier.get().build(request),
+            rootObjectBuilderSupplier.get().build(request)
+        );
+    }
+
+    private GraphQLBatchedInvocationInput create(List<GraphQLRequest> graphQLRequests, HttpServletRequest request, boolean readOnly) {
+        return new GraphQLBatchedInvocationInput(
+            graphQLRequests,
+            readOnly ? schemaProviderSupplier.get().getReadOnlySchema(request) : schemaProviderSupplier.get().getSchema(request),
+            contextBuilderSupplier.get().build(request),
+            rootObjectBuilderSupplier.get().build(request)
+        );
+    }
+
+    public GraphQLSingleInvocationInput create(GraphQLRequest graphQLRequest, HandshakeRequest request) {
+        return new GraphQLSingleInvocationInput(
+            graphQLRequest,
+            schemaProviderSupplier.get().getSchema(request),
+            contextBuilderSupplier.get().build(request),
+            rootObjectBuilderSupplier.get().build(request)
+        );
+    }
+
+    public GraphQLBatchedInvocationInput create(List<GraphQLRequest> graphQLRequest, HandshakeRequest request) {
+        return new GraphQLBatchedInvocationInput(
+            graphQLRequest,
+            schemaProviderSupplier.get().getSchema(request),
+            contextBuilderSupplier.get().build(request),
+            rootObjectBuilderSupplier.get().build(request)
+        );
+    }
+
+    public static Builder newBuilder(GraphQLSchema schema) {
+        return new Builder(new DefaultGraphQLSchemaProvider(schema));
+    }
+
+    public static Builder newBuilder(GraphQLSchemaProvider schemaProvider) {
+        return new Builder(schemaProvider);
+    }
+
+    public static Builder newBuilder(Supplier<GraphQLSchemaProvider> schemaProviderSupplier) {
+        return new Builder(schemaProviderSupplier);
+    }
+
+    public static class Builder {
+        private final Supplier<GraphQLSchemaProvider> schemaProviderSupplier;
+        private Supplier<GraphQLContextBuilder> contextBuilderSupplier = DefaultGraphQLContextBuilder::new;
+        private Supplier<GraphQLRootObjectBuilder> rootObjectBuilderSupplier = DefaultGraphQLRootObjectBuilder::new;
+
+        public Builder(GraphQLSchemaProvider schemaProvider) {
+            this(() -> schemaProvider);
+        }
+
+        public Builder(Supplier<GraphQLSchemaProvider> schemaProviderSupplier) {
+            this.schemaProviderSupplier = schemaProviderSupplier;
+        }
+
+        public Builder withGraphQLContextBuilder(GraphQLContextBuilder contextBuilder) {
+            return withGraphQLContextBuilder(() -> contextBuilder);
+        }
+
+        public Builder withGraphQLContextBuilder(Supplier<GraphQLContextBuilder> contextBuilderSupplier) {
+            this.contextBuilderSupplier = contextBuilderSupplier;
+            return this;
+        }
+
+        public Builder withGraphQLRootObjectBuilder(GraphQLRootObjectBuilder rootObjectBuilder) {
+            return withGraphQLRootObjectBuilder(() -> rootObjectBuilder);
+        }
+
+        public Builder withGraphQLRootObjectBuilder(Supplier<GraphQLRootObjectBuilder> rootObjectBuilderSupplier) {
+            this.rootObjectBuilderSupplier = rootObjectBuilderSupplier;
+            return this;
+        }
+
+        public GraphQLInvocationInputFactory build() {
+            return new GraphQLInvocationInputFactory(schemaProviderSupplier, contextBuilderSupplier, rootObjectBuilderSupplier);
+        }
+    }
+}