Update to graphql-java 3.0 and use GraphQLSchemaProvider in simple servlet (fixes #29)

Author: apottere

build.gradle

@@ -56,7 +56,7 @@ dependencies {
     compile 'commons-fileupload:commons-fileupload:1.3.1'
 
     // GraphQL
-    compile 'com.graphql-java:graphql-java:2.4.0'
+    compile 'com.graphql-java:graphql-java:3.0.0'
 
     compileOnly 'com.graphql-java:graphql-java-annotations:0.13.1'
     testCompile 'com.graphql-java:graphql-java-annotations:0.13.1'

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

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2016 Yurii Rashkovskii
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ */
+package graphql.servlet;
+
+import graphql.schema.GraphQLSchema;
+
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * @author Andrew Potter
+ */
+public class DefaultGraphQLSchemaProvider implements GraphQLSchemaProvider {
+
+    private final GraphQLSchema schema;
+    private final GraphQLSchema readOnlySchema;
+
+    public DefaultGraphQLSchemaProvider(GraphQLSchema schema) {
+        this(schema, GraphQLSchemaProvider.copyReadOnly(schema));
+    }
+
+    public DefaultGraphQLSchemaProvider(GraphQLSchema schema, GraphQLSchema readOnlySchema) {
+        this.schema = schema;
+        this.readOnlySchema = readOnlySchema;
+    }
+
+
+    @Override
+    public GraphQLSchema getSchema(HttpServletRequest request) {
+        return getSchema();
+    }
+
+    @Override
+    public GraphQLSchema getSchema() {
+        return schema;
+    }
+
+    @Override
+    public GraphQLSchema getReadOnlySchema(HttpServletRequest request) {
+        return readOnlySchema;
+    }
+}

src/main/java/graphql/servlet/GraphQLSchemaProvider.java

@@ -16,7 +16,27 @@
 
 import graphql.schema.GraphQLSchema;
 
+import javax.servlet.http.HttpServletRequest;
+
 public interface GraphQLSchemaProvider {
+
+    static GraphQLSchema copyReadOnly(GraphQLSchema schema) {
+        return GraphQLSchema.newSchema().query(schema.getQueryType()).build(schema.getAdditionalTypes());
+    }
+
+    /**
+     * return a schema based on the request (auth, etc).  Optional is empty when called from an mbean.
+     */
+    GraphQLSchema getSchema(HttpServletRequest request);
+
+
+    /**
+     * return a schema for handling mbean calls.
+     */
     GraphQLSchema getSchema();
-    GraphQLSchema getReadOnlySchema();
+
+    /**
+     * return a read-only schema based on the request (auth, etc).  Should return the same schema as {@link #getSchema(HttpServletRequest)} for a given request.
+     */
+    GraphQLSchema getReadOnlySchema(HttpServletRequest request);
 }

src/main/java/graphql/servlet/GraphQLServlet.java

@@ -21,12 +21,13 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.RuntimeJsonMappingException;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
-import com.google.common.io.CharStreams;
 import graphql.ExecutionResult;
+import graphql.GraphQL;
 import graphql.GraphQLError;
 import graphql.InvalidSyntaxError;
 import graphql.execution.ExecutionStrategy;
 import graphql.execution.instrumentation.Instrumentation;
+import graphql.introspection.IntrospectionQuery;
 import graphql.schema.GraphQLFieldDefinition;
 import graphql.schema.GraphQLSchema;
 import graphql.validation.ValidationError;
@@ -45,7 +46,6 @@
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.InputStreamReader;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.ArrayList;
@@ -57,12 +57,10 @@
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
-import static graphql.GraphQL.newGraphQL;
-
 /**
  * @author Andrew Potter
  */
-public abstract class GraphQLServlet extends HttpServlet implements Servlet, GraphQLMBean, GraphQLSchemaProvider {
+public abstract class GraphQLServlet extends HttpServlet implements Servlet, GraphQLMBean {
 
     public static final Logger log = LoggerFactory.getLogger(GraphQLServlet.class);
 
@@ -72,8 +70,10 @@ public abstract class GraphQLServlet extends HttpServlet implements Servlet, Gra
 
     private static final ObjectMapper mapper = new ObjectMapper();
 
+    protected abstract GraphQLSchemaProvider getSchemaProvider();
     protected abstract GraphQLContext createContext(Optional<HttpServletRequest> request, Optional<HttpServletResponse> response);
-    protected abstract ExecutionStrategy getExecutionStrategy();
+    protected abstract ExecutionStrategy getQueryExecutionStrategy();
+    protected abstract ExecutionStrategy getMutationExecutionStrategy();
     protected abstract Instrumentation getInstrumentation();
     protected abstract Map<String, Object> transformVariables(GraphQLSchema schema, String query, Map<String, Object> variables);
 
@@ -100,7 +100,7 @@ public GraphQLServlet(List<GraphQLOperationListener> operationListeners, List<Gr
                 path = request.getServletPath();
             }
             if (path.contentEquals("/schema.json")) {
-                query(CharStreams.toString(new InputStreamReader(GraphQLServlet.class.getResourceAsStream("introspectionQuery"))), null, new HashMap<>(), getSchema(), request, response, context);
+                query(IntrospectionQuery.INTROSPECTION_QUERY, null, new HashMap<>(), getSchemaProvider().getSchema(request), request, response, context);
             } else {
                 if (request.getParameter("query") != null) {
                     final Map<String, Object> variables = new HashMap<>();
@@ -111,7 +111,7 @@ public GraphQLServlet(List<GraphQLOperationListener> operationListeners, List<Gr
                     if (request.getParameter("operationName") != null) {
                         operationName = request.getParameter("operationName");
                     }
-                    query(request.getParameter("query"), operationName, variables, getReadOnlySchema(), request, response, context);
+                    query(request.getParameter("query"), operationName, variables, getSchemaProvider().getReadOnlySchema(request), request, response, context);
                 } else {
                     response.setStatus(STATUS_BAD_REQUEST);
                     log.info("Bad GET request: path was not \"/schema.json\" or no query variable named \"query\" given");
@@ -184,7 +184,7 @@ public GraphQLServlet(List<GraphQLOperationListener> operationListeners, List<Gr
                 variables = new HashMap<>();
             }
 
-            query(graphQLRequest.getQuery(), graphQLRequest.getOperationName(), variables, getSchema(), request, response, context);
+            query(graphQLRequest.getQuery(), graphQLRequest.getOperationName(), variables, getSchemaProvider().getSchema(request), request, response, context);
         };
     }
 
@@ -206,18 +206,18 @@ public void removeServletListener(GraphQLServletListener servletListener) {
 
     @Override
     public String[] getQueries() {
-        return getSchema().getQueryType().getFieldDefinitions().stream().map(GraphQLFieldDefinition::getName).toArray(String[]::new);
+        return getSchemaProvider().getSchema().getQueryType().getFieldDefinitions().stream().map(GraphQLFieldDefinition::getName).toArray(String[]::new);
     }
 
     @Override
     public String[] getMutations() {
-        return getSchema().getMutationType().getFieldDefinitions().stream().map(GraphQLFieldDefinition::getName).toArray(String[]::new);
+        return getSchemaProvider().getSchema().getMutationType().getFieldDefinitions().stream().map(GraphQLFieldDefinition::getName).toArray(String[]::new);
     }
 
     @Override
     public String executeQuery(String query) {
         try {
-            final ExecutionResult result = newGraphQL(getSchema()).instrumentation(getInstrumentation()).build().execute(query, createContext(Optional.empty(), Optional.empty()), new HashMap<>());
+            final ExecutionResult result = newGraphQL(getSchemaProvider().getSchema()).execute(query, createContext(Optional.empty(), Optional.empty()), new HashMap<>());
             return mapper.writeValueAsString(createResultFromDataAndErrors(result.getData(), result.getErrors()));
         } catch (Exception e) {
             return e.getMessage();
@@ -257,6 +257,13 @@ private Optional<FileItem> getFileItem(Map<String, List<FileItem>> fileItems, St
         return items.stream().findFirst();
     }
 
+    private GraphQL newGraphQL(GraphQLSchema schema) {
+        return GraphQL.newGraphQL(schema)
+            .queryExecutionStrategy(getQueryExecutionStrategy())
+            .mutationExecutionStrategy(getMutationExecutionStrategy())
+            .instrumentation(getInstrumentation())
+            .build();
+    }
 
     private void query(String query, String operationName, Map<String, Object> variables, GraphQLSchema schema, HttpServletRequest req, HttpServletResponse resp, GraphQLContext context) throws IOException {
         if (Subject.getSubject(AccessController.getContext()) == null && context.getSubject().isPresent()) {
@@ -271,7 +278,7 @@ private void query(String query, String operationName, Map<String, Object> varia
         } else {
             runListeners(operationListeners, l -> runListener(l, it -> it.beforeGraphQLOperation(context, operationName, query, variables)));
 
-            final ExecutionResult executionResult = newGraphQL(schema).queryExecutionStrategy(getExecutionStrategy()).instrumentation(getInstrumentation()).build().execute(query, operationName, context, transformVariables(schema, query, variables));
+            final ExecutionResult executionResult = newGraphQL(schema).execute(query, operationName, context, transformVariables(schema, query, variables));
             final List<GraphQLError> errors = executionResult.getErrors();
             final Object data = executionResult.getData();
 

src/main/java/graphql/servlet/OsgiGraphQLServlet.java

@@ -51,17 +51,14 @@ public class OsgiGraphQLServlet extends GraphQLServlet {
     private ExecutionStrategyProvider executionStrategyProvider = new EnhancedExecutionStrategyProvider();
     private InstrumentationProvider instrumentationProvider = new NoOpInstrumentationProvider();
 
-    private GraphQLSchema schema;
-    private GraphQLSchema readOnlySchema;
+    private GraphQLSchemaProvider schemaProvider;
 
     protected void updateSchema() {
-        final GraphQLObjectType.Builder object = newObject().name("Query").description("Root query type");
+        final GraphQLObjectType.Builder queryTypeBuilder = newObject().name("Query").description("Root query type");
 
         for (GraphQLQueryProvider provider : queryProviders) {
             if (provider.getQueries() != null && !provider.getQueries().isEmpty()) {
-                for (GraphQLFieldDefinition graphQLFieldDefinition : provider.getQueries()) {
-                    object.field(graphQLFieldDefinition);
-                }
+                provider.getQueries().forEach(queryTypeBuilder::field);
             }
         }
 
@@ -70,24 +67,21 @@ protected void updateSchema() {
             types.addAll(typesProvider.getTypes());
         }
 
-        readOnlySchema = newSchema().query(object.build()).build(types);
+        GraphQLObjectType mutationType = null;
 
-        if (mutationProviders.isEmpty()) {
-            schema = readOnlySchema;
-        } else {
-            final GraphQLObjectType.Builder mutationObject = newObject().name("Mutation").description("Root mutation type");
+        if (!mutationProviders.isEmpty()) {
+            final GraphQLObjectType.Builder mutationTypeBuilder = newObject().name("Mutation").description("Root mutation type");
 
             for (GraphQLMutationProvider provider : mutationProviders) {
-                provider.getMutations().forEach(mutationObject::field);
+                provider.getMutations().forEach(mutationTypeBuilder::field);
             }
 
-            final GraphQLObjectType mutationType = mutationObject.build();
-            if (mutationType.getFieldDefinitions().isEmpty()) {
-                schema = readOnlySchema;
-            } else {
-                schema = newSchema().query(object.build()).mutation(mutationType).build();
+            if (!mutationTypeBuilder.build().getFieldDefinitions().isEmpty()) {
+                mutationType = mutationTypeBuilder.build();
             }
         }
+
+        this.schemaProvider = new DefaultGraphQLSchemaProvider(newSchema().query(queryTypeBuilder.build()).mutation(mutationType).build(types));
     }
 
     public OsgiGraphQLServlet() {
@@ -148,15 +142,25 @@ public void unsetInstrumentationProvider(ExecutionStrategyProvider provider) {
         instrumentationProvider = new NoOpInstrumentationProvider();
     }
 
+    @Override
+    protected GraphQLSchemaProvider getSchemaProvider() {
+        return schemaProvider;
+    }
+
     protected GraphQLContext createContext(Optional<HttpServletRequest> req, Optional<HttpServletResponse> resp) {
         return contextBuilder.build(req, resp);
     }
 
     @Override
-    protected ExecutionStrategy getExecutionStrategy() {
+    protected ExecutionStrategy getQueryExecutionStrategy() {
         return executionStrategyProvider.getExecutionStrategy();
     }
 
+    @Override
+    protected ExecutionStrategy getMutationExecutionStrategy() {
+        return getQueryExecutionStrategy();
+    }
+
     @Override
     protected Instrumentation getInstrumentation() {
         return instrumentationProvider.getInstrumentation();
@@ -175,14 +179,4 @@ public void bindOperationListener(GraphQLOperationListener listener) {
     public void unbindOperationListener(GraphQLOperationListener listener) {
         removeOperationListener(listener);
     }
-
-    @Override
-    public GraphQLSchema getSchema() {
-        return schema;
-    }
-
-    @Override
-    public GraphQLSchema getReadOnlySchema() {
-        return readOnlySchema;
-    }
 }