Package org.allGraphQLCases.server

Class MyQueryTypeController

java.lang.Object

org.allGraphQLCases.server.MyQueryTypeController

Direct Known Subclasses:

MyQueryTypeController

@Controller
@SchemaMapping(typeName="MyQueryType")
public class MyQueryTypeController
extends Object

Author:

generated by graphql-java-generator

See Also:

• https://github.com/graphql-java-generator/graphql-java-generator

Field Summary

Fields

Modifier and Type	Field	Description
protected DataFetchersDelegateMyQueryType	dataFetchersDelegateMyQueryType
protected GraphqlServerUtils	graphqlServerUtils

Constructor Summary

Constructors

Constructor	Description
MyQueryTypeController()

Method Summary

Modifier and Type	Method	Description
Object	_if(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.if.
Object	_implements(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String _if)	This method loads the data for ${dataFetcher.graphQLType}.implements.
Object	_import(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.import.
Object	_instanceof(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.instanceof.
Object	_int(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.int.
Object	_interface(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.interface.
Object	_long(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.long.
Object	_native(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.native.
Object	_new(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.new.
Object	_null(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.null.
Object	_package(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.package.
Object	_private(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.private.
Object	_protected(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.protected.
Object	_public(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.public.
Object	_return(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.return.
Object	_short(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.short.
Object	_static(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.static.
Object	_strictfp(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.strictfp.
Object	_super(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.super.
Object	_switch(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.switch.
Object	_synchronized(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.synchronized.
Object	_this(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.this.
Object	_throw(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.throw.
Object	_throws(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.throws.
Object	_transient(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.transient.
Object	_try(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.try.
Object	_void(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.void.
Object	_volatile(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.volatile.
Object	_while(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.while.
Object	aBreak(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.aBreak.
Object	allFieldCases(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_AllFieldCasesInput_SINS input)	This method loads the data for ${dataFetcher.graphQLType}.allFieldCases.
Object	checkOverriddenController(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.checkOverriddenController.
Object	connectionOnHuman(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String planet, String episode)	This method loads the data for ${dataFetcher.graphQLType}.connectionOnHuman.
Object	connectionWithoutParameters(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.connectionWithoutParameters.
Object	directiveOnField(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.directiveOnField.
Object	directiveOnQuery(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Boolean uppercase)	This method loads the data for ${dataFetcher.graphQLType}.directiveOnQuery.
Object	enumWithReservedJavaKeywordAsValues(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.enumWithReservedJavaKeywordAsValues.
Object	error(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String errorLabel)	This method loads the data for ${dataFetcher.graphQLType}.error.
Object	foo140(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.foo140.
Object	issue128(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.issue128.
Object	issue200(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Boolean param)	This method loads the data for ${dataFetcher.graphQLType}.issue200.
Object	issue53(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Date date)	This method loads the data for ${dataFetcher.graphQLType}.issue53.
Object	issue82Float(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Double aFloat)	This method loads the data for ${dataFetcher.graphQLType}.issue82Float.
Object	issue82ID(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, UUID aID)	This method loads the data for ${dataFetcher.graphQLType}.issue82ID.
Object	json(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Object jsonParam)	This method loads the data for ${dataFetcher.graphQLType}.json.
Object	jsons(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<Object> jsonsParam)	This method loads the data for ${dataFetcher.graphQLType}.jsons.
Object	jsonsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<Object> inputParam)	This method loads the data for ${dataFetcher.graphQLType}.jsonsWithInput.
Object	jsonWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Object inputParam)	This method loads the data for ${dataFetcher.graphQLType}.jsonWithInput.
Object	listOfEnumWithReservedJavaKeywordAsValues(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String param1, List<String> param2)	This method loads the data for ${dataFetcher.graphQLType}.listOfEnumWithReservedJavaKeywordAsValues.
Object	object(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Object object)	This method loads the data for ${dataFetcher.graphQLType}.object.
Object	objects(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<Object> objects)	This method loads the data for ${dataFetcher.graphQLType}.objects.
Object	objectsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<Object> inputParam)	This method loads the data for ${dataFetcher.graphQLType}.objectsWithInput.
Object	objectWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Object inputParam)	This method loads the data for ${dataFetcher.graphQLType}.objectWithInput.
Object	relay(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.relay.
Object	reservedJavaKeywordAllFieldCases(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.reservedJavaKeywordAllFieldCases.
Object	returnEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.returnEnum.
Object	returnListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.returnListOfEnums.
Object	returnListOfListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.returnListOfListOfEnums.
Object	returnListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.returnListOfMandatoryEnums.
Object	returnMandatoryEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.returnMandatoryEnum.
Object	returnMandatoryListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.returnMandatoryListOfEnums.
Object	returnMandatoryListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.returnMandatoryListOfMandatoryEnums.
Object	testBase64String(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, byte[] input)	This method loads the data for ${dataFetcher.graphQLType}.testBase64String.
Object	unionTest(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_HumanInput_SINS human1, SINP_HumanInput_SINS human2, SINP_DroidInput_SINS droid1, SINP_DroidInput_SINS droid2)	This method loads the data for ${dataFetcher.graphQLType}.unionTest.
Object	withEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String episode)	This method loads the data for ${dataFetcher.graphQLType}.withEnum.
Object	withList(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String firstName, List<SINP_CharacterInput_SINS> characters)	This method loads the data for ${dataFetcher.graphQLType}.withList.
Object	withListOfList(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<List<Double>> matrix)	This method loads the data for ${dataFetcher.graphQLType}.withListOfList.
Object	withOneMandatoryParam(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_CharacterInput_SINS character)	This method loads the data for ${dataFetcher.graphQLType}.withOneMandatoryParam.
Object	withOneMandatoryParamDefaultValue(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Integer intParam)	This method loads the data for ${dataFetcher.graphQLType}.withOneMandatoryParamDefaultValue.
Object	withOneOptionalParam(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_CharacterInput_SINS character)	This method loads the data for ${dataFetcher.graphQLType}.withOneOptionalParam.
Object	withoutParameters(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)	This method loads the data for ${dataFetcher.graphQLType}.withoutParameters.
Object	withTwoMandatoryParamDefaultVal(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_DroidInput_SINS theHero, Integer num)	This method loads the data for ${dataFetcher.graphQLType}.withTwoMandatoryParamDefaultVal.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

dataFetchersDelegateMyQueryType

@Autowired
protected DataFetchersDelegateMyQueryType dataFetchersDelegateMyQueryType

graphqlServerUtils

@Autowired
protected GraphqlServerUtils graphqlServerUtils

Constructor Details

MyQueryTypeController

public MyQueryTypeController()

Method Details

withoutParameters

@SchemaMapping(field="withoutParameters")
public Object withoutParameters(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.withoutParameters.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

withOneOptionalParam

@SchemaMapping(field="withOneOptionalParam")
public Object withOneOptionalParam(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("character")
 SINP_CharacterInput_SINS character)

This method loads the data for ${dataFetcher.graphQLType}.withOneOptionalParam.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

withOneMandatoryParam

@SchemaMapping(field="withOneMandatoryParam")
public Object withOneMandatoryParam(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("character")
 SINP_CharacterInput_SINS character)

This method loads the data for ${dataFetcher.graphQLType}.withOneMandatoryParam.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

withOneMandatoryParamDefaultValue

@SchemaMapping(field="withOneMandatoryParamDefaultValue")
public Object withOneMandatoryParamDefaultValue(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("intParam")
 Integer intParam)

This method loads the data for ${dataFetcher.graphQLType}.withOneMandatoryParamDefaultValue.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

withTwoMandatoryParamDefaultVal

@SchemaMapping(field="withTwoMandatoryParamDefaultVal")
public Object withTwoMandatoryParamDefaultVal(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("theHero")
 SINP_DroidInput_SINS theHero,
 @Argument("num")
 Integer num)

This method loads the data for ${dataFetcher.graphQLType}.withTwoMandatoryParamDefaultVal.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

withEnum

@SchemaMapping(field="withEnum")
public Object withEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("episode")
 String episode)

This method loads the data for ${dataFetcher.graphQLType}.withEnum.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

withListOfList

@SchemaMapping(field="withListOfList")
public Object withListOfList(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("matrix")
 List<List<Double>> matrix)

This method loads the data for ${dataFetcher.graphQLType}.withListOfList.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

withList

@SchemaMapping(field="withList")
public Object withList(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("firstName")
 String firstName,
 @Argument("characters")
 List<SINP_CharacterInput_SINS> characters)

This method loads the data for ${dataFetcher.graphQLType}.withList.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

allFieldCases

@SchemaMapping(field="allFieldCases")
public Object allFieldCases(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("input")
 SINP_AllFieldCasesInput_SINS input)

This method loads the data for ${dataFetcher.graphQLType}.allFieldCases.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

unionTest

@SchemaMapping(field="unionTest")
public Object unionTest(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("human1")
 SINP_HumanInput_SINS human1,
 @Argument("human2")
 SINP_HumanInput_SINS human2,
 @Argument("droid1")
 SINP_DroidInput_SINS droid1,
 @Argument("droid2")
 SINP_DroidInput_SINS droid2)

This method loads the data for ${dataFetcher.graphQLType}.unionTest.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

error

@SchemaMapping(field="error")
public Object error(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("errorLabel")
 String errorLabel)

This method loads the data for ${dataFetcher.graphQLType}.error.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

aBreak

@SchemaMapping(field="aBreak")
public Object aBreak(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.aBreak.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

directiveOnQuery

@SchemaMapping(field="directiveOnQuery")
public Object directiveOnQuery(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("uppercase")
 Boolean uppercase)

This method loads the data for ${dataFetcher.graphQLType}.directiveOnQuery.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

directiveOnField

@SchemaMapping(field="directiveOnField")
public Object directiveOnField(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.directiveOnField.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

returnEnum

@SchemaMapping(field="returnEnum")
public Object returnEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.returnEnum.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

To manage enum values that are java keyword, enum values like if, else (...) are stored in enum values prefixed by _ (like _if, _else...) But this prevents the automatic mapping of spring-graphql to work. So enum values are returned as String

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

returnMandatoryEnum

@SchemaMapping(field="returnMandatoryEnum")
public Object returnMandatoryEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.returnMandatoryEnum.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

To manage enum values that are java keyword, enum values like if, else (...) are stored in enum values prefixed by _ (like _if, _else...) But this prevents the automatic mapping of spring-graphql to work. So enum values are returned as String

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

returnListOfEnums

@SchemaMapping(field="returnListOfEnums")
public Object returnListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.returnListOfEnums.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

To manage enum values that are java keyword, enum values like if, else (...) are stored in enum values prefixed by _ (like _if, _else...) But this prevents the automatic mapping of spring-graphql to work. So enum values are returned as String

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

returnListOfListOfEnums

@SchemaMapping(field="returnListOfListOfEnums")
public Object returnListOfListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.returnListOfListOfEnums.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

To manage enum values that are java keyword, enum values like if, else (...) are stored in enum values prefixed by _ (like _if, _else...) But this prevents the automatic mapping of spring-graphql to work. So enum values are returned as String

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

returnListOfMandatoryEnums

@SchemaMapping(field="returnListOfMandatoryEnums")
public Object returnListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.returnListOfMandatoryEnums.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

To manage enum values that are java keyword, enum values like if, else (...) are stored in enum values prefixed by _ (like _if, _else...) But this prevents the automatic mapping of spring-graphql to work. So enum values are returned as String

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

returnMandatoryListOfEnums

@SchemaMapping(field="returnMandatoryListOfEnums")
public Object returnMandatoryListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.returnMandatoryListOfEnums.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

To manage enum values that are java keyword, enum values like if, else (...) are stored in enum values prefixed by _ (like _if, _else...) But this prevents the automatic mapping of spring-graphql to work. So enum values are returned as String

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

returnMandatoryListOfMandatoryEnums

@SchemaMapping(field="returnMandatoryListOfMandatoryEnums")
public Object returnMandatoryListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.returnMandatoryListOfMandatoryEnums.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

To manage enum values that are java keyword, enum values like if, else (...) are stored in enum values prefixed by _ (like _if, _else...) But this prevents the automatic mapping of spring-graphql to work. So enum values are returned as String

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

connectionWithoutParameters

@SchemaMapping(field="connectionWithoutParameters")
public Object connectionWithoutParameters(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.connectionWithoutParameters.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

connectionOnHuman

@SchemaMapping(field="connectionOnHuman")
public Object connectionOnHuman(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("planet")
 String planet,
 @Argument("episode")
 String episode)

This method loads the data for ${dataFetcher.graphQLType}.connectionOnHuman.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

checkOverriddenController

@SchemaMapping(field="checkOverriddenController")
public Object checkOverriddenController(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.checkOverriddenController.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

issue53

@SchemaMapping(field="issue53")
public Object issue53(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("date")
 Date date)

This method loads the data for ${dataFetcher.graphQLType}.issue53.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

issue200

@SchemaMapping(field="issue200")
public Object issue200(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("param")
 Boolean param)

This method loads the data for ${dataFetcher.graphQLType}.issue200.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

issue82Float

@SchemaMapping(field="issue82Float")
public Object issue82Float(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("aFloat")
 Double aFloat)

This method loads the data for ${dataFetcher.graphQLType}.issue82Float.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

issue82ID

@SchemaMapping(field="issue82ID")
public Object issue82ID(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("aID")
 UUID aID)

This method loads the data for ${dataFetcher.graphQLType}.issue82ID.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

issue128

@SchemaMapping(field="issue128")
public Object issue128(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.issue128.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

enumWithReservedJavaKeywordAsValues

@SchemaMapping(field="enumWithReservedJavaKeywordAsValues")
public Object enumWithReservedJavaKeywordAsValues(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.enumWithReservedJavaKeywordAsValues.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

To manage enum values that are java keyword, enum values like if, else (...) are stored in enum values prefixed by _ (like _if, _else...) But this prevents the automatic mapping of spring-graphql to work. So enum values are returned as String

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

listOfEnumWithReservedJavaKeywordAsValues

@SchemaMapping(field="listOfEnumWithReservedJavaKeywordAsValues")
public Object listOfEnumWithReservedJavaKeywordAsValues(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("param1")
 String param1,
 @Argument("param2")
 List<String> param2)

This method loads the data for ${dataFetcher.graphQLType}.listOfEnumWithReservedJavaKeywordAsValues.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

To manage enum values that are java keyword, enum values like if, else (...) are stored in enum values prefixed by _ (like _if, _else...) But this prevents the automatic mapping of spring-graphql to work. So enum values are returned as String

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

reservedJavaKeywordAllFieldCases

@SchemaMapping(field="reservedJavaKeywordAllFieldCases")
public Object reservedJavaKeywordAllFieldCases(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.reservedJavaKeywordAllFieldCases.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_if

@SchemaMapping(field="if")
public Object _if(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.if.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_implements

@SchemaMapping(field="implements")
public Object _implements(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("if")
 String _if)

This method loads the data for ${dataFetcher.graphQLType}.implements.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_import

@SchemaMapping(field="import")
public Object _import(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.import.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_instanceof

@SchemaMapping(field="instanceof")
public Object _instanceof(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.instanceof.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_int

@SchemaMapping(field="int")
public Object _int(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.int.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_interface

@SchemaMapping(field="interface")
public Object _interface(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.interface.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_long

@SchemaMapping(field="long")
public Object _long(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.long.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_native

@SchemaMapping(field="native")
public Object _native(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.native.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_new

@SchemaMapping(field="new")
public Object _new(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.new.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_null

@SchemaMapping(field="null")
public Object _null(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.null.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_package

@SchemaMapping(field="package")
public Object _package(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.package.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_private

@SchemaMapping(field="private")
public Object _private(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.private.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_protected

@SchemaMapping(field="protected")
public Object _protected(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.protected.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_public

@SchemaMapping(field="public")
public Object _public(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.public.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_return

@SchemaMapping(field="return")
public Object _return(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.return.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_short

@SchemaMapping(field="short")
public Object _short(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.short.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_static

@SchemaMapping(field="static")
public Object _static(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.static.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_strictfp

@SchemaMapping(field="strictfp")
public Object _strictfp(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.strictfp.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_super

@SchemaMapping(field="super")
public Object _super(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.super.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_switch

@SchemaMapping(field="switch")
public Object _switch(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.switch.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_synchronized

@SchemaMapping(field="synchronized")
public Object _synchronized(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.synchronized.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_this

@SchemaMapping(field="this")
public Object _this(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.this.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_throw

@SchemaMapping(field="throw")
public Object _throw(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.throw.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_throws

@SchemaMapping(field="throws")
public Object _throws(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.throws.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_transient

@SchemaMapping(field="transient")
public Object _transient(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.transient.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_try

@SchemaMapping(field="try")
public Object _try(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.try.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_void

@SchemaMapping(field="void")
public Object _void(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.void.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_volatile

@SchemaMapping(field="volatile")
public Object _volatile(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.volatile.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

_while

@SchemaMapping(field="while")
public Object _while(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.while.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

foo140

@SchemaMapping(field="foo140")
public Object foo140(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.foo140.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

testBase64String

@SchemaMapping(field="testBase64String")
public Object testBase64String(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("input")
 byte[] input)

This method loads the data for ${dataFetcher.graphQLType}.testBase64String.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

json

@SchemaMapping(field="json")
public Object json(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("json")
 Object jsonParam)

This method loads the data for ${dataFetcher.graphQLType}.json.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

jsons

@SchemaMapping(field="jsons")
public Object jsons(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("jsons")
 List<Object> jsonsParam)

This method loads the data for ${dataFetcher.graphQLType}.jsons.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

jsonWithInput

@SchemaMapping(field="jsonWithInput")
public Object jsonWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("input")
 Object inputParam)

This method loads the data for ${dataFetcher.graphQLType}.jsonWithInput.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

jsonsWithInput

@SchemaMapping(field="jsonsWithInput")
public Object jsonsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("input")
 List<Object> inputParam)

This method loads the data for ${dataFetcher.graphQLType}.jsonsWithInput.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

object

@SchemaMapping(field="object")
public Object object(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("object")
 Object object)

This method loads the data for ${dataFetcher.graphQLType}.object.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

objects

@SchemaMapping(field="objects")
public Object objects(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("objects")
 List<Object> objects)

This method loads the data for ${dataFetcher.graphQLType}.objects.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

objectWithInput

@SchemaMapping(field="objectWithInput")
public Object objectWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("input")
 Object inputParam)

This method loads the data for ${dataFetcher.graphQLType}.objectWithInput.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

objectsWithInput

@SchemaMapping(field="objectsWithInput")
public Object objectsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment,
 @Argument("input")
 List<Object> inputParam)

This method loads the data for ${dataFetcher.graphQLType}.objectsWithInput.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

relay

@SchemaMapping(field="relay")
public Object relay(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)

This method loads the data for ${dataFetcher.graphQLType}.relay.
For optimization, this method returns a CompletableFuture. This allows to use graphql-java java-dataloader to highly optimize the number of requests to the server.
The principle is this one: The data loader collects all the data to load, avoid to load several times the same data, and allows parallel execution of the queries, if multiple queries are to be run.
You can implements this method like the sample below:

 @Override
 public CompletableFuture<List> friends(DataFetchingEnvironment environment,
                DataLoader<Long, Member> dataLoader, Human origin) {
        List<java.lang.Long> friendIds = origin.getFriendIds();
        DataLoader<java.lang.Long, CharacterImpl> dataLoader = environment.getDataLoader("Character");
        return dataLoader.loadMany(friendIds);
 }
 

Parameters:

dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

dataLoader - The DataLoader allows to load several data in one query. It allows to solve the (n+1) queries issues, and greatly optimizes the response time.
You'll find more informations here: https://github.com/graphql-java/java-dataloader

origin - The object from which the field is fetch. In other word: the aim of this data fetcher is to fetch the author attribute of the origin, which is an instance of {ObjectType {name:Post, fields:{Field{name:id, type:ID!, params:[]},Field{name:date, type:Date!, params:[]},Field{name:author, type:Member, params:[]},Field{name:publiclyAvailable, type:Boolean, params:[]},Field{name:title, type:String!, params:[]},Field{name:content, type:String!, params:[]},Field{name:authorId, type:ID, params:[]},Field{name:topicId, type:ID, params:[]}}, comments ""}. It depends on your data modle, but it typically contains the id to use in the query.

Throws:

NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.