GraphQL Java

https://www.graphql-java.com/documentation/
Admin
GraphQL Java is a Java library that provides a complete implementation of the GraphQL specification,...
Tokens:44,563
Snippets:286
Trust Score:9.4
Update:1 week ago
Show doc for...
Tokens:
Raw
### Java example: Setting up DataLoader with batch loading, data fetchers, instrumentation, and execution

Source: https://www.graphql-java.com/documentation/batching

This snippet shows a complete setup for using DataLoader in graphql-java. It defines a BatchLoader that loads characters via a batch HTTP API, uses DataFetchers to load single and multiple keys, configures DataLoaderDispatcherInstrumentation with statistics, and executes a query with a DataLoaderRegistry. Note that DataLoaderDispatcherInstrumentation is automatically added if not manually configured.

```java
//  

// a batch loader function that will be called with N or more keys for batch loading  

// This can be a singleton object since it's stateless  

//  

BatchLoader<String, Object> characterBatchLoader = new BatchLoader<String, Object>() {  

    @Override  

    public CompletionStage<List<Object>> load(List<String> keys) {  

        //  

        // we use supplyAsync() of values here for maximum parallelisation  

        //  

        return CompletableFuture.supplyAsync(() -> getCharacterDataViaBatchHTTPApi(keys));  

    }  

};  

  

//  

// use this data loader in the data fetchers associated with characters and put them into  

// the graphql schema (not shown)  

//  

DataFetcher<?> heroDataFetcher = new DataFetcher<Object>() {  

    @Override  

    public Object get(DataFetchingEnvironment environment) {  

        DataLoader<String, Object> dataLoader = environment.getDataLoader("character");  

        return dataLoader.load("2001"); // R2D2  

    }  

};  

  

DataFetcher<?> friendsDataFetcher = new DataFetcher<Object>() {  

    @Override  

    public Object get(DataFetchingEnvironment environment) {  

        StarWarsCharacter starWarsCharacter = environment.getSource();  

        List<String> friendIds = starWarsCharacter.getFriendIds();  

        DataLoader<String, Object> dataLoader = environment.getDataLoader("character");  

        return dataLoader.loadMany(friendIds);  

    }  

};  

  

//  

// this instrumentation implementation will dispatch all the data loaders  

// as each level of the graphql query is executed and hence make batched objects  

// available to the query and the associated DataFetchers  

//  

// In this case we use options to make it keep statistics on the batching efficiency  

//  

DataLoaderDispatcherInstrumentationOptions options = DataLoaderDispatcherInstrumentationOptions  

        .newOptions().includeStatistics(true);  

  

DataLoaderDispatcherInstrumentation dispatcherInstrumentation  

        = new DataLoaderDispatcherInstrumentation(options);  

  

//  

// 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();  

  

//  

// a data loader for characters that points to the character batch loader  

//  

// Since data loaders are stateful, they are created per execution request.  

//  

DataLoader<String, Object> characterDataLoader = DataLoaderFactory.newDataLoader(characterBatchLoader);  

  

//  

// 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.  

//  

// Also note that the data loaders are created per execution request  

//  

DataLoaderRegistry registry = new DataLoaderRegistry();  

registry.register("character", characterDataLoader);  

  

ExecutionInput executionInput = newExecutionInput()  

        .query(getQuery())  

        .dataLoaderRegistry(registry)  

        .build();  

  

ExecutionResult executionResult = graphQL.execute(executionInput);  

```

--------------------------------

### Install to local Maven repository with Gradle

Source: https://www.graphql-java.com/documentation/contributions

Run this command to install the project artifacts into the local Maven repository.

```bash
./gradlew install  
```

--------------------------------

### Interface Java example

Source: https://www.graphql-java.com/documentation/schema

Java equivalent of the interface SDL example, using newInterface() to define a GraphQLInterfaceType.

```java
GraphQLInterfaceType comicCharacter = newInterface()  
    .name("ComicCharacter")  
    .description("An abstract comic character.")  
    .field(newFieldDefinition()  
            .name("name")  
            .description("The name of the character.")  
            .type(GraphQLString))  
    .build();  
```

--------------------------------

### InputObject Java example

Source: https://www.graphql-java.com/documentation/schema

Java equivalent of the input object SDL example, using newInputObject() to define a GraphQLInputObjectType.

```java
GraphQLInputObjectType inputObjectType = newInputObject()  
    .name("inputObjectType")  
    .field(newInputObjectField()  
            .name("field")  
            .type(GraphQLString))  
    .build();  
```

--------------------------------

### Set up GraphQL with SubscriptionExecutionStrategy and get Publisher

Source: https://www.graphql-java.com/documentation/subscriptions

Builds a GraphQL instance with SubscriptionExecutionStrategy and executes a subscription query, retrieving the Publisher<ExecutionResult> from the ExecutionResult.

```java
GraphQL graphQL = GraphQL  

        .newGraphQL(schema)  

        .subscriptionExecutionStrategy(new SubscriptionExecutionStrategy())  

        .build();  

  

ExecutionResult executionResult = graphQL.execute(query);  

  

Publisher<ExecutionResult> stockPriceStream = executionResult.getData();  

```

--------------------------------

### Hello World example in graphql-java

Source: https://www.graphql-java.com/documentation/getting-started

A complete Java program that defines a simple GraphQL schema, wires a static data fetcher, and executes a query. Prints {hello=world}.

```java
import graphql.ExecutionResult;  

import graphql.GraphQL;  

import graphql.schema.GraphQLSchema;  

import graphql.schema.StaticDataFetcher;  

import graphql.schema.idl.RuntimeWiring;  

import graphql.schema.idl.SchemaGenerator;  

import graphql.schema.idl.SchemaParser;  

import graphql.schema.idl.TypeDefinitionRegistry;  

  

import static graphql.schema.idl.RuntimeWiring.newRuntimeWiring;  

  

public class HelloWorld {  

  

    public static void main(String[] args) {  

        String schema = "type Query{hello: String}";  

  

        SchemaParser schemaParser = new SchemaParser();  

        TypeDefinitionRegistry typeDefinitionRegistry = schemaParser.parse(schema);  

  

        RuntimeWiring runtimeWiring = newRuntimeWiring()  

                .type("Query", builder -> builder.dataFetcher("hello", new StaticDataFetcher("world")))  

                .build();  

  

        SchemaGenerator schemaGenerator = new SchemaGenerator();  

        GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);  

  

        GraphQL build = GraphQL.newGraphQL(graphQLSchema).build();  

        ExecutionResult executionResult = build.execute("{hello}");  

  

        System.out.println(executionResult.getData().toString());  

        // Prints: {hello=world}  

    }  

}  

```

--------------------------------

### Object type Java example

Source: https://www.graphql-java.com/documentation/schema

Java equivalent of the SDL object type example, using newObject() to define a GraphQLObjectType with fields and descriptions.

```java
GraphQLObjectType simpsonCharacter = newObject()  
    .name("SimpsonCharacter")  
    .description("A Simpson character")  
    .field(newFieldDefinition()  
            .name("name")  
            .description("The name of the character.")  
            .type(GraphQLString))  
    .field(newFieldDefinition()  
            .name("mainCharacter")  
            .description("One of the main Simpson characters?")  
            .type(GraphQLBoolean))  
    .build();  
```

--------------------------------

### Interface SDL example

Source: https://www.graphql-java.com/documentation/schema

SDL definition of an interface with a single field name of type String.

```graphql
interface ComicCharacter {  
  name: String  
}  
```

--------------------------------

### Configure query and mutation execution strategies

Source: https://www.graphql-java.com/documentation/execution

Wire in execution strategies when creating the GraphQL object. The example uses AsyncExecutionStrategy for queries and AsyncSerialExecutionStrategy for mutations, which is equivalent to the default settings.

```java
GraphQL.newGraphQL(schema)  

        .queryExecutionStrategy(new AsyncExecutionStrategy())  

        .mutationExecutionStrategy(new AsyncSerialExecutionStrategy())  

        .build();  
```

--------------------------------

### Example query for AsyncExecutionStrategy

Source: https://www.graphql-java.com/documentation/execution

A GraphQL query used to illustrate how AsyncExecutionStrategy dispatches fields concurrently. The enemies and friends fields can be fetched at the same time, but results are assembled in query field order.

```graphql
query {  

  hero {  

    enemies {  

      name  

    }  

    friends {  

      name  

    }  

  }  

}  
```

--------------------------------

### GraphQL query with Relay-style connection

Source: https://www.graphql-java.com/documentation/field-selection

Example query using a connection pattern with edges and node fields, demonstrating a selection set for users with pagination.

```graphql
query {  

  users(first:10)  {  

    edges {  

      node {  

        name  

        age  

        weight  

        friends {  

          name  

        }  

      }  

    }  

  }  

}  



```

--------------------------------

### Union SDL example

Source: https://www.graphql-java.com/documentation/schema

SDL definition of two object types (Cat and Dog) and a union type Pet that can be either Cat or Dog.

```graphql
type Cat {  
  name: String  
  lives: Int  
}  

  

type Dog {  
  name: String  
  bonesOwned: Int  
}  

  

union Pet = Cat | Dog  
```

--------------------------------

### GraphQL subscription example

Source: https://www.graphql-java.com/documentation/schema

Defines a GraphQL subscription named 'foo' with a placeholder for a normal GraphQL query. Subscriptions allow queries that receive updates when the backing object changes.

```graphql
subscription foo {  

  # normal graphql query  

}  

```

--------------------------------

### InputObject SDL example

Source: https://www.graphql-java.com/documentation/schema

SDL definition of an input object type with a single field name of type String.

```graphql
input Character {  
  name: String  
}  
```

--------------------------------

### Enum Java example

Source: https://www.graphql-java.com/documentation/schema

Java equivalent of the enum SDL example, using newEnum() to define a GraphQLEnumType with values RED, GREEN, and BLUE.

```java
GraphQLEnumType colorEnum = newEnum()  
        .name("Color")  
        .description("Supported colors.")  
        .value("RED")  
        .value("GREEN")  
        .value("BLUE")  
        .build();  
```

--------------------------------

### MaxQueryComplexityInstrumentation setup

Source: https://www.graphql-java.com/documentation/instrumentation

Shows how to add MaxQueryComplexityInstrumentation with a limit of 10 to a GraphQL instance. Queries exceeding the limit will be aborted.

```java
GraphQL.newGraphQL(schema)  

        .instrumentation(new MaxQueryComplexityInstrumentation(10))  

        .build();  

```

--------------------------------

### Mutation query example

Source: https://www.graphql-java.com/documentation/execution

A GraphQL mutation query that creates a review for an episode, using variables $ep and $review. It requests the stars and commentary fields of the created review.

```graphql
mutation CreateReviewForEpisode($ep: Episode!, $review: ReviewInput!) {  

  createReview(episode: $ep, review: $review) {  

    stars  

    commentary  

  }  

}  

```

--------------------------------

### Chain Instrumentation with ChainedInstrumentation

Source: https://www.graphql-java.com/documentation/instrumentation

Combines FooInstrumentation and BarInstrumentation into a single ChainedInstrumentation and installs it on a GraphQL schema. The instrumentation objects are invoked in the order they are added to the list.

```java
List<Instrumentation> chainedList = new ArrayList<>();  

chainedList.add(new FooInstrumentation());  

chainedList.add(new BarInstrumentation());  

ChainedInstrumentation chainedInstrumentation = new ChainedInstrumentation(chainedList);  

  

GraphQL.newGraphQL(schema)  

        .instrumentation(chainedInstrumentation)  

        .build();  

```

--------------------------------

### Define Star Wars schema in SDL (starWarsSchema.graphqls)

Source: https://www.graphql-java.com/documentation/schema

Static schema definition file `starWarsSchema.graphqls` that defines the query type, enum, interface, and object types for the Star Wars example. It contains only type and field definitions; runtime wiring is required to make it executable.

```graphql
schema {  

  query: QueryType  

}  

  

type QueryType {  

  hero(episode: Episode): Character  

  human(id : String) : Human  

  droid(id: ID!): Droid  

}  

  

  

enum Episode {  

  NEWHOPE  

  EMPIRE  

  JEDI  

}  

  

interface Character {  

  id: ID!  

  name: String!  

  friends: [Character]  

  appearsIn: [Episode]!  

}  

  

type Human implements Character {  

  id: ID!  

  name: String!  

  friends: [Character]  

  appearsIn: [Episode]!  

  homePlanet: String  

}  

  

type Droid implements Character {  

  id: ID!  

  name: String!  

  friends: [Character]  

  appearsIn: [Episode]!  

  primaryFunction: String  

}  


```

--------------------------------

### GraphQL query with selection set

Source: https://www.graphql-java.com/documentation/data-fetching

Example query showing the selection set of the 'products' field, including nested fields like 'sellingLocations'. This illustrates what sub-selection is available to a data fetcher for optimizing data access.

```graphql
query {  

  products {  

    # the fields below represent the selection set  

    name  

    description  

    sellingLocations {  

        state  

    }  

  }  

}  

```

--------------------------------

### Create schema programmatically with DataFetcher and code registry

Source: https://www.graphql-java.com/documentation/schema

Shows how to create a schema programmatically by defining a DataFetcher and registering it with a GraphQLCodeRegistry using coordinates. The DataFetcher's get method receives the DataFetchingEnvironment and can access the source object via environment.getSource().

```java
DataFetcher<Foo> fooDataFetcher = new DataFetcher<Foo>() {  

    @Override  

    public Foo get(DataFetchingEnvironment environment) {  

        // environment.getSource() is the value of the surrounding  

        // object. In this case described by objectType  

        Foo value = perhapsFromDatabase(); // Perhaps getting from a DB or whatever  

        return value;  

    }  

};  

  

GraphQLObjectType objectType = newObject()  

        .name("ObjectType")  

        .field(newFieldDefinition()  

                .name("foo")  

                .type(GraphQLString)  

        )  

        .build();  

  

GraphQLCodeRegistry codeRegistry = newCodeRegistry()  

        .dataFetcher(  

                coordinates("ObjectType", "foo"),  

                fooDataFetcher)  

        .build();  
```

--------------------------------

### Custom DataFetcher implementation

Source: https://www.graphql-java.com/documentation/execution

Define a custom DataFetcher to fetch top-level domain objects, e.g., from a database. The get method receives a DataFetchingEnvironment with field arguments and other context.

```java
DataFetcher userDataFetcher = new DataFetcher() {  

    @Override  

    public Object get(DataFetchingEnvironment environment) {  

        return fetchUserFromDatabase(environment.getArgument("userId"));  

    }  

};  
```

--------------------------------

### Declare and use a custom @auth directive

Source: https://www.graphql-java.com/documentation/directives

Shows the required declaration of a custom directive before use, including its arguments and location, followed by an example usage on a field definition. The declaration must appear before the directive is used in SDL.

```graphql
# This is a directive declaration  

directive @auth(role : String!) on FIELD_DEFINITION  

  

type Employee  

  id : ID  

  

  # and this is a usage of that declared directive  

  salary : Float @auth(role : "manager")  

}  
```

--------------------------------

### Build the project with Gradle

Source: https://www.graphql-java.com/documentation/contributions

Run this command to build the project. The resulting jar file will be placed in the 'build/libs' directory.

```bash
./gradlew build  
```

--------------------------------

### Run tests with Gradle

Source: https://www.graphql-java.com/documentation/contributions

Run this command to execute the project's tests.

```bash
./gradlew test  
```

--------------------------------

### Union Java example with TypeResolver

Source: https://www.graphql-java.com/documentation/schema

Java example of defining a union type with a TypeResolver that returns the appropriate GraphQLObjectType based on the runtime object type. The resolver is registered in the code registry for the union name "Pet".

```java
TypeResolver typeResolver = new TypeResolver() {  
    @Override  
    public GraphQLObjectType getType(TypeResolutionEnvironment env) {  
        if (env.getObject() instanceof Cat) {  
            return CatType;  
        }  
        if (env.getObject() instanceof Dog) {  
            return DogType;  
        }  
        return null;  
    }  
};  

GraphQLUnionType PetType = newUnionType()  
        .name("Pet")  
        .possibleType(CatType)  
        .possibleType(DogType)  
        .build();  

  

GraphQLCodeRegistry codeRegistry = newCodeRegistry()  
        .typeResolver("Pet", typeResolver)  
        .build();  
```

--------------------------------

### Enum SDL example

Source: https://www.graphql-java.com/documentation/schema

SDL definition of an enum type with three values: RED, GREEN, and BLUE.

```graphql
enum Color {  
  RED  
  GREEN  
  BLUE  
}  
```

--------------------------------

### CustomInstrumentation.instrumentExecutionResult(ExecutionResult, InstrumentationExecutionParameters, InstrumentationState)

Source: https://www.graphql-java.com/documentation/instrumentation

Allows instrumenting the execution result, for example adding extensions data.

```APIDOC
## CustomInstrumentation.instrumentExecutionResult(ExecutionResult, InstrumentationExecutionParameters, InstrumentationState)

### Description
Allows instrumenting the execution result, for example adding extensions data. Returns a CompletableFuture that completes with the instrumented result.

### Method
INSTRUMENT

### Endpoint
CustomInstrumentation.instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters, InstrumentationState state)

### Parameters
#### Parameters
- **executionResult** (ExecutionResult) - Required - The original execution result.
- **parameters** (InstrumentationExecutionParameters) - Required - Parameters for the execution.
- **state** (InstrumentationState) - Required - The state created by createState().

### Request Example
```java
@Override
public @NotNull CompletableFuture<ExecutionResult> instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters, InstrumentationState state) {
    return CompletableFuture.completedFuture(executionResult);
}
```

### Response
#### Success Response
- **CompletableFuture<ExecutionResult>** (CompletableFuture) - A future that completes with the instrumented execution result.

#### Response Example
```java
CompletableFuture<ExecutionResult> future = CompletableFuture.completedFuture(executionResult);
```
```

--------------------------------

### Set up TracingInstrumentation on GraphQL object

Source: https://www.graphql-java.com/documentation/instrumentation

Shows how to attach an Instrumentation implementation, here TracingInstrumentation, when building the GraphQL object.

```java
GraphQL.newGraphQL(schema)  

       .instrumentation(new TracingInstrumentation())  

       .build();  

```

--------------------------------

### GraphQL.newGraphQL(schema).instrumentation(new TracingInstrumentation()).build()

Source: https://www.graphql-java.com/documentation/instrumentation

Shows how to configure a custom Instrumentation when building a GraphQL instance.

```APIDOC
## GraphQL.newGraphQL(schema).instrumentation(new TracingInstrumentation()).build()

### Description
Configures the GraphQL instance to use a specified Instrumentation implementation, such as TracingInstrumentation, for observing query execution.

### Method
BUILD

### Endpoint
GraphQL.newGraphQL(schema).instrumentation(new TracingInstrumentation()).build()

### Parameters
#### Instrumentation Parameter
- **instrumentation** (Instrumentation) - Required - The Instrumentation instance to use.

### Request Example
```java
GraphQL.newGraphQL(schema)
       .instrumentation(new TracingInstrumentation())
       .build();
```

### Response
#### Success Response
- **GraphQL** (GraphQL) - The configured GraphQL instance.

#### Response Example
```java
GraphQL graphQL = GraphQL.newGraphQL(schema)
       .instrumentation(new TracingInstrumentation())
       .build();
```
```

--------------------------------

### Object type SDL example

Source: https://www.graphql-java.com/documentation/schema

SDL definition of an object type with two fields: name (String) and mainCharacter (Boolean).

```graphql
type SimpsonCharacter {  
  name: String  
  mainCharacter: Boolean  
}  
```

--------------------------------

### Build RuntimeWiring with data fetchers and type resolver

Source: https://www.graphql-java.com/documentation/schema

Builds the runtime wiring for the Star Wars schema, providing data fetchers for the query fields and friends, a type resolver for the Character interface, and a custom scalar. Shows lambda, builder, and full builder syntax options.

```java
RuntimeWiring buildRuntimeWiring() {  

    return RuntimeWiring.newRuntimeWiring()  

            .scalar(CustomScalar)  

            // this uses builder function lambda syntax  

            .type("QueryType", typeWiring -> typeWiring  

                    .dataFetcher("hero", new StaticDataFetcher(StarWarsData.getArtoo()))  

                    .dataFetcher("human", StarWarsData.getHumanDataFetcher())  

                    .dataFetcher("droid", StarWarsData.getDroidDataFetcher())  

            )  

            .type("Human", typeWiring -> typeWiring  

                    .dataFetcher("friends", StarWarsData.getFriendsDataFetcher())  

            )  

            // you can use builder syntax if you don't like the lambda syntax  

            .type("Droid", typeWiring -> typeWiring  

                    .dataFetcher("friends", StarWarsData.getFriendsDataFetcher())  

            )  

            // or full builder syntax if that takes your fancy  

            .type(  

                    newTypeWiring("Character")  

                            .typeResolver(StarWarsData.getCharacterTypeResolver())  

                            .build()  

            )  

            .build();  

}  


```

--------------------------------

### Execute query asynchronously with executeAsync()

Source: https://www.graphql-java.com/documentation/execution

Use graphQL.executeAsync(executionInput) to get a CompletableFuture<ExecutionResult>. Compose actions with thenAccept and wait with join().

```java
GraphQL graphQL = buildSchema();  

  

ExecutionInput executionInput = ExecutionInput.newExecutionInput().query("query { hero { name } }")  

        .build();  

  

CompletableFuture<ExecutionResult> promise = graphQL.executeAsync(executionInput);  

  

promise.thenAccept(executionResult -> {  

    // here you might send back the results as JSON over HTTP  

    encodeResultToJsonAndSendResponse(executionResult);  

});  

  

promise.join();  
```

--------------------------------

### BatchLoaderWithContext with overall and per-key context

Source: https://www.graphql-java.com/documentation/batching

Shows a BatchLoaderWithContext that retrieves an overall SecurityContext and a map of per-key context objects from the BatchLoaderEnvironment. It then creates a DataLoader with a BatchLoaderContextProvider that supplies the overall context, and a DataFetcher that passes the source object as per-load context.

```java
BatchLoaderWithContext<String, Object> batchLoaderWithCtx = new BatchLoaderWithContext<String, Object>() {  

    @Override  
    public CompletionStage<List<Object>> load(List<String> keys, BatchLoaderEnvironment loaderContext) {  
        //  
        // we can have an overall context object  
        SecurityContext securityCtx = loaderContext.getContext();  
        //  
        // and we can have a per key set of context objects  
        Map<Object, Object> keysToSourceObjects = loaderContext.getKeyContexts();  

        return CompletableFuture.supplyAsync(() -> getTheseCharacters(securityCtx.getToken(), keys, keysToSourceObjects));  
    }  
};  

// ....  

SecurityContext securityCtx = SecurityContext.newSecurityContext();  

BatchLoaderContextProvider contextProvider = new BatchLoaderContextProvider() {  
    @Override  
    public Object getContext() {  
        return securityCtx;  
    }  
};  
//  
// this creates an overall context for the dataloader  
//  
DataLoaderOptions loaderOptions = DataLoaderOptions.newOptions().setBatchLoaderContextProvider(contextProvider);  
DataLoader<String, Object> characterDataLoader = DataLoaderFactory.newDataLoader(batchLoaderWithCtx, loaderOptions);  

// .... later in your data fetcher  

DataFetcher<?> dataFetcherThatCallsTheDataLoader = new DataFetcher<Object>() {  
    @Override  
    public Object get(DataFetchingEnvironment environment) {  
        String argId = environment.getArgument("id");  
        Object source = environment.getSource();  
        //  
        // you can pass per load call contexts  
        //  
        return characterDataLoader.load(argId, source);  
    }  
};  

```

--------------------------------

### Example query for complexity limit

Source: https://www.graphql-java.com/documentation/instrumentation

A sample GraphQL query that would be used with the MaxQueryComplexityInstrumentation. This query has a complexity of 12, which exceeds the limit of 10.

```graphql
query {  

  hero {  

    name  

    friends {  

      name  

      homeWorld {  

        name  

        climate  

      }  

      species {  

        name  

      }  

    }  

    homeWorld {  

      name  

      climate  

    }  

  }  

}  

```

--------------------------------

### ProductDTO with DataFetchingEnvironment in getLaunchDate

Source: https://www.graphql-java.com/documentation/data-fetching

DTO class with a method that uses DataFetchingEnvironment to format launchDate based on dateFormat argument.

```java
class ProductDTO {  

  

    private ID id;  

    private String name;  

    private String description;  

    private Double cost;  

    private Double tax;  

    private LocalDateTime launchDate;  

  

    // ...  

  

    public String getName() {  

        return name;  

    }  

  

    // ...  

  

    public String getLaunchDate(DataFetchingEnvironment environment) {  

        String dateFormat = environment.getArgument("dateFormat");  

        return yodaTimeFormatter(launchDate,dateFormat);  

    }  

}  

```

--------------------------------

### Generate executable schema from SDL and wiring

Source: https://www.graphql-java.com/documentation/schema

Combines the static schema file and the runtime wiring to produce an executable GraphQLSchema. Parses the SDL file into a TypeDefinitionRegistry, then calls makeExecutableSchema with the wiring.

```java
SchemaParser schemaParser = new SchemaParser();  

SchemaGenerator schemaGenerator = new SchemaGenerator();  

  

File schemaFile = loadSchema("starWarsSchema.graphqls");  

  

TypeDefinitionRegistry typeRegistry = schemaParser.parse(schemaFile);  

RuntimeWiring wiring = buildRuntimeWiring();  

GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(typeRegistry, wiring);  


```

--------------------------------

### DataFetcher for Query.products

Source: https://www.graphql-java.com/documentation/data-mapping

A DataFetcher that retrieves product info, cost, and tax from three services and combines them into a unified view.

```java
DataFetcher productsDataFetcher = new DataFetcher() {  
    @Override  
    public Object get(DataFetchingEnvironment env) {  
        String matchArg = env.getArgument("match");  
  
        List<ProductInfo> productInfo = getMatchingProducts(matchArg);  
  
        List<ProductCostInfo> productCostInfo = getProductCosts(productInfo);  
  
        List<ProductTaxInfo> productTaxInfo = getProductTax(productInfo);  
  
        return mapDataTogether(productInfo, productCostInfo, productTaxInfo);  
    }  
};  

```

--------------------------------

### Example query exceeding depth limit

Source: https://www.graphql-java.com/documentation/instrumentation

A GraphQL query with a depth of 4 (hero, friends, friends, friends) that will be aborted because it exceeds the configured limit of 4.

```graphql
query {  

      hero {  

        name  

        friends {  

          name  

          friends {  

            name  

            friends {  

              name  

            }  

          }  

        }  

      }  

    }  
```

--------------------------------

### SchemaTransformer visitor command methods

Source: https://www.graphql-java.com/documentation/schema

Illustrates the command methods a visitor can return to instruct SchemaTransformer: changeNode, insertAfter, insertBefore, deleteNode, and CONTINUE. This code is intentionally non-compiling and serves to show the available traversal control commands.

```java
GraphQLTypeVisitorStub visitor = new GraphQLTypeVisitorStub() {  

    @Override  

    public TraversalControl visitGraphQLObjectType(GraphQLObjectType objectType, TraverserContext<GraphQLSchemaElement> context) {  

  

        // changes the current element in the schema  

        return changeNode(context, updatedElement);  

  

        // inserts a new element after the current one in the schema  

        return insertAfter(context, newElement);  

  

        // inserts a new element before the current one in teh schema  

        return insertBefore(context, newElement);  

  

        // deletes the current element from the schema  

        return deleteNode(context);  

  

        // just continue with no change  

        return CONTINUE;  

    }  

};  

```

--------------------------------

### Custom DataFetcher for Query.products

Source: https://www.graphql-java.com/documentation/data-fetching

DataFetcher implementation that fetches products from database using context and match argument.

```java
DataFetcher productsDataFetcher = new DataFetcher<List<ProductDTO>>() {  

    @Override  

    public List<ProductDTO> get(DataFetchingEnvironment environment) {  

        DatabaseSecurityCtx ctx = environment.getGraphQlContext().get("databaseSecurityCtx");  

  

        List<ProductDTO> products;  

        String match = environment.getArgument("match");  

        if (match != null) {  

            products = fetchProductsFromDatabaseWithMatching(ctx, match);  

        } else {  

            products = fetchAllProductsFromDatabase(ctx);  

        }  

        return products;  

    }  

};  

```

--------------------------------

### Serialize ExecutionResult to JSON with toSpecification

Source: https://www.graphql-java.com/documentation/execution

Call toSpecification on an ExecutionResult to get a Map that conforms to the GraphQL spec, then send it as JSON. This ensures nulls and other spec details are handled correctly.

```java
ExecutionResult executionResult = graphQL.execute(executionInput);  

  

Map<String, Object> toSpecificationResult = executionResult.toSpecification();  

  

sendAsJson(toSpecificationResult);  
```

--------------------------------

### Build and execute schema with @dateFormat directive

Source: https://www.graphql-java.com/documentation/directives

Shows how to parse the SDL, register the directive wiring, and execute a query with and without the format argument. The expected outputs are '08-10-1969' for default and '10-08-1969' for 'MM-dd-YYYY'.

```java
static GraphQLSchema buildSchema() {  

    String sdlSpec = "directive @dateFormat on FIELD_DEFINITION\n" +  
                  "type Query {\n" +  
                  "    dateField : String @dateFormat \n" +  
                  "}";  

    TypeDefinitionRegistry registry = new SchemaParser().parse(sdlSpec);  

    RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring()  
            .directive("dateFormat", new DateFormatting())  
            .build();  

    return new SchemaGenerator().makeExecutableSchema(registry, runtimeWiring);  
}  

public static void main(String[] args) {  
    GraphQLSchema schema = buildSchema();  
    GraphQL graphql = GraphQL.newGraphQL(schema).build();  

    Map<String, Object> root = new HashMap<>();  
    root.put("dateField", LocalDateTime.of(1969, 10, 8, 0, 0));  

    String query = "" +  
            "query {\n" +  
            "    default : dateField \n" +  
            "    usa : dateField(format : \"MM-dd-YYYY\") \n" +  
            "}";  

    ExecutionInput executionInput = ExecutionInput.newExecutionInput()  
            .root(root)  
            .query(query)  
            .build();  

    ExecutionResult executionResult = graphql.execute(executionInput);  
    Map<String, Object> data = executionResult.getData();  

    // data['default'] == '08-10-1969'  
    // data['usa'] == '10-08-1969'  
}  

```

--------------------------------

### Custom GraphQLError exception with extensions

Source: https://www.graphql-java.com/documentation/execution

Example of a custom exception that implements `GraphQLError` to include custom attributes (`foo` and `fizz`) in the resulting graphql error. The `getExtensions` method returns a map with these attributes.

```java
class CustomRuntimeException extends RuntimeException implements GraphQLError {  
    @Override  
    public Map<String, Object> getExtensions() {  
        Map<String, Object> customAttributes = new LinkedHashMap<>();  
        customAttributes.put("foo", "bar");  
        customAttributes.put("fizz", "whizz");  
        return customAttributes;  
    }  

  

    @Override  
    public List<SourceLocation> getLocations() {  
        return null;  
    }  

  

    @Override  
    public ErrorType getErrorType() {  
        return ErrorType.DataFetchingException;  
    }  
}  
```

--------------------------------

### Java runtime representation of complex list input

Source: https://www.graphql-java.com/documentation/data-mapping

Shows a Java example of the runtime value for the 'people' argument: a List of Maps, where each Map has 'name', 'age', and 'friends' entries, and 'friends' is a List of Maps.

```java
List.of(  

        Map.of("name", "Brad",  

                "age", 42,  

                "friends", List.of(  

                        Map.of("name", "Bill",  

                                "age", 17,  

                                "friends", List.of()  

                        )  

                )  

        ),  

        Map.of("name", "Andreas",  

                "age", 34,  

                "friends", List.of(  

                        Map.of("name", "Ted",  

                                "age", 15,  

                                "friends", List.of()  

                        )  

                )  

        )  

);  

```

--------------------------------

### Return data and errors with DataFetcherResult

Source: https://www.graphql-java.com/documentation/execution

Use DataFetcherResult to return both data and errors from a DataFetcher. The example retrieves a user from a remote GraphQL resource, maps errors to GraphQLError, and returns a DataFetcherResult with the data and error list.

```java
DataFetcher userDataFetcher = new DataFetcher() {  

    @Override  

    public Object get(DataFetchingEnvironment environment) {  

        Map response = fetchUserFromRemoteGraphQLResource(environment.getArgument("userId"));  

        List<GraphQLError> errors = response.get("errors").stream()  

            .map(MyMapGraphQLError::new)  

            .collect(Collectors.toList());  

        return new DataFetcherResult(response.get("data"), errors);  

    }  

};  
```

--------------------------------

### GraphQL query for products

Source: https://www.graphql-java.com/documentation/data-mapping

Queries the products field with a match argument and selects id, name, cost, and tax fields.

```graphql
query ProductQuery {  
  products(match : "Paper*")  
  {  
    id, name, cost, tax  
  }  
}  

```

--------------------------------

### GraphQL schema for products query

Source: https://www.graphql-java.com/documentation/data-fetching

Type declaration showing Query and Product types with fields and arguments.

```graphql
type Query {  

  products(match : String) : [Product]   # a list of products  

}  

  

type Product {  

  id : ID  

  name : String  

  description : String  

  cost : Float  

  tax : Float  

  launchDate(dateFormat : String = "dd, MMM, yyyy') : String  

}  

```
Tokens:
Raw