GraphQLSchemaGenerator (GraphQL SPQR 0.9.9 API)

java.lang.Object
- io.leangen.graphql.GraphQLSchemaGenerator

```
public class GraphQLSchemaGenerator
extends Object
```
This class is the main entry point to the library. It is used to generate a GraphQL schema by analyzing the registered classes and exposing the chosen methods as GraphQL queries or mutations. The process of choosing the methods to expose is delegated to ResolverBuilder instances, and a different set of builders can be attached to each registered class. One such coupling of a registered class and a set of builders is modeled by an instance of OperationSource. Methods of the with*OperationSource family are used to register sources to be analyzed.

Builders can also be registered globally (to be used when none are provided explicitly) via withResolverBuilders(ResolverBuilder...). The process of mapping the Java methods to GraphQL queries/mutations will also transparently map all encountered Java types to corresponding GraphQL types. The entire mapping process is handled by an instance OperationMapper where actual type mapping is delegated to different instances of TypeMapper.

To customize the mapping process, clients can registers their own TypeMappers using withTypeMappers(TypeMapper...). Runtime conversion between values provided by the GraphQL client and those expected by Java code might be needed. This is handled by InputConverter instances.

Similarly, the conversion between values returned by Java code and those expected by the GraphQL client (if needed) is handled by OutputConverter instances. Custom implementations of both InputConverter and OutputConverter can be provided using withInputConverters(InputConverter[]) and withOutputConverters(OutputConverter[]) respectively.

Example:
```
 
 UserService userService = new UserService(); //could also be injected by a framework
 GraphQLSchema schema = new GraphQLSchemaGenerator()
      .withOperationsFromSingletons(userService) //register an operations source and use the default strategy
      .withNestedResolverBuildersForType(User.class, new BeanResolverBuilder()) //customize how queries are extracted from User.class
      .generate();
 GraphQL graphQL = new GraphQL(schema);

 //keep the reference to GraphQL instance and execute queries against it.
 //this query selects a user by ID and requests name and regDate fields only
 ExecutionResult result = graphQL.execute(
 "{ user (id: 123) {
      name,
      regDate
  }}");
  
 
```

Constructor Summary

Constructors
Constructor and Description
`GraphQLSchemaGenerator()` Default constructor
`GraphQLSchemaGenerator(String queryRoot, String mutationRoot, String subscriptionRoot)` Constructor which allows to customize names of root types.
`GraphQLSchemaGenerator(String queryRoot, String queryRootDescription, String mutationRoot, String mutationRootDescription, String subscriptionRoot, String subscriptionRootDescription)` Constructor which allows to customize names of root types.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`graphql.schema.GraphQLSchema`	`generate()` Generates a GraphQL schema based on the results of analysis of the registered sources.
`GraphQLSchemaGenerator`	`withAbstractInputHandler(AbstractInputHandler abstractInputHandler)`
`GraphQLSchemaGenerator`	`withAbstractInputTypeResolution()`
`GraphQLSchemaGenerator`	`withAdditionalDirectives(AnnotatedType... additionalDirectives)`
`GraphQLSchemaGenerator`	`withAdditionalDirectives(graphql.schema.GraphQLDirective... additionalDirectives)`
`GraphQLSchemaGenerator`	`withAdditionalDirectives(Type... additionalDirectives)`
`GraphQLSchemaGenerator`	`withAdditionalTypes(Collection<graphql.schema.GraphQLType> additionalTypes)`
`GraphQLSchemaGenerator`	`withArgumentInjectors(ArgumentInjector... argumentInjectors)`
`GraphQLSchemaGenerator`	`withArgumentInjectors(ExtensionProvider<GeneratorConfiguration,ArgumentInjector> provider)`
`GraphQLSchemaGenerator`	`withBasePackages(String... basePackages)`
`GraphQLSchemaGenerator`	`withDirectiveBuilder(DirectiveBuilder directiveBuilder)`
`GraphQLSchemaGenerator`	`withImplementationDiscoveryStrategy(ImplementationDiscoveryStrategy implDiscoveryStrategy)`
`GraphQLSchemaGenerator`	`withInclusionStrategy(InclusionStrategy inclusionStrategy)`
`GraphQLSchemaGenerator`	`withInputConverters(ExtensionProvider<GeneratorConfiguration,InputConverter> provider)`
`GraphQLSchemaGenerator`	`withInputConverters(InputConverter<?,?>... inputConverters)` Registers custom `InputConverter`s to be used for converting values provided by the GraphQL client into those expected by the corresponding Java method.
`GraphQLSchemaGenerator`	`withInputConvertersPrepended(InputConverter<?,?>... inputConverters)`
`GraphQLSchemaGenerator`	`withInputFieldBuilders(ExtensionProvider<ExtendedGeneratorConfiguration,InputFieldBuilder> provider)`
`GraphQLSchemaGenerator`	`withInputFieldBuilders(InputFieldBuilder... inputFieldBuilders)`
`GraphQLSchemaGenerator`	`withInterfaceMappingStrategy(InterfaceMappingStrategy interfaceStrategy)`
`GraphQLSchemaGenerator`	`withJavaDeprecationReason(String deprecationReason)`
`GraphQLSchemaGenerator`	`withJavaDeprecationRespected(boolean respectJavaDeprecation)`
`GraphQLSchemaGenerator`	`withModules(ExtensionProvider<GeneratorConfiguration,Module> provider)`
`GraphQLSchemaGenerator`	`withModules(Module... modules)`
`GraphQLSchemaGenerator`	`withNestedOperationsFromTypes(AnnotatedType... types)` The same as `withNestedOperationsFromTypes(Type...)` except that an `AnnotatedType` is used, so any extra annotations on the type (not only those directly on the class) are kept.
`GraphQLSchemaGenerator`	`withNestedOperationsFromTypes(Type... types)` Register a type to be scanned for exposed methods, using the globally registered builders.
`GraphQLSchemaGenerator`	`withNestedResolverBuilders(ExtensionProvider<GeneratorConfiguration,ResolverBuilder> provider)`
`GraphQLSchemaGenerator`	`withNestedResolverBuilders(ResolverBuilder... resolverBuilders)` Globally registers `ResolverBuilder`s to be used for sources that don't have explicitly assigned builders.
`GraphQLSchemaGenerator`	`withNestedResolverBuildersForType(AnnotatedType querySourceType, ResolverBuilder... resolverBuilders)` Same as `withNestedResolverBuildersForType(Type, ResolverBuilder...)` except that an `AnnotatedType` is used so any extra annotations on the type (not only those directly on the class) are kept.
`GraphQLSchemaGenerator`	`withNestedResolverBuildersForType(Type querySourceType, ResolverBuilder... resolverBuilders)` Register `querySourceType` type to be scanned for exposed methods, using the provided `ResolverBuilder`s.
`GraphQLSchemaGenerator`	`withOperationBuilder(OperationBuilder operationBuilder)`
`GraphQLSchemaGenerator`	`withOperationsFromSingleton(Object serviceSingleton)` Register `serviceSingleton` as a singleton `OperationSource`, with its class (obtained via `Object.getClass()`) as its runtime type and with the globally registered `ResolverBuilder`s.
`GraphQLSchemaGenerator`	`withOperationsFromSingleton(Object serviceSingleton, AnnotatedType beanType)` Same as `withOperationsFromSingleton(Object, Type)`, except that an `AnnotatedType` is used as `serviceSingleton`'s runtime type.
`GraphQLSchemaGenerator`	`withOperationsFromSingleton(Object serviceSingleton, AnnotatedType beanType, ResolverBuilder... builders)` Same as `withOperationsFromSingleton(Object, AnnotatedType)` except that custom `ResolverBuilder`s will be used to look through `beanType` for methods to be exposed.
`GraphQLSchemaGenerator`	`withOperationsFromSingleton(Object serviceSingleton, ResolverBuilder... builders)` Same as `withOperationsFromSingleton(Object)` except that custom `ResolverBuilder`s will be used to look through `beanType` for methods to be exposed.
`GraphQLSchemaGenerator`	`withOperationsFromSingleton(Object serviceSingleton, Type beanType)` Register `serviceSingleton` as a singleton `OperationSource`, with `beanType` as its runtime type and with the globally registered `ResolverBuilder`s.
`GraphQLSchemaGenerator`	`withOperationsFromSingleton(Object serviceSingleton, Type beanType, ResolverBuilder... builders)` Same as `withOperationsFromSingleton(Object, Type)` except that custom `ResolverBuilder`s will be used to look through `beanType` for methods to be exposed.
`GraphQLSchemaGenerator`	`withOperationsFromSingletons(Object... serviceSingletons)` Same as `withOperationsFromSingleton(Object)` except that multiple beans can be registered at the same time.
`GraphQLSchemaGenerator`	`withOperationsFromType(AnnotatedType serviceType)`
`GraphQLSchemaGenerator`	`withOperationsFromType(AnnotatedType serviceType, ResolverBuilder... builders)`
`GraphQLSchemaGenerator`	`withOperationsFromType(Type serviceType)`
`GraphQLSchemaGenerator`	`withOperationsFromType(Type serviceType, ResolverBuilder... builders)`
`GraphQLSchemaGenerator`	`withOperationsFromTypes(AnnotatedType... serviceType)`
`GraphQLSchemaGenerator`	`withOperationsFromTypes(Type... serviceType)`
`GraphQLSchemaGenerator`	`withOutputConverters(ExtensionProvider<GeneratorConfiguration,OutputConverter> provider)`
`GraphQLSchemaGenerator`	`withOutputConverters(OutputConverter<?,?>... outputConverters)` Registers custom `OutputConverter`s to be used for converting values returned by the exposed Java method into those expected by the GraphQL client.
`GraphQLSchemaGenerator`	`withOutputConvertersPrepended(OutputConverter<?,?>... outputConverters)`
`GraphQLSchemaGenerator`	`withRelayCompliantMutations()` Sets a flag that all mutations should be mapped in a Relay-compliant way, using the default name and description for output wrapper fields.
`GraphQLSchemaGenerator`	`withRelayCompliantMutations(String wrapperFieldName, String wrapperFieldDescription)` Sets a flag signifying that all mutations should be mapped in a Relay-compliant way, using the default name and description for output wrapper fields.
`GraphQLSchemaGenerator`	`withRelayConnectionCheckRelaxed()` Removes the requirement on queries returning a Connection to comply with the Relay Connection spec
`GraphQLSchemaGenerator`	`withRelayNodeInterfaceInference(boolean enabled)` Sets the flag controlling whether the Node interface (as defined by the Relay spec) should be automatically inferred for types that have an ID field.
`GraphQLSchemaGenerator`	`withResolverBuilders(ExtensionProvider<GeneratorConfiguration,ResolverBuilder> provider)`
`GraphQLSchemaGenerator`	`withResolverBuilders(ResolverBuilder... resolverBuilders)` Globally registers `ResolverBuilder`s to be used for sources that don't have explicitly assigned builders.
`GraphQLSchemaGenerator`	`withResolverInterceptorFactories(ExtensionProvider<GeneratorConfiguration,ResolverInterceptorFactory> provider)`
`GraphQLSchemaGenerator`	`withResolverInterceptors(ResolverInterceptor... interceptors)`
`GraphQLSchemaGenerator`	`withScalarDeserializationStrategy(ScalarDeserializationStrategy scalarStrategy)`
`GraphQLSchemaGenerator`	`withSchemaProcessors(GraphQLSchemaProcessor... processors)` Registers custom schema processors that can perform arbitrary transformations on the schema just before it is built.
`GraphQLSchemaGenerator`	`withSchemaTransformers(ExtensionProvider<GeneratorConfiguration,SchemaTransformer> provider)`
`GraphQLSchemaGenerator`	`withSchemaTransformers(SchemaTransformer... transformers)`
`GraphQLSchemaGenerator`	`withStringInterpolation(MessageBundle... messageBundles)`
`GraphQLSchemaGenerator`	`withTypeAdapters(AbstractTypeAdapter<?,?>... typeAdapters)` Type adapters (instances of `AbstractTypeAdapter`) are both type mappers and bi-directional converters, implementing `TypeMapper`, `InputConverter` and `OutputConverter`.
`GraphQLSchemaGenerator`	`withTypeComparator(Comparator<AnnotatedType> comparator)`
`GraphQLSchemaGenerator`	`withTypeInfoGenerator(TypeInfoGenerator typeInfoGenerator)`
`GraphQLSchemaGenerator`	`withTypeMappers(ExtensionProvider<GeneratorConfiguration,TypeMapper> provider)` Registers custom `TypeMapper`s to be used for mapping Java type to GraphQL types.
`GraphQLSchemaGenerator`	`withTypeMappers(TypeMapper... typeMappers)` Registers custom `TypeMapper`s to be used for mapping Java type to GraphQL types.
`GraphQLSchemaGenerator`	`withTypeMappersPrepended(TypeMapper... typeMappers)`
`GraphQLSchemaGenerator`	`withTypeSynonymGroup(AnnotatedType... synonyms)`
`GraphQLSchemaGenerator`	`withTypeSynonymGroup(Type... synonyms)`
`GraphQLSchemaGenerator`	`withTypeTransformer(TypeTransformer transformer)`
`GraphQLSchemaGenerator`	`withValueMapperFactory(ValueMapperFactory valueMapperFactory)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - GraphQLSchemaGenerator
```
public GraphQLSchemaGenerator()
```
    Default constructor
  - GraphQLSchemaGenerator
```
public GraphQLSchemaGenerator(String queryRoot,
                              String mutationRoot,
                              String subscriptionRoot)
```
    Constructor which allows to customize names of root types.
    
    Parameters:
    
    queryRoot - name of query root type
    
    mutationRoot - name of mutation root type
    
    subscriptionRoot - name of subscription root type
  - GraphQLSchemaGenerator
```
public GraphQLSchemaGenerator(String queryRoot,
                              String queryRootDescription,
                              String mutationRoot,
                              String mutationRootDescription,
                              String subscriptionRoot,
                              String subscriptionRootDescription)
```
    Constructor which allows to customize names of root types.
    
    Parameters:
    
    queryRoot - name of query root type
    
    mutationRoot - name of mutation root type
    
    subscriptionRoot - name of subscription root type
- Method Detail
  - withOperationsFromSingleton
```
public GraphQLSchemaGenerator withOperationsFromSingleton(Object serviceSingleton)
```
    Register serviceSingleton as a singleton OperationSource, with its class (obtained via Object.getClass()) as its runtime type and with the globally registered ResolverBuilders. All query/mutation methods discovered by analyzing the serviceSingleton's type will be later, in query resolution time, invoked on this specific instance (hence the 'singleton' in the method name). Instances of stateless service classes are commonly registered this way.
    
    Parameters:
    
    serviceSingleton - The singleton bean whose type is to be scanned for query/mutation methods and on which those methods will be invoked in query/mutation execution time
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withOperationsFromSingleton
```
public GraphQLSchemaGenerator withOperationsFromSingleton(Object serviceSingleton,
                                                          Type beanType)
```
    Register serviceSingleton as a singleton OperationSource, with beanType as its runtime type and with the globally registered ResolverBuilders.
    See withOperationsFromSingleton(Object)
    
    Parameters:
    
    serviceSingleton - The singleton bean whose type is to be scanned for query/mutation methods and on which those methods will be invoked in query/mutation execution time
    
    beanType - Runtime type of serviceSingleton. Should be explicitly provided when it differs from its class (that can be obtained via Object.getClass()). This is commonly the case when the class is generic or when the instance has been proxied by a framework. Use TypeToken to get a Type literal or TypeFactory to create it dynamically.
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withOperationsFromSingleton
```
public GraphQLSchemaGenerator withOperationsFromSingleton(Object serviceSingleton,
                                                          AnnotatedType beanType)
```
    Same as withOperationsFromSingleton(Object, Type), except that an AnnotatedType is used as serviceSingleton's runtime type. Needed when type annotations such as GraphQLNonNull not directly declared on the class should be captured.
    
    Parameters:
    
    serviceSingleton - The singleton bean whose type is to be scanned for query/mutation methods and on which those methods will be invoked in query/mutation execution time
    
    beanType - Runtime type of serviceSingleton. Should be explicitly provided when it differs from its class (that can be obtained via Object.getClass()) and when annotations on the type should be kept. Use TypeToken to get an AnnotatedType literal or TypeFactory to create it dynamically.
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withOperationsFromSingleton
```
public GraphQLSchemaGenerator withOperationsFromSingleton(Object serviceSingleton,
                                                          ResolverBuilder... builders)
```
    Same as withOperationsFromSingleton(Object) except that custom ResolverBuilders will be used to look through beanType for methods to be exposed.
    
    Parameters:
    
    serviceSingleton - The singleton bean whose type is to be scanned for query/mutation methods and on which those methods will be invoked in query/mutation execution time
    
    builders - Custom strategy to use when analyzing beanType
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withOperationsFromSingleton
```
public GraphQLSchemaGenerator withOperationsFromSingleton(Object serviceSingleton,
                                                          Type beanType,
                                                          ResolverBuilder... builders)
```
    Same as withOperationsFromSingleton(Object, Type) except that custom ResolverBuilders will be used to look through beanType for methods to be exposed.
    
    Parameters:
    
    serviceSingleton - The singleton bean whose type is to be scanned for query/mutation methods and on which those methods will be invoked in query/mutation execution time
    
    beanType - Runtime type of serviceSingleton. Should be explicitly provided when it differs from its class (that can be obtained via Object.getClass()). This is commonly the case when the class is generic or when the instance has been proxied by a framework. Use TypeToken to get a Type literal or TypeFactory to create it dynamically.
    
    builders - Custom strategy to use when analyzing beanType
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withOperationsFromSingleton
```
public GraphQLSchemaGenerator withOperationsFromSingleton(Object serviceSingleton,
                                                          AnnotatedType beanType,
                                                          ResolverBuilder... builders)
```
    Same as withOperationsFromSingleton(Object, AnnotatedType) except that custom ResolverBuilders will be used to look through beanType for methods to be exposed.
    
    Parameters:
    
    serviceSingleton - The singleton bean whose type is to be scanned for query/mutation methods and on which those methods will be invoked in query/mutation execution time
    
    beanType - Runtime type of serviceSingleton. Should be explicitly provided when it differs from its class (that can be obtained via Object.getClass()) and when annotations on the type should be kept. Use TypeToken to get an AnnotatedType literal or TypeFactory to create it dynamically.
    
    builders - Custom builders to use when analyzing beanType
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withOperationsFromSingletons
```
public GraphQLSchemaGenerator withOperationsFromSingletons(Object... serviceSingletons)
```
    Same as withOperationsFromSingleton(Object) except that multiple beans can be registered at the same time.
    
    Parameters:
    
    serviceSingletons - Singleton beans whose type is to be scanned for query/mutation methods and on which those methods will be invoked in query/mutation execution time
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withOperationsFromType
```
public GraphQLSchemaGenerator withOperationsFromType(Type serviceType)
```
  - withOperationsFromType
```
public GraphQLSchemaGenerator withOperationsFromType(Type serviceType,
                                                     ResolverBuilder... builders)
```
  - withOperationsFromTypes
```
public GraphQLSchemaGenerator withOperationsFromTypes(Type... serviceType)
```
  - withOperationsFromType
```
public GraphQLSchemaGenerator withOperationsFromType(AnnotatedType serviceType)
```
  - withOperationsFromType
```
public GraphQLSchemaGenerator withOperationsFromType(AnnotatedType serviceType,
                                                     ResolverBuilder... builders)
```
  - withOperationsFromTypes
```
public GraphQLSchemaGenerator withOperationsFromTypes(AnnotatedType... serviceType)
```
  - withNestedOperationsFromTypes
```
public GraphQLSchemaGenerator withNestedOperationsFromTypes(Type... types)
```
    Register a type to be scanned for exposed methods, using the globally registered builders. This is not normally required as domain types will be discovered dynamically and globally registered builders will be used anyway. Only needed when no exposed method refers to this domain type directly (relying exclusively on interfaces or super-types instead) and the type should still be mapped and listed in the resulting schema.
    
    Parameters:
    
    types - The domain types that are to be scanned for query/mutation methods
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withNestedOperationsFromTypes
```
public GraphQLSchemaGenerator withNestedOperationsFromTypes(AnnotatedType... types)
```
    The same as withNestedOperationsFromTypes(Type...) except that an AnnotatedType is used, so any extra annotations on the type (not only those directly on the class) are kept.
    
    Parameters:
    
    types - The domain types that are to be scanned for query/mutation methods
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withNestedResolverBuildersForType
```
public GraphQLSchemaGenerator withNestedResolverBuildersForType(Type querySourceType,
                                                                ResolverBuilder... resolverBuilders)
```
    Register querySourceType type to be scanned for exposed methods, using the provided ResolverBuilders. Domain types are discovered dynamically, when referred to by an exposed method (either as its parameter type or return type). This method gives a way to customize how the discovered domain type will be analyzed.
    
    Parameters:
    
    querySourceType - The domain type that is to be scanned for query/mutation methods
    
    resolverBuilders - Custom resolverBuilders to use when analyzing querySourceType type
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withNestedResolverBuildersForType
```
public GraphQLSchemaGenerator withNestedResolverBuildersForType(AnnotatedType querySourceType,
                                                                ResolverBuilder... resolverBuilders)
```
    Same as withNestedResolverBuildersForType(Type, ResolverBuilder...) except that an AnnotatedType is used so any extra annotations on the type (not only those directly on the class) are kept.
    
    Parameters:
    
    querySourceType - The annotated domain type that is to be scanned for query/mutation methods
    
    resolverBuilders - Custom resolverBuilders to use when analyzing querySourceType type
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withResolverBuilders
```
public GraphQLSchemaGenerator withResolverBuilders(ResolverBuilder... resolverBuilders)
```
    Globally registers ResolverBuilders to be used for sources that don't have explicitly assigned builders.
    
    Parameters:
    
    resolverBuilders - builders to be globally registered
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withResolverBuilders
```
public GraphQLSchemaGenerator withResolverBuilders(ExtensionProvider<GeneratorConfiguration,ResolverBuilder> provider)
```
  - withNestedResolverBuilders
```
public GraphQLSchemaGenerator withNestedResolverBuilders(ResolverBuilder... resolverBuilders)
```
    Globally registers ResolverBuilders to be used for sources that don't have explicitly assigned builders.
    
    Parameters:
    
    resolverBuilders - builders to be globally registered
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withNestedResolverBuilders
```
public GraphQLSchemaGenerator withNestedResolverBuilders(ExtensionProvider<GeneratorConfiguration,ResolverBuilder> provider)
```
  - withInputFieldBuilders
```
public GraphQLSchemaGenerator withInputFieldBuilders(InputFieldBuilder... inputFieldBuilders)
```
  - withInputFieldBuilders
```
public GraphQLSchemaGenerator withInputFieldBuilders(ExtensionProvider<ExtendedGeneratorConfiguration,InputFieldBuilder> provider)
```
  - withAbstractInputTypeResolution
```
public GraphQLSchemaGenerator withAbstractInputTypeResolution()
```
  - withAbstractInputHandler
```
public GraphQLSchemaGenerator withAbstractInputHandler(AbstractInputHandler abstractInputHandler)
```
  - withBasePackages
```
public GraphQLSchemaGenerator withBasePackages(String... basePackages)
```
  - withStringInterpolation
```
public GraphQLSchemaGenerator withStringInterpolation(MessageBundle... messageBundles)
```
  - withJavaDeprecationRespected
```
public GraphQLSchemaGenerator withJavaDeprecationRespected(boolean respectJavaDeprecation)
```
  - withJavaDeprecationReason
```
public GraphQLSchemaGenerator withJavaDeprecationReason(String deprecationReason)
```
  - withTypeInfoGenerator
```
public GraphQLSchemaGenerator withTypeInfoGenerator(TypeInfoGenerator typeInfoGenerator)
```
  - withValueMapperFactory
```
public GraphQLSchemaGenerator withValueMapperFactory(ValueMapperFactory valueMapperFactory)
```
  - withInterfaceMappingStrategy
```
public GraphQLSchemaGenerator withInterfaceMappingStrategy(InterfaceMappingStrategy interfaceStrategy)
```
  - withScalarDeserializationStrategy
```
public GraphQLSchemaGenerator withScalarDeserializationStrategy(ScalarDeserializationStrategy scalarStrategy)
```
  - withInclusionStrategy
```
public GraphQLSchemaGenerator withInclusionStrategy(InclusionStrategy inclusionStrategy)
```
  - withImplementationDiscoveryStrategy
```
public GraphQLSchemaGenerator withImplementationDiscoveryStrategy(ImplementationDiscoveryStrategy implDiscoveryStrategy)
```
  - withTypeTransformer
```
public GraphQLSchemaGenerator withTypeTransformer(TypeTransformer transformer)
```
  - withTypeMappers
```
public GraphQLSchemaGenerator withTypeMappers(TypeMapper... typeMappers)
```
    Registers custom TypeMappers to be used for mapping Java type to GraphQL types.
    Ordering of mappers is strictly important as the first TypeMapper that supports the given Java type will be used for mapping it.
    
    See TypeMapper.supports(AnnotatedType)
    
    Parameters:
    
    typeMappers - Custom type mappers to register with the builder
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withTypeMappersPrepended
```
public GraphQLSchemaGenerator withTypeMappersPrepended(TypeMapper... typeMappers)
```
  - withTypeMappers
```
public GraphQLSchemaGenerator withTypeMappers(ExtensionProvider<GeneratorConfiguration,TypeMapper> provider)
```
    Registers custom TypeMappers to be used for mapping Java type to GraphQL types.
    Ordering of mappers is strictly important as the first TypeMapper that supports the given Java type will be used for mapping it.
    
    See TypeMapper.supports(AnnotatedType)
    
    Parameters:
    
    provider - Provides the customized list of TypeMappers to use
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withSchemaTransformers
```
public GraphQLSchemaGenerator withSchemaTransformers(SchemaTransformer... transformers)
```
  - withSchemaTransformers
```
public GraphQLSchemaGenerator withSchemaTransformers(ExtensionProvider<GeneratorConfiguration,SchemaTransformer> provider)
```
  - withInputConverters
```
public GraphQLSchemaGenerator withInputConverters(InputConverter<?,?>... inputConverters)
```
    Registers custom InputConverters to be used for converting values provided by the GraphQL client into those expected by the corresponding Java method. Only needed in some specific cases when usual deserialization isn't enough, for example, when a client-provided List should be repackaged into a Map, which is normally done because GraphQL type system has no direct support for maps.
    Ordering of converters is strictly important as the first InputConverter that supports the given Java type will be used for converting it.
    
    See InputConverter.supports(AnnotatedType)
    
    Parameters:
    
    inputConverters - Custom input converters to register with the builder
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withInputConvertersPrepended
```
public GraphQLSchemaGenerator withInputConvertersPrepended(InputConverter<?,?>... inputConverters)
```
  - withInputConverters
```
public GraphQLSchemaGenerator withInputConverters(ExtensionProvider<GeneratorConfiguration,InputConverter> provider)
```
  - withOutputConverters
```
public GraphQLSchemaGenerator withOutputConverters(OutputConverter<?,?>... outputConverters)
```
    Registers custom OutputConverters to be used for converting values returned by the exposed Java method into those expected by the GraphQL client. Only needed in some specific cases when usual serialization isn't enough, for example, when an instance of Map should be repackaged into a List, which is normally done because GraphQL type system has no direct support for maps.
    Ordering of converters is strictly important as the first OutputConverter that supports the given Java type will be used for converting it.
    
    See OutputConverter.supports(AnnotatedType)
    
    Parameters:
    
    outputConverters - Custom output converters to register with the builder
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withOutputConvertersPrepended
```
public GraphQLSchemaGenerator withOutputConvertersPrepended(OutputConverter<?,?>... outputConverters)
```
  - withOutputConverters
```
public GraphQLSchemaGenerator withOutputConverters(ExtensionProvider<GeneratorConfiguration,OutputConverter> provider)
```
  - withTypeAdapters
```
public GraphQLSchemaGenerator withTypeAdapters(AbstractTypeAdapter<?,?>... typeAdapters)
```
    Type adapters (instances of AbstractTypeAdapter) are both type mappers and bi-directional converters, implementing TypeMapper, InputConverter and OutputConverter. They're used in the same way as mappers/converters individually, and exist solely because it can sometimes be convenient to group the logic for mapping and converting to/from the same Java type in one place. For example, because GraphQL type system has no notion of maps, Maps require special logic both when mapping them to a GraphQL type and when converting them before and after invoking a Java method. For this reason, all code dealing with translating Maps is kept in one place in MapToListTypeAdapter.
    Ordering of mappers/converters is strictly important as the first one supporting the given Java type will be used to map/convert it.
    
    See withTypeMappers(ExtensionProvider)
    
    See withInputConverters(ExtensionProvider)
    
    See withOutputConverters(ExtensionProvider)
    
    Parameters:
    
    typeAdapters - Custom type adapters to register with the builder
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withArgumentInjectors
```
public GraphQLSchemaGenerator withArgumentInjectors(ArgumentInjector... argumentInjectors)
```
  - withArgumentInjectors
```
public GraphQLSchemaGenerator withArgumentInjectors(ExtensionProvider<GeneratorConfiguration,ArgumentInjector> provider)
```
  - withModules
```
public GraphQLSchemaGenerator withModules(Module... modules)
```
  - withModules
```
public GraphQLSchemaGenerator withModules(ExtensionProvider<GeneratorConfiguration,Module> provider)
```
  - withResolverInterceptors
```
public GraphQLSchemaGenerator withResolverInterceptors(ResolverInterceptor... interceptors)
```
  - withResolverInterceptorFactories
```
public GraphQLSchemaGenerator withResolverInterceptorFactories(ExtensionProvider<GeneratorConfiguration,ResolverInterceptorFactory> provider)
```
  - withAdditionalTypes
```
public GraphQLSchemaGenerator withAdditionalTypes(Collection<graphql.schema.GraphQLType> additionalTypes)
```
  - withAdditionalDirectives
```
public GraphQLSchemaGenerator withAdditionalDirectives(Type... additionalDirectives)
```
  - withAdditionalDirectives
```
public GraphQLSchemaGenerator withAdditionalDirectives(AnnotatedType... additionalDirectives)
```
  - withAdditionalDirectives
```
public GraphQLSchemaGenerator withAdditionalDirectives(graphql.schema.GraphQLDirective... additionalDirectives)
```
  - withTypeSynonymGroup
```
public GraphQLSchemaGenerator withTypeSynonymGroup(Type... synonyms)
```
  - withTypeSynonymGroup
```
public GraphQLSchemaGenerator withTypeSynonymGroup(AnnotatedType... synonyms)
```
  - withTypeComparator
```
public GraphQLSchemaGenerator withTypeComparator(Comparator<AnnotatedType> comparator)
```
  - withOperationBuilder
```
public GraphQLSchemaGenerator withOperationBuilder(OperationBuilder operationBuilder)
```
  - withDirectiveBuilder
```
public GraphQLSchemaGenerator withDirectiveBuilder(DirectiveBuilder directiveBuilder)
```
  - withRelayCompliantMutations
```
public GraphQLSchemaGenerator withRelayCompliantMutations()
```
    Sets a flag that all mutations should be mapped in a Relay-compliant way, using the default name and description for output wrapper fields.
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withRelayCompliantMutations
```
public GraphQLSchemaGenerator withRelayCompliantMutations(String wrapperFieldName,
                                                          String wrapperFieldDescription)
```
    Sets a flag signifying that all mutations should be mapped in a Relay-compliant way, using the default name and description for output wrapper fields.
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withRelayNodeInterfaceInference
```
public GraphQLSchemaGenerator withRelayNodeInterfaceInference(boolean enabled)
```
    Sets the flag controlling whether the Node interface (as defined by the Relay spec) should be automatically inferred for types that have an ID field.
    
    Parameters:
    
    enabled - Whether the inference should be enabled
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withRelayConnectionCheckRelaxed
```
public GraphQLSchemaGenerator withRelayConnectionCheckRelaxed()
```
    Removes the requirement on queries returning a Connection to comply with the Relay Connection spec
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - withSchemaProcessors
```
public GraphQLSchemaGenerator withSchemaProcessors(GraphQLSchemaProcessor... processors)
```
    Registers custom schema processors that can perform arbitrary transformations on the schema just before it is built.
    
    Parameters:
    
    processors - Custom processors to call right before the GraphQL schema is built
    
    Returns:
    
    This GraphQLSchemaGenerator instance, to allow method chaining
  - generate
```
public graphql.schema.GraphQLSchema generate()
```
    Generates a GraphQL schema based on the results of analysis of the registered sources. All exposed methods will be mapped as queries or mutations and all Java types referred to by those methods will be mapped to corresponding GraphQL types. Such schema can then be used to construct GraphQL instances. See the example in the description of this class.
    
    Returns:
    
    A GraphQL schema

Class GraphQLSchemaGenerator

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

GraphQLSchemaGenerator

GraphQLSchemaGenerator

GraphQLSchemaGenerator

Method Detail

withOperationsFromSingleton

withOperationsFromSingleton

withOperationsFromSingleton

withOperationsFromSingleton

withOperationsFromSingleton

withOperationsFromSingleton

withOperationsFromSingletons

withOperationsFromType

withOperationsFromType

withOperationsFromTypes

withOperationsFromType

withOperationsFromType

withOperationsFromTypes

withNestedOperationsFromTypes

withNestedOperationsFromTypes

withNestedResolverBuildersForType

withNestedResolverBuildersForType

withResolverBuilders

withResolverBuilders

withNestedResolverBuilders

withNestedResolverBuilders

withInputFieldBuilders

withInputFieldBuilders

withAbstractInputTypeResolution

withAbstractInputHandler

withBasePackages

withStringInterpolation

withJavaDeprecationRespected

withJavaDeprecationReason

withTypeInfoGenerator

withValueMapperFactory

withInterfaceMappingStrategy

withScalarDeserializationStrategy

withInclusionStrategy

withImplementationDiscoveryStrategy

withTypeTransformer

withTypeMappers

withTypeMappersPrepended

withTypeMappers

withSchemaTransformers

withSchemaTransformers

withInputConverters

withInputConvertersPrepended

withInputConverters

withOutputConverters

withOutputConvertersPrepended

withOutputConverters

withTypeAdapters

withArgumentInjectors

withArgumentInjectors

withModules

withModules

withResolverInterceptors

withResolverInterceptorFactories

withAdditionalTypes

withAdditionalDirectives

withAdditionalDirectives

withAdditionalDirectives

withTypeSynonymGroup

withTypeSynonymGroup

withTypeComparator

withOperationBuilder

withDirectiveBuilder

withRelayCompliantMutations

withRelayCompliantMutations

withRelayNodeInterfaceInference

withRelayConnectionCheckRelaxed

withSchemaProcessors

generate