Question: Inject Request Context? about rejoiner HOT 16 OPEN

public class RQLServer {

  private static final int HTTP_PORT = 8080;
  private static final Logger logger = Logger.getLogger(Server.class.getName());

  public static void main(String[] args) throws Exception {
    Server server = new Server(HTTP_PORT);

    ServletContextHandler context = new ServletContextHandler(
        server,
        "/",
        ServletContextHandler.SESSIONS
    );

    context.addEventListener(new GuiceServletContextListener() {
      @Override
      protected Injector getInjector() {
        return Guice.createInjector(
            new SchemaProviderModule(),
            new RQLModule(),
            new RQLSchema(),
            new ServletModule() {
              @Override
              protected void configureServlets() {
                serve("/graphql").with(RQLHandler.class);
              }
            });
      }
    });

    context.addFilter(
        GuiceFilter.class,
        "/*",
        EnumSet.of(javax.servlet.DispatcherType.REQUEST, javax.servlet.DispatcherType.ASYNC)
    );

    context.addServlet(DefaultServlet.class, "/");

    try {
      logger.info("Server running on port " + HTTP_PORT);
      server.start();
      server.join();
    } catch (Exception e) {
      logger.info("error" + e.getMessage());
    } finally {
      server.destroy();
    }
  }
}

public class RQLModule extends AbstractModule {

  @Override
  protected void configure() {
  // ...
  }

  @Provides
  GraphQL getGraphQL(Injector injector) {
    GraphQLSchema schema = injector.getInstance(Key.get(GraphQLSchema.class, Schema.class));

    Instrumentation INSTRUMENTATION =
        new ChainedInstrumentation(
            Arrays.asList(
                GuavaListenableFutureSupport.listenableFutureInstrumentation(),
                new TracingInstrumentation()));

    return GraphQL.newGraphQL(schema).instrumentation(INSTRUMENTATION).build();
  }
}

@Singleton
public class RQLHandler extends HttpServlet {

  private static final TypeToken<Map<String, Object>> MAP_TYPE_TOKEN =
      new TypeToken<Map<String, Object>>() {
      };
  private static final Gson GSON = new GsonBuilder().serializeNulls().create();

  @Inject
  GraphQL graphQL;

  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {

    Map<String, Object> json = readJson(req);
    String query = (String) json.get("query");
    if (query == null) {
      resp.setStatus(400);
      return;
    }
    String operationName = (String) json.get("operationName");
    Map<String, Object> variables = getVariables(json.get("variables"));

    ExecutionInput executionInput =
        ExecutionInput.newExecutionInput()
            .query(query)
            .operationName(operationName)
            .variables(variables)
            .context(new Object())
            .build();

    ExecutionResult executionResult = graphQL.execute(executionInput);
    resp.setContentType("application/json");
    resp.setStatus(HttpServletResponse.SC_OK);

    GSON.toJson(executionResult.toSpecification(), resp.getWriter());
  }

  private static Map<String, Object> getVariables(Object variables) {
    Map<String, Object> variablesWithStringKey = new HashMap<>();
    if (variables instanceof Map) {
      ((Map) variables).forEach((k, v) -> variablesWithStringKey.put(String.valueOf(k), v));
    }
    return variablesWithStringKey;
  }

  private static Map<String, Object> readJson(HttpServletRequest request) {
    try {
      String json = CharStreams.toString(request.getReader());
      return jsonToMap(json);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

  private static Map<String, Object> jsonToMap(String json) {
    if (Strings.isNullOrEmpty(json)) {
      return ImmutableMap.of();
    }
    return Optional.<Map<String, Object>>ofNullable(GSON.fromJson(json, MAP_TYPE_TOKEN.getType()))
        .orElse(ImmutableMap.of());
  }
}

// AbstractModule
  @Provides
  @RequestScoped
  DataLoaderRegistry getLoaders(CoreClient client) {
    DataLoaderRegistry registry = new DataLoaderRegistry();

    BatchLoader<String, Book> batchBookLoader = ids -> {
      return FutureConverter.toCompletableFuture(client.getBooks(ids));
    };

    registry.register("books", new DataLoader<>(batchBookLoader));

    return registry;
  }

// Handler
  @Inject
  Provider<DataLoaderRegistry> registryProvider;

  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws IOException {

    DataLoaderRegistry registry = registryProvider.get();

    Map<String, Object> json = readJson(req);
    String query = (String) json.get("query");
    if (query == null) {
      resp.setStatus(400);
      return;
    }
    String operationName = (String) json.get("operationName");
    Map<String, Object> variables = getVariables(json.get("variables"));

    Instrumentation INSTRUMENTATION =
        new ChainedInstrumentation(
            Arrays.asList(
                GuavaListenableFutureSupport.listenableFutureInstrumentation(),
                new DataLoaderDispatcherInstrumentation(registry),
                new TracingInstrumentation()
            )
        );

    GraphQL graphQL = builder.instrumentation(INSTRUMENTATION).build();

    ExecutionInput executionInput =
        ExecutionInput.newExecutionInput()
            .query(query)
            .operationName(operationName)
            .variables(variables)
            .build();

    ExecutionResult executionResult = graphQL.execute(executionInput);
    resp.setContentType("application/json");
    resp.setStatus(HttpServletResponse.SC_OK);

    GSON.toJson(executionResult.toSpecification(), resp.getWriter());
  }

// SchemaModule
  @SchemaModification(addField = "book", onType = Shelf.class)
  ListenableFuture<Book> addBooksToShel(DataLoaderRegistry registry,
      Shelf shelf) {
    DataLoader<String, Book> loader = registry.getDataLoader("books");
    CompletableFuture<Listing> res = loader
        .load(String.valueOf(shelf.getBookIds()));

    return FutureConverter.toListenableFuture(res);
  }

// AbstractModule
  @Provides
  @Singleton
  Builder getGraphQL(@Schema GraphQLSchema schema) {
    return GraphQL.newGraphQL(schema);
  }

// Handler
  @Inject
  GraphQL.Builder builder;

  @Inject
  Provider<DataLoaderRegistry> registryProvider;

  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws IOException {
// ...

public class RQLDataLoaderProvider implements Provider<DataLoaderRegistry> {

  @Inject
  CoreClient core;

  @Inject
  LPClient lp;

  public static <T> CompletableFuture<T> asFuture(Callable<? extends T> callable,
      Executor executor) {
    CompletableFuture<T> future = new CompletableFuture<>();
    executor.execute(() -> {
      try {
        future.complete(callable.call());
      } catch (Throwable t) {
        future.completeExceptionally(t);
      }
    });

    return future;
  }

  BatchLoader<String, Listing> batchListingsLoader = ids -> asFuture(
      ServletScopes.transferRequest(() -> core.getListings(ids).getListingsList()),
      MoreExecutors.directExecutor());

  BatchLoader<String, Release> batchReleasesLoader = ids -> asFuture(
      ServletScopes.transferRequest(() -> lp.getReleases(ids).getReleasesList()),
      MoreExecutors.directExecutor());

  public DataLoaderRegistry get() {
    DataLoaderRegistry registry = new DataLoaderRegistry();

    registry.register("listings", new DataLoader<>(batchListingsLoader));
    registry.register("releases", new DataLoader<>(batchReleasesLoader));

    return registry;
  }
}

  @SchemaModification(addField = "release", onType = Listing.class)
  ListenableFuture<Release> listingToRelease(DataLoaderRegistry registry, Listing listing) {
    DataLoader<String, Release> loader = registry.getDataLoader("releases");
    return FutureConverter.toListenableFuture(loader.load(listing.getMerchandisingUuid()));
  }

  @SchemaModification(addField = "listing", onType = FeedEntry.class)
  ListenableFuture<Listing> feedEntryToListing(DataLoaderRegistry registry,
      FeedEntry entry) {
    if (entry.getType() == EntryType.LISTING) {
      DataLoader<String, Listing> loader = registry.getDataLoader("listings");
      CompletableFuture<Listing> res = loader.load(String.valueOf(entry.getId()));
      return FutureConverter.toListenableFuture(res);
    }

    return null;
  }

  @SchemaModification(addField = "lpFeed", onType = AuthUser.class)
  ImmutableList<FeedEntry> userToLPFeedEntries(
      @LPFeed FeedServiceGrpc.FeedServiceBlockingStub client,
      AuthUser user) {
    EntriesRequest.Builder req = EntriesRequest.newBuilder();
    req.setUserId(user.getResourceOwnerId());

    FeedResponse resp = client.getFeedEntries(req.build());
    return ImmutableList.copyOf(resp.getEntriesList());
  }