graphql.servlet.GraphQLServlet Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of graphql-java-servlet Show documentation
Show all versions of graphql-java-servlet Show documentation
relay.js-compatible GraphQL servlet
/**
* 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 com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.RuntimeJsonMappingException;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import graphql.ExecutionResult;
import graphql.GraphQL;
import graphql.GraphQLError;
import graphql.execution.instrumentation.Instrumentation;
import graphql.introspection.IntrospectionQuery;
import graphql.schema.GraphQLFieldDefinition;
import graphql.schema.GraphQLSchema;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.security.auth.Subject;
import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* @author Andrew Potter
*/
public abstract class GraphQLServlet extends HttpServlet implements Servlet, GraphQLMBean {
public static final Logger log = LoggerFactory.getLogger(GraphQLServlet.class);
public static final String APPLICATION_JSON_UTF8 = "application/json;charset=UTF-8";
public static final int STATUS_OK = 200;
public static final int STATUS_BAD_REQUEST = 400;
private static final ObjectMapper mapper = new ObjectMapper();
protected abstract GraphQLSchemaProvider getSchemaProvider();
protected abstract GraphQLContext createContext(Optional request, Optional response);
protected abstract ExecutionStrategyProvider getExecutionStrategyProvider();
protected abstract Instrumentation getInstrumentation();
protected abstract Map transformVariables(GraphQLSchema schema, String query, Map variables);
protected abstract GraphQLErrorHandler getGraphQLErrorHandler();
private final List listeners;
private final ServletFileUpload fileUpload;
private final RequestHandler getHandler;
private final RequestHandler postHandler;
public GraphQLServlet() {
this(null, null);
}
public GraphQLServlet(List listeners, FileItemFactory fileItemFactory) {
this.listeners = listeners != null ? new ArrayList<>(listeners) : new ArrayList<>();
this.fileUpload = new ServletFileUpload(fileItemFactory != null ? fileItemFactory : new DiskFileItemFactory());
this.getHandler = (request, response) -> {
final GraphQLContext context = createContext(Optional.of(request), Optional.of(response));
String path = request.getPathInfo();
if (path == null) {
path = request.getServletPath();
}
if (path.contentEquals("/schema.json")) {
query(IntrospectionQuery.INTROSPECTION_QUERY, null, new HashMap<>(), getSchemaProvider().getSchema(request), request, response, context);
} else {
if (request.getParameter("query") != null) {
final Map variables = new HashMap<>();
if (request.getParameter("variables") != null) {
variables.putAll(deserializeVariables(request.getParameter("variables")));
}
String operationName = null;
if (request.getParameter("operationName") != null) {
operationName = request.getParameter("operationName");
}
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");
}
}
};
this.postHandler = (request, response) -> {
final GraphQLContext context = createContext(Optional.of(request), Optional.of(response));
GraphQLRequest graphQLRequest = null;
try {
InputStream inputStream = null;
if (ServletFileUpload.isMultipartContent(request)) {
final Map> fileItems = fileUpload.parseParameterMap(request);
if (fileItems.containsKey("graphql")) {
final Optional graphqlItem = getFileItem(fileItems, "graphql");
if (graphqlItem.isPresent()) {
inputStream = graphqlItem.get().getInputStream();
}
} else if (fileItems.containsKey("query")) {
final Optional queryItem = getFileItem(fileItems, "query");
if (queryItem.isPresent()) {
graphQLRequest = new GraphQLRequest();
graphQLRequest.setQuery(new String(queryItem.get().get()));
final Optional operationNameItem = getFileItem(fileItems, "operationName");
if (operationNameItem.isPresent()) {
graphQLRequest.setOperationName(new String(operationNameItem.get().get()).trim());
}
final Optional variablesItem = getFileItem(fileItems, "variables");
if (variablesItem.isPresent()) {
String variables = new String(variablesItem.get().get());
if (!variables.isEmpty()) {
graphQLRequest.setVariables(deserializeVariables(variables));
}
}
}
}
if (inputStream == null && graphQLRequest == null) {
response.setStatus(STATUS_BAD_REQUEST);
log.info("Bad POST multipart request: no part named \"graphql\" or \"query\"");
return;
}
context.setFiles(Optional.of(fileItems));
} else {
// this is not a multipart request
inputStream = request.getInputStream();
}
if (graphQLRequest == null) {
graphQLRequest = mapper.readValue(inputStream, GraphQLRequest.class);
}
} catch (Exception e) {
log.info("Bad POST request: parsing failed", e);
response.setStatus(STATUS_BAD_REQUEST);
return;
}
Map variables = graphQLRequest.getVariables();
if (variables == null) {
variables = new HashMap<>();
}
query(graphQLRequest.getQuery(), graphQLRequest.getOperationName(), variables, getSchemaProvider().getSchema(request), request, response, context);
};
}
public void addListener(GraphQLServletListener servletListener) {
listeners.add(servletListener);
}
public void removeListener(GraphQLServletListener servletListener) {
listeners.remove(servletListener);
}
@Override
public String[] getQueries() {
return getSchemaProvider().getSchema().getQueryType().getFieldDefinitions().stream().map(GraphQLFieldDefinition::getName).toArray(String[]::new);
}
@Override
public String[] getMutations() {
return getSchemaProvider().getSchema().getMutationType().getFieldDefinitions().stream().map(GraphQLFieldDefinition::getName).toArray(String[]::new);
}
@Override
public String executeQuery(String query) {
try {
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();
}
}
private void doRequest(HttpServletRequest request, HttpServletResponse response, RequestHandler handler) {
List requestCallbacks = runListeners(l -> l.onRequest(request, response));
try {
handler.handle(request, response);
runCallbacks(requestCallbacks, c -> c.onSuccess(request, response));
} catch (Throwable t) {
response.setStatus(500);
log.error("Error executing GraphQL request!", t);
runCallbacks(requestCallbacks, c -> c.onError(request, response, t));
} finally {
runCallbacks(requestCallbacks, c -> c.onFinally(request, response));
}
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doRequest(req, resp, getHandler);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doRequest(req, resp, postHandler);
}
private Optional getFileItem(Map> fileItems, String name) {
List items = fileItems.get(name);
if(items == null || items.isEmpty()) {
return Optional.empty();
}
return items.stream().findFirst();
}
private GraphQL newGraphQL(GraphQLSchema schema) {
ExecutionStrategyProvider executionStrategyProvider = getExecutionStrategyProvider();
return GraphQL.newGraphQL(schema)
.queryExecutionStrategy(executionStrategyProvider.getQueryExecutionStrategy())
.mutationExecutionStrategy(executionStrategyProvider.getMutationExecutionStrategy())
.subscriptionExecutionStrategy(executionStrategyProvider.getSubscriptionExecutionStrategy())
.instrumentation(getInstrumentation())
.build();
}
private void query(String query, String operationName, Map variables, GraphQLSchema schema, HttpServletRequest req, HttpServletResponse resp, GraphQLContext context) throws IOException {
if (operationName != null && operationName.isEmpty()) {
query(query, null, variables, schema, req, resp, context);
} else if (Subject.getSubject(AccessController.getContext()) == null && context.getSubject().isPresent()) {
Subject.doAs(context.getSubject().get(), (PrivilegedAction) () -> {
try {
query(query, operationName, variables, schema, req, resp, context);
} catch (IOException e) {
throw new RuntimeException(e);
}
return null;
});
} else {
List operationCallbacks = runListeners(l -> l.onOperation(context, operationName, query, variables));
final ExecutionResult executionResult = newGraphQL(schema).execute(query, operationName, context, transformVariables(schema, query, variables));
final List errors = executionResult.getErrors();
final Object data = executionResult.getData();
final String response = mapper.writeValueAsString(createResultFromDataAndErrors(data, errors));
resp.setContentType(APPLICATION_JSON_UTF8);
resp.setStatus(STATUS_OK);
resp.getWriter().write(response);
if(getGraphQLErrorHandler().errorsPresent(errors)) {
runCallbacks(operationCallbacks, c -> c.onError(context, operationName, query, variables, data, errors));
} else {
runCallbacks(operationCallbacks, c -> c.onSuccess(context, operationName, query, variables, data));
}
runCallbacks(operationCallbacks, c -> c.onFinally(context, operationName, query, variables, data));
}
}
private Map createResultFromDataAndErrors(Object data, List errors) {
final Map result = new HashMap<>();
result.put("data", data);
if (getGraphQLErrorHandler().errorsPresent(errors)) {
result.put("errors", getGraphQLErrorHandler().processErrors(errors));
}
return result;
}
private List runListeners(Function action) {
if (listeners == null) {
return Collections.emptyList();
}
return listeners.stream()
.map(listener -> {
try {
return action.apply(listener);
} catch (Throwable t) {
log.error("Error running listener: {}", listener, t);
return null;
}
})
.filter(Objects::nonNull)
.collect(Collectors.toList());
}
private void runCallbacks(List callbacks, Consumer action) {
callbacks.forEach(callback -> {
try {
action.accept(callback);
} catch (Throwable t) {
log.error("Error running callback: {}", callback, t);
}
});
}
protected static class VariablesDeserializer extends JsonDeserializer> {
@Override
public Map deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
return deserializeVariablesObject(p.readValueAs(Object.class));
}
}
private static Map deserializeVariables(String variables) {
try {
return deserializeVariablesObject(mapper.readValue(variables, Object.class));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static Map deserializeVariablesObject(Object variables) {
if (variables instanceof Map) {
@SuppressWarnings("unchecked")
Map genericVariables = (Map) variables;
return genericVariables;
} else if (variables instanceof String) {
try {
return mapper.readValue((String) variables, new TypeReference>() {});
} catch (IOException e) {
throw new RuntimeException(e);
}
} else {
throw new RuntimeException("variables should be either an object or a string");
}
}
protected static class GraphQLRequest {
private String query;
@JsonDeserialize(using = GraphQLServlet.VariablesDeserializer.class)
private Map variables = new HashMap<>();
private String operationName;
public String getQuery() {
return query;
}
public void setQuery(String query) {
this.query = query;
}
public Map getVariables() {
return variables;
}
public void setVariables(Map variables) {
this.variables = variables;
}
public String getOperationName() {
return operationName;
}
public void setOperationName(String operationName) {
this.operationName = operationName;
}
}
protected interface RequestHandler extends BiConsumer {
@Override
default void accept(HttpServletRequest request, HttpServletResponse response) {
try {
handle(request, response);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
void handle(HttpServletRequest request, HttpServletResponse response) throws Exception;
}
}