# Vert.x Web GraphQL

Vert.x Web GraphQL extends Vert.x Web with the GraphQL-Java library so that you can build a GraphQL server.

Tip | This is the reference documentation for Vert.x Web GraphQL. It is highly recommended to get familiar with the GraphQL-Java API first. You may start by reading the GraphQL-Java documentation.

Warning | This module has Tech Preview status, this means the API can change between versions.

## Getting started

To use this module, add the following to the dependencies section of your Maven POM file:

    <dependency>
     <groupId>io.vertx</groupId>
     <artifactId>vertx-web-graphql</artifactId>
     <version>3.9.0</version>
    </dependency>

Or, if you use Gradle:

    compile 'io.vertx:vertx-web-graphql:3.9.0'

## Handler setup

Create a Vert.x Web `Route` and a `GraphQLHandler` for it:

    var GraphQLHandler = require("vertx-web-graphql-js/graph_ql_handler");
    var graphQL = setupGraphQLJava();

    router.route("/graphql").handler(GraphQLHandler.create(graphQL).handle);

The handler serves both `GET` and `POST` requests. However you can restrict the service to one type of HTTP method:

    var GraphQLHandler = require("vertx-web-graphql-js/graph_ql_handler");
    var graphQL = setupGraphQLJava();

    router.post("/graphql").handler(GraphQLHandler.create(graphQL).handle);

Tip | The `GraphQLHandler` does not require a `BodyHandler` to read `POST` requests content.

### GraphiQL client

As you are building your application, testing your GraphQL queries in GraphiQL can be handy.

To do so, create a route for GraphiQL resources and a `GraphiQLHandler` for them:

    var GraphiQLHandler = require("vertx-web-graphql-js/graphi_ql_handler");
    var options = {
      "enabled" : true
    };

    router.route("/graphiql/*").handler(GraphiQLHandler.create(options).handle);

Then browse to http://localhost:8080/graphiql/.

Note | The GraphiQL user interface is disabled by default for security reasons. This is why you must configure the `GraphiQLHandlerOptions` to enable it.

Tip | GraphiQL is enabled automatically when Vert.x Web runs in development mode. To switch the development mode on, use the `VERTXWEB_ENVIRONMENT` environment variable or `vertxweb.environment` system property and set it to `dev`. In this case, create the `GraphiQLHandler` without changing the `enabled` property.

If your application is protected by authentication, you can customize the headers sent by GraphiQL dynamically:

    var MultiMap = require("vertx-js/multi_map");
    graphiQLHandler.graphiQLRequestHeaders(function (rc) {
      var token = rc.get("token");
      return MultiMap.caseInsensitiveMultiMap().add(Java.type("io.vertx.core.http.HttpHeaders").AUTHORIZATION, "Bearer " + token)
    });

    router.route("/graphiql/*").handler(graphiQLHandler.handle);

Please refer to the `GraphiQLHandlerOptions` documentation for further details.

### Enable query batching

Query batching consists in posting an array instead of a single object to the GraphQL endpoint.

Vert.x Web GraphQL can handle such requests but by default the feature is disabled. To enable it, create the `GraphQLHandler` with options:

    var GraphQLHandler = require("vertx-web-graphql-js/graph_ql_handler");
    var options = {
      "requestBatchingEnabled" : true
    };

    var handler = GraphQLHandler.create(graphQL, options);

## Building a GraphQL server

The GraphQL-Java API is very well suited for the asynchronous world: the asynchronous execution strategy is the default for queries (serial asynchronous for mutations).

To avoid blocking the event loop, all you have to do is implement data fetchers that return a `CompletionStage` instead of the result directly.

    var dataFetcher = function (environment) {

      var completableFuture = new (Java.type("java.util.concurrent.CompletableFuture"))();

      retrieveLinksFromBackend(environment, function (ar, ar_err) {
        if (ar_err == null) {
          completableFuture.complete(ar);
        } else {
          completableFuture.completeExceptionally(ar_err);
        }
      });

      return completableFuture
    };

    var runtimeWiring = Java.type("graphql.schema.idl.RuntimeWiring").newRuntimeWiring().type("Query", function (builder) {
      builder.dataFetcher("allLinks", dataFetcher);
    }).build();

### Fetching data with callback-based APIs

Implementing a data fetcher that returns a `CompletionStage` is not a complex task. But when you work with Vert.x callback-based APIs, it requires a bit of boilerplate.

This is where the `VertxDataFetcher` can help:

    var dataFetcher = new (Java.type("io.vertx.ext.web.handler.graphql.VertxDataFetcher"))(function (environment, future) {

      retrieveLinksFromBackend(environment, future);

    });

    var runtimeWiring = Java.type("graphql.schema.idl.RuntimeWiring").newRuntimeWiring().type("Query", function (builder) {
      builder.dataFetcher("allLinks", dataFetcher);
    }).build();

### Providing data fetchers with some context

Very often, the `GraphQLHandler` will be declared after other route handlers. For example, you could protect your application with authentication.

In this case, it is likely that your data fetchers will need to know which user is logged-in to narrow down the results. Let’s say your authentication layer stores a `User` object in the `RoutingContext`.

You may retrieve this object by inspecting the `DataFetchingEnvironment`:

    var dataFetcher = new (Java.type("io.vertx.ext.web.handler.graphql.VertxDataFetcher"))(function (environment, future) {

      var routingContext = environment.getContext();

      var user = routingContext.get("user");

      retrieveLinksPostedBy(user, future);

    });

Note | The routing context is available with any kind of data fetchers, not just `VertxDataFetcher`.

If you prefer not to expose the routing context to your data fetchers, configure the GraphQL handler to customize the context object:

    var GraphQLHandler = require("vertx-web-graphql-js/graph_ql_handler");
    var dataFetcher = new (Java.type("io.vertx.ext.web.handler.graphql.VertxDataFetcher"))(function (environment, future) {

      // User as custom context object
      var user = environment.getContext();

      retrieveLinksPostedBy(user, future);

    });

    var graphQL = setupGraphQLJava(dataFetcher);

    // Customize the query context object when setting up the handler
    var handler = GraphQLHandler.create(graphQL).queryContext(function (routingContext) {

      return routingContext.get("user")

    });

    router.route("/graphql").handler(handler.handle);

### JSON data results

The default GraphQL data fetcher is `PropertyDataFetcher`. As a consequence, it will be able to read the fields of your domain objects without further configuration.

Nevertheless, some Vert.x data clients return `JsonArray` and `JsonObject` results.

If you don’t need (or don’t wish to) use a domain object layer, you can configure GraphQL-Java to use `VertxPropertyDataFetcher` instead:

    var builder = Java.type("graphql.schema.idl.RuntimeWiring").newRuntimeWiring();

    builder.wiringFactory(new (Java.type("graphql.schema.idl.WiringFactory"))());

Tip | `VertxPropertyDataFetcher` wraps a `PropertyDataFetcher` so you can still use it with domain objects.

### Using dataloaders

Dataloaders help you to load data efficiently by batching fetch requests and caching results.

First, create a batch loader:

    var linksBatchLoader = function (keys, environment) {

      return retrieveLinksFromBackend(keys, environment)

    };

Tip | If you work with Vert.x callback-based APIs, you may use a `VertxBatchLoader` or a `VertxMappedBatchLoader` to simplify your code.

Then, configure the `GraphQLHandler` to create a `DataLoaderRegistry` for each request:

    Code not translatable

### Apollo WebSocketLink

You can use an Apollo WebSocketLink which connects over a websocket. This is specially useful if you want to add subscriptions to your GraphQL schema, but you can also use the websocket for queries and mutations.

    var ApolloWSHandler = require("vertx-web-graphql-js/apollo_ws_handler");
    var graphQL = setupGraphQLJava();

    router.route("/graphql").handler(ApolloWSHandler.create(graphQL).handle);

Important | To support the `graphql-ws` websocket subprotocol, it has to be added to the server configuration:

    var httpServerOptions = {
      "webSocketSubProtocols" : [
        "graphql-ws"
      ]
    };
    vertx.createHttpServer(httpServerOptions).requestHandler(router.handle).listen(8080);

Note | If you want to support a WebSocketLink and a HttpLink in the same path, you can add the ApolloWSHandler in first place and then the GraphQLHandler.

    var ApolloWSHandler = require("vertx-web-graphql-js/apollo_ws_handler");
    var GraphQLHandler = require("vertx-web-graphql-js/graph_ql_handler");
    var graphQL = setupGraphQLJava();

    router.route("/graphql").handler(ApolloWSHandler.create(graphQL).handle);
    router.route("/graphql").handler(GraphQLHandler.create(graphQL).handle);

Here you can find how to configure the Apollo SubscriptionClient: https://github.com/apollographql/subscriptions-transport-ws

Important | A subscription `DataFetcher` has to return a `org.reactivestreams.Publisher` instance.