@GraphQLSchema
public class TodoSchema {

    @GraphQLSchemaQuery
    private RootObjectType root;

    public static class AddTodoIn {
        private String text;
    }
    
    // default value provider for an input mutation parameter 
    public AddTodoIn getAddTodoInputDefaultValue() {
        AddTodoIn addTodoInput = new AddTodoIn();
        addTodoInput.setText("--- default text ---");
        return addTodoInput;
    }

    @GraphQLMutation
    public
    @GraphQLOut("todoEdge")
    TodoObjectType.TodoEdgeObjectType addTodoMutation(@GraphQLIn("addTodoInput", defaultProvider = "getAddTodoInputDefaultValue") AddTodoIn addTodoInput) {
    
        // mutation implementaion goes here
        
        return todoEdgeObjectType;
    }

@GraphQLObject("Root")
public class RootObjectType {

    @GraphQLNonNull
    @GraphQLDescription("Root query version number")
    private String version;

    @GraphQLField
    @GraphQLDescription("Root viwer node as per Relay spec")
    public UserObjectType viewer(/** no input expected **/) {
    
        // custom data fetcher for the field with name 'viewer'
        
        return userObjectType;
    }
}

@GraphQLInterface("Node")
public interface RelayNode {

    @GraphQLID("id")
    @GraphQLNonNull
    @GraphQLDescription("GraphQL Relay global object unique identifier")
    String getId(RelayNode relayNode);
}

    // annotation is not required if enum names are acceptable as values
    @GraphQLEnum(valueProvider = "getValue")
    public enum Episode {
        @GraphQLDescription("Released in 1977.")
        NEWHOPE,
        @GraphQLDescription("Released in 1980.")
        EMPIRE,
        @GraphQLDescription("Released in 1983.")
        JEDI;

        // enum field value provider must be static method with 1 input argument - its own enumeration type
        public static Object getValue(Episode self) {
            if (self == NEWHOPE)
                return 4;
            else if (self == EMPIRE)
                return 5;
            else
                return 6;
        }
    }

    // avaliable context objects are `obj` (enum instance itself) and `cls` - enum class
    @GraphQLEnum(defaultSpel = "#obj.getActualValue()")
    public enum EpisodeV2 {
        @GraphQLDescription("Released in 1977.")
        NEWHOPE(4),
        @GraphQLDescription("Released in 1980.")
        EMPIRE(5),
        @GraphQLDescription("Released in 1983.")
        JEDI(6);

        int actualValue;

        EpisodeV2(int val) {
            actualValue = val;
        }

        public int getActualValue() {
            return actualValue;
        }
    }

    @GraphQLUnion(value = "Pet", possibleTypes = {Dog.class, Cat.class})
    public interface PetsUnionType {
       // empty marker
       // possible types must implement this interface
    }
    
    //...
    
    @GraphQLField("pets")
    public List<PetsUnionType> getPets() {
       List<PetsUnionType> pets = new ArrayList<>();
       pets.addAll(cats);
       pets.addAll(dogs);
       return pets;
    }    

    @GraphQLField
    public TodoObjectType.TodoConnectionObjectType todos(@GraphQLIn RelayConnectionArguments args) {
       
       // `args` is extracted from arguments context
       
    }

    @GraphQLField("manager")
    public UserObjectType getManager(@GraphQLIn UserObjectType employee) {
    
       // `employee` is extracted from upstream 'source' element as input parameters are empty
    
    }

    // default value provider for an input mutation parameter 
    public AddTodoIn getAddTodoInputDefaultValue() {
        AddTodoIn addTodoInput = new AddTodoIn();
        addTodoInput.setText("--- default text ---");
        return addTodoInput;
    }

    @GraphQLMutation("addTodoMutation")
    public
    @GraphQLOut("todoEdge")
    TodoObjectType.TodoEdgeObjectType addTodoMutation(@GraphQLIn("addTodoInput", defaultProvider = "getAddTodoInputDefaultValue") AddTodoIn addTodoInput, AddTodoIn2 addTodoInput2) {
    
        // `addTodoInput` created based on input `variables`
        // `addTodoInput2` is skipped as it's not marked explicitly as `@GraphQLIn` parameter
    
    }

    @GraphQLField("manager")
    public UserObjectType getManager(UserObjectType employee,
                                     @GraphQLIn(value = "ids", defaultSpel = "T(java.util.Collections).EMPTY_SET") Set<String> ids) {
        // omitted for simplicity
    }

    // there must be either `@ComponentScan` annotation defined for a schema base package 
    // or all beans must be instantiated explicitly in configuration class
    @Configuration
    @ComponentScan(basePackages = "com.oembedler.moon.graphql.test.todoschema")
    public static class TodoSchemaConfiguration {

        // use as is
        @Bean
        public GraphQLSchemaBeanFactory graphQLSchemaBeanFactory() {
            return new SpringGraphQLSchemaBeanFactory();
        }

        // configuration can be customized depending on the case
        @Bean
        public GraphQLSchemaConfig graphQLSchemaConfig() {
            GraphQLSchemaConfig graphQLSchemaConfig = new GraphQLSchemaConfig();
            return graphQLSchemaConfig;
        }

        // use as is
        @Bean
        public GraphQLSchemaBuilder graphQLSchemaBuilder() {
            return new GraphQLSchemaBuilder(graphQLSchemaConfig(), graphQLSchemaBeanFactory());
        }

        // use as is
        @Bean
        public GraphQLSchemaHolder graphQLSchemaHolder() {
            return graphQLSchemaBuilder().buildSchema(TodoSchema.class);
        }
    }

        RxExecutionResult result = GraphQLQueryExecutor
                                             .create(graphQLSchemaHolder)
                                             .query("{viewer{ id }}")
                                             .execute();
        // work with execution result

        GraphQLRxExecutionResult result =
                GraphQLQueryExecutor.builder()
                        .create(graphQLSchemaHolder)
                        .forkJoinExecutorService()
                        .query("{viewer{ id }}")
                        .execute();

    private String clientMutationIdName = "clientMutationId";
    private boolean injectClientMutationId = true;
    private boolean allowEmptyClientMutationId = false;
    private String mutationInputArgumentName = "input";
    private String outputObjectNamePrefix = "Payload";
    private String inputObjectNamePrefix = "Input";
    private String schemaMutationObjectName = "Mutation";
    private boolean dateAsTimestamp = true;
    private String dateFormat = "yyyy-MM-dd'T'HH:mm'Z'";

    // there will be more config options added in the future

    public Integer getFirstDefaultValue() {
        return 1;
    }

    public Integer getLastDefaultValue() {
        return 1;
    }

    // `before`, `after`, `first`, `last` and `childScore` are avaliable in SpEL expression
    @GraphQLField
    @GraphQLComplexity("1 + first * #childScore")
    public TodoConnectionObjectType todos(@GraphQLIn(value = "before") String before,
                                          @GraphQLIn(value = "after") String after,
                                          @GraphQLIn(value = "first", defaultProvider = "getFirstDefaultValue") Integer first,
                                          @GraphQLIn(value = "last", defaultProvider = "getLastDefaultValue") Integer last) {

        // implementation ommitted for the sake of simplicity        

        return todoConnectionObjectType;
    }

   GraphQLQueryExecutor.create(graphQLSchemaHolder).maxQueryComplexity(1500);

GraphQLQueryExecutor.create(graphQLSchemaHolder).maxQueryDepth(4);

@GraphQLObject("Todo")
public class TodoObjectType extends BaseObjectType {

    // fields definitions are omitted for clarity 

    @GraphQLObject
    public static class TodoEdgeObjectType extends EdgeObjectType<TodoObjectType> {
    
      // `EdgeObjectType` is generic class that can be extended to add custom behaviour
      
    }

    @GraphQLObject
    public static class TodoConnectionObjectType extends ConnectionObjectType<TodoEdgeObjectType, PageInfoObjectType> {
    
    // `ConnectionObjectType` is generic class that can be extended to add custom behaviour
    
    }
}

// defined in library `relay` package
@GraphQLInterface("Node")
public interface RelayNode {

    @GraphQLID("id")
    @GraphQLNonNull
    @GraphQLDescription("GraphQL Relay global object unique identifier")
    String getId(RelayNode relayNode);
}

public class BaseObjectType implements RelayNode {

    @GraphQLIgnore
    private String id;

    @GraphQLID("id")
    @GraphQLNonNull
    @GraphQLDescription("Global object unique identifier")
    public String getId(RelayNode relayNode) {
        BaseObjectType baseObjectType = (BaseObjectType) relayNode;
        
        // `id` can be encoded into base64 if opaque value is required
        
        return baseObjectType.id;
    }
}

@GraphQLObject("Root")
public class RootObjectType {

    @GraphQLField
    public RelayNode node(@GraphQLID @GraphQLNonNull @GraphQLIn("id") final String id) {
    
        // data resolver by global ID goes here
        
        return null;
    }
    
}

    @GraphQLField
    public TodoConnectionObjectType todos(@GraphQLIn(value = "before") String before,
                                          @GraphQLIn(value = "after") String after,
                                          @GraphQLIn(value = "first") Integer first,
                                          @GraphQLIn(value = "last") Integer last) {}

    public class RelayConnectionArguments {
        public String before;
        public String after;
        public Integer first;
        public Integer last;
        // ...
    }

    @GraphQLField
    public TodoConnectionObjectType todos(@GraphQLIn("connArgs") RelayConnectionArguments) {
         // when query for a data arguments must be passed as embedded input argument `connArgs` 
         // { ... todos(connArgs{first: 10}){...} ... }
    }