Examples with DataLoaderDispatcherInstrumentation graphql.execution.instrumentation.dataloader.DataLoaderDispatcherInstrumentation used on opensource projects

Example 1 with DataLoaderDispatcherInstrumentation

use of graphql.execution.instrumentation.dataloader.DataLoaderDispatcherInstrumentation in project graphql-java by graphql-java.

the class BatchingExamples method perRequestGraphQl.

private void perRequestGraphQl() {
    GraphQLSchema staticSchema = staticSchema_Or_MayBeFrom_IoC_Injection();
    DataLoaderRegistry registry = new DataLoaderRegistry();
    registry.register("character", getCharacterDataLoader());
    DataLoaderDispatcherInstrumentation dispatcherInstrumentation = new DataLoaderDispatcherInstrumentation(registry);
    GraphQL graphQL = GraphQL.newGraphQL(staticSchema).instrumentation(dispatcherInstrumentation).build();
    graphQL.execute("{ helloworld }");
// you can now throw away the GraphQL and hence DataLoaderDispatcherInstrumentation
// and DataLoaderRegistry objects since they are really cheap to build per request
}

Example 2 with DataLoaderDispatcherInstrumentation

use of graphql.execution.instrumentation.dataloader.DataLoaderDispatcherInstrumentation in project graphql-java by graphql-java.

the class HttpMain method handleStarWars.

private void handleStarWars(HttpServletRequest httpRequest, HttpServletResponse httpResponse) throws IOException {
    // 
    // this builds out the parameters we need like the graphql query from the http request
    QueryParameters parameters = QueryParameters.from(httpRequest);
    if (parameters.getQuery() == null) {
        // 
        // how to handle nonsensical requests is up to your application
        httpResponse.setStatus(400);
        return;
    }
    ExecutionInput.Builder executionInput = newExecutionInput().query(parameters.getQuery()).operationName(parameters.getOperationName()).variables(parameters.getVariables());
    // 
    // This example uses the DataLoader technique to ensure that the most efficient
    // loading of data (in this case StarWars characters) happens.  We pass that to data
    // fetchers via the graphql context object.
    // 
    DataLoaderRegistry dataLoaderRegistry = buildDataLoaderRegistry();
    // 
    // the context object is something that means something to down stream code.  It is instructions
    // from yourself to your other code such as DataFetchers.  The engine passes this on unchanged and
    // makes it available to inner code
    // 
    // the graphql guidance says  :
    // 
    // - GraphQL should be placed after all authentication middleware, so that you
    // - have access to the same session and user information you would in your
    // - HTTP endpoint handlers.
    // 
    Map<String, Object> context = new HashMap<>();
    context.put("YouAppSecurityClearanceLevel", "CodeRed");
    context.put("YouAppExecutingUser", "Dr Nefarious");
    context.put("dataloaderRegistry", dataLoaderRegistry);
    executionInput.context(context);
    // 
    // you need a schema in order to execute queries
    GraphQLSchema schema = buildStarWarsSchema();
    DataLoaderDispatcherInstrumentation dlInstrumentation = new DataLoaderDispatcherInstrumentation(dataLoaderRegistry, newOptions().includeStatistics(true));
    Instrumentation instrumentation = new ChainedInstrumentation(asList(new TracingInstrumentation(), dlInstrumentation));
    // finally you build a runtime graphql object and execute the query
    GraphQL graphQL = GraphQL.newGraphQL(schema).instrumentation(instrumentation).build();
    ExecutionResult executionResult = graphQL.execute(executionInput.build());
    returnAsJson(httpResponse, executionResult);
}

Example 3 with DataLoaderDispatcherInstrumentation

use of graphql.execution.instrumentation.dataloader.DataLoaderDispatcherInstrumentation in project graphql-java by graphql-java.

the class BatchingExamples method starWarsExample.

void starWarsExample() {
    // a batch loader function that will be called with N or more keys for batch loading
    BatchLoader<String, Object> characterBatchLoader = new BatchLoader<String, Object>() {

        @Override
        public CompletionStage<List<Object>> load(List<String> keys) {
            // 
            return CompletableFuture.supplyAsync(() -> getCharacterDataViaBatchHTTPApi(keys));
        }
    };
    // a data loader for characters that points to the character batch loader
    DataLoader<String, Object> characterDataLoader = new DataLoader<>(characterBatchLoader);
    // 
    // use this data loader in the data fetchers associated with characters and put them into
    // the graphql schema (not shown)
    // 
    DataFetcher heroDataFetcher = new DataFetcher() {

        @Override
        public Object get(DataFetchingEnvironment environment) {
            // R2D2
            return characterDataLoader.load("2001");
        }
    };
    DataFetcher friendsDataFetcher = new DataFetcher() {

        @Override
        public Object get(DataFetchingEnvironment environment) {
            StarWarsCharacter starWarsCharacter = environment.getSource();
            List<String> friendIds = starWarsCharacter.getFriendIds();
            return characterDataLoader.loadMany(friendIds);
        }
    };
    // 
    // DataLoaderRegistry is a place to register all data loaders in that needs to be dispatched together
    // in this case there is 1 but you can have many
    // 
    DataLoaderRegistry registry = new DataLoaderRegistry();
    registry.register("character", characterDataLoader);
    // 
    // this instrumentation implementation will dispatched all the dataloaders
    // as each level fo the graphql query is executed and hence make batched objects
    // available to the query and the associated DataFetchers
    // 
    DataLoaderDispatcherInstrumentation dispatcherInstrumentation = new DataLoaderDispatcherInstrumentation(registry);
    // 
    // now build your graphql object and execute queries on it.
    // the data loader will be invoked via the data fetchers on the
    // schema fields
    // 
    GraphQL graphQL = GraphQL.newGraphQL(buildSchema()).instrumentation(dispatcherInstrumentation).build();
}