Package org.allGraphQLCases.server.impl

Class DataFetchersDelegateMyQueryTypeImpl

java.lang.Object
org.allGraphQLCases.server.impl.DataFetchersDelegateMyQueryTypeImpl
All Implemented Interfaces:
DataFetchersDelegateMyQueryType
@Component public class DataFetchersDelegateMyQueryTypeImpl extends Object implements DataFetchersDelegateMyQueryType
Author:
etienne-sf

  • Constructor Summary

    Constructors
    Constructor
    Description
    DataFetchersDelegateMyQueryTypeImpl()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    String
    _if(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.if.
    String
    _implements(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String _if)
    Description for the implements field:
    Test for PR 177 (on server side, the returned value is the content of the if input parameter)
    This method loads the data for MyQueryType.implements.
    String
    _import(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.import.
    String
    _instanceof(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.instanceof.
    String
    _int(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.int.
    String
    _interface(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.interface.
    String
    _long(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.long.
    String
    _native(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.native.
    String
    _new(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.new.
    String
    _null(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    Description for the null field:
    Issue #188: null is not identified as a java keyword
    This method loads the data for MyQueryType.null.
    String
    _package(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.package.
    String
    _private(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.private.
    String
    _protected(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.protected.
    String
    _public(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.public.
    String
    _return(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.return.
    String
    _short(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.short.
    String
    _static(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.static.
    String
    _strictfp(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.strictfp.
    String
    _super(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.super.
    String
    _switch(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.switch.
    String
    _synchronized(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.synchronized.
    String
    _this(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.this.
    String
    _throw(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.throw.
    String
    _throws(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.throws.
    String
    _transient(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.transient.
    String
    _try(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.try.
    String
    _void(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.void.
    String
    _volatile(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.volatile.
    String
    _while(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.while.
    STP_break_STS
    aBreak(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    Description for the aBreak field:
    Check for GraphQL identifier that are java keywords
    This method loads the data for MyQueryType.aBreak.
    STP_AllFieldCases_STS
    allFieldCases(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_AllFieldCasesInput_SINS input)
    Description for the allFieldCases field:
    ################################################################################ # Complementary tests with the AllFieldCases Object
    This method loads the data for MyQueryType.allFieldCases.
    static String
    buildWithArguments(graphql.language.OperationDefinition operation)
     
    STP_HumanConnection_STS
    connectionOnHuman(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String planet, SEP_Episode_SES SEP_Episode_SES)
    This method loads the data for MyQueryType.connectionOnHuman.
    SIP_CharacterConnection_SIS
    connectionWithoutParameters(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.connectionWithoutParameters.
    SIP_Character_SIS
    directiveOnField(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    Description for the directiveOnField field:
    # Returns the value, and potentially the anotherValue of the @testDirective directive set on the @directiveOnQuery
    List<String>
    directiveOnQuery(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Boolean uppercase)
    Description for the directiveOnQuery field:
    # Returns the value, and potentially the anotherValue of the @testDirective directive set on the directiveOnQuery query
    SEP_EnumWithReservedJavaKeywordAsValues_SES
    enumWithReservedJavaKeywordAsValues(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    Description for the enumWithReservedJavaKeywordAsValues field:
    test for issue #139 (use of java reserved keyword)
    This method loads the data for MyQueryType.enumWithReservedJavaKeywordAsValues.
    SIP_Character_SIS
    error(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String errorLabel)
    Description for the error field:
    ################################################################################ # error always returns an error!
    STP_Foo140_STS
    foo140(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    Description for the foo140 field:
    test for issue #140 (error for type that implements multiple interfaces)
    This method loads the data for MyQueryType.foo140.
    SIP_Client_SIS
    issue128(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    Description for the issue128 field:
    test for issue #128 (compilation error when a Query returns a type 'Client')
    This method loads the data for MyQueryType.issue128.
    Boolean
    issue200(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Boolean param)
    This method loads the data for MyQueryType.issue200.
    String
    Issue217(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String AnArg)
    Description for the Issue217 field:
    Issue 217: issue when a field name starts with an uppercase letter
    This method loads the data for MyQueryType.Issue217.
    Date
    issue53(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Date date)
    No action.
    Double
    issue82Float(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Double aFloat)
    Description for the issue82Float field:
    #issue82 is about hard coded values as parameters.
    UUID
    issue82ID(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, UUID id)
    This method loads the data for MyQueryType.issue82ID.
    com.fasterxml.jackson.databind.node.ObjectNode
    json(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, com.fasterxml.jackson.databind.node.ObjectNode json)
    Description for the json field:
    Test of JSON scalar, for issue #205
    This method loads the data for MyQueryType.json.
    List<com.fasterxml.jackson.databind.node.ObjectNode>
    jsons(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<com.fasterxml.jackson.databind.node.ObjectNode> jsons)
    This method loads the data for MyQueryType.jsons.
    List<STP_TypeWithJson_STS>
    jsonsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<SINP_InputWithJson_SINS> input)
    This method loads the data for MyQueryType.jsonsWithInput.
    STP_TypeWithJson_STS
    jsonWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_InputWithJson_SINS input)
    This method loads the data for MyQueryType.jsonWithInput.
    List<SEP_EnumWithReservedJavaKeywordAsValues_SES>
    listOfEnumWithReservedJavaKeywordAsValues(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SEP_EnumWithReservedJavaKeywordAsValues_SES param1, List<SEP_EnumWithReservedJavaKeywordAsValues_SES> param2)
    This method loads the data for MyQueryType.listOfEnumWithReservedJavaKeywordAsValues.
    Object
    object(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Object object)
    This method loads the data for MyQueryType.object.
    List<Object>
    objects(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<Object> objects)
    This method loads the data for MyQueryType.objects.
    List<STP_TypeWithObject_STS>
    objectsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<SINP_InputWithObject_SINS> input)
    This method loads the data for MyQueryType.objectsWithInput.
    STP_TypeWithObject_STS
    objectWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_InputWithObject_SINS input)
    This method loads the data for MyQueryType.objectWithInput.
    STP_MyQueryType_STS
    relay(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.relay.
    STP_ReservedJavaKeywordAllFieldCases_STS
    reservedJavaKeywordAllFieldCases(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.reservedJavaKeywordAllFieldCases.
    SEP_EnumWithReservedJavaKeywordAsValues_SES
    returnEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.returnEnum.
    List<SEP_EnumWithReservedJavaKeywordAsValues_SES>
    returnListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.returnListOfEnums.
    List<List<SEP_EnumWithReservedJavaKeywordAsValues_SES>>
    returnListOfListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.returnListOfListOfEnums.
    List<SEP_EnumWithReservedJavaKeywordAsValues_SES>
    returnListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.returnListOfMandatoryEnums.
    SEP_EnumWithReservedJavaKeywordAsValues_SES
    returnMandatoryEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.returnMandatoryEnum.
    List<SEP_EnumWithReservedJavaKeywordAsValues_SES>
    returnMandatoryListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.returnMandatoryListOfEnums.
    List<SEP_EnumWithReservedJavaKeywordAsValues_SES>
    returnMandatoryListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for MyQueryType.returnMandatoryListOfMandatoryEnums.
    byte[]
    testBase64String(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, byte[] input)
    Description for the testBase64String field:
    Test for issue #174: a custom scalar which Java type is an array
    This method loads the data for MyQueryType.testBase64String.
    List<SUP_AnyCharacter_SUS>
    unionTest(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_HumanInput_SINS human1, SINP_HumanInput_SINS human2, SINP_DroidInput_SINS droid1, SINP_DroidInput_SINS droid2)
    Description for the unionTest field:
    ################################################################################ # Test for unions
    This method loads the data for MyQueryType.unionTest.
    SIP_Character_SIS
    withEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SEP_Episode_SES SEP_Episode_SES)
    This method loads the data for MyQueryType.withEnum.
    List<SIP_Character_SIS>
    withList(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String name, List<SINP_CharacterInput_SINS> characters)
    Description for the withList field:
    ################################################################################ # withList return a list of Characters, matching the given list of CharacterInput
    STP_AllFieldCases_STS
    withListOfList(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<List<Double>> matrix)
    This method loads the data for MyQueryType.withListOfList.
    SIP_Character_SIS
    withOneMandatoryParam(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_CharacterInput_SINS character)
    This method loads the data for MyQueryType.withOneMandatoryParam.
    Integer
    withOneMandatoryParamDefaultValue(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Integer result)
    This method loads the data for MyQueryType.withOneMandatoryParamDefaultValue.
    SIP_Character_SIS
    withOneOptionalParam(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_CharacterInput_SINS character)
    This method loads the data for MyQueryType.withOneOptionalParam.
    List<SIP_Character_SIS>
    withoutParameters(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    Description for the withoutParameters field:
    This is a description to describe the field withoutParameters on two lines
    This method loads the data for MyQueryType.withoutParameters.
    STP_Droid_STS
    withTwoMandatoryParamDefaultVal(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_DroidInput_SINS theHero, Integer num)
    This method loads the data for MyQueryType.withTwoMandatoryParamDefaultVal.

    Methods inherited from class java.lang.Object

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

  • Constructor Details

    • DataFetchersDelegateMyQueryTypeImpl

      public DataFetchersDelegateMyQueryTypeImpl()

  • Method Details

    • withoutParameters

      public List<SIP_Character_SIS> withoutParameters(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the withoutParameters field:
      This is a description to describe the field withoutParameters on two lines
      This method loads the data for MyQueryType.withoutParameters. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<org.allGraphQLCases.server.SIP_Character_SIS>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<org.allGraphQLCases.server.SIP_Character_SIS>> or a Flux<List<org.allGraphQLCases.server.SIP_Character_SIS>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<org.allGraphQLCases.server.SIP_Character_SIS>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<org.allGraphQLCases.server.SIP_Character_SIS>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      withoutParameters in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • withOneOptionalParam

      public SIP_Character_SIS withOneOptionalParam(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_CharacterInput_SINS character)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.withOneOptionalParam. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.SIP_Character_SIS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.SIP_Character_SIS> or a Flux<org.allGraphQLCases.server.SIP_Character_SIS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.SIP_Character_SIS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.SIP_Character_SIS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      withOneOptionalParam in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      character - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • withOneMandatoryParam

      public SIP_Character_SIS withOneMandatoryParam(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_CharacterInput_SINS character)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.withOneMandatoryParam. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.SIP_Character_SIS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.SIP_Character_SIS> or a Flux<org.allGraphQLCases.server.SIP_Character_SIS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.SIP_Character_SIS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.SIP_Character_SIS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      withOneMandatoryParam in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      character - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • withEnum

      public SIP_Character_SIS withEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SEP_Episode_SES SEP_Episode_SES)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.withEnum. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.SIP_Character_SIS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.SIP_Character_SIS> or a Flux<org.allGraphQLCases.server.SIP_Character_SIS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.SIP_Character_SIS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.SIP_Character_SIS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      withEnum in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      SEP_Episode_SES - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • withListOfList

      public STP_AllFieldCases_STS withListOfList(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<List<Double>> matrix)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.withListOfList. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.STP_AllFieldCases_STS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.STP_AllFieldCases_STS> or a Flux<org.allGraphQLCases.server.STP_AllFieldCases_STS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.STP_AllFieldCases_STS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.STP_AllFieldCases_STS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      withListOfList in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      matrix - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • withList

      public List<SIP_Character_SIS> withList(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String name, List<SINP_CharacterInput_SINS> characters)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the withList field:
      ################################################################################ # withList return a list of Characters, matching the given list of CharacterInput. # The name of the first Character returned is replaced by the given firstName. # All ids are generated
      This method loads the data for MyQueryType.withList. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<org.allGraphQLCases.server.SIP_Character_SIS>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<org.allGraphQLCases.server.SIP_Character_SIS>> or a Flux<List<org.allGraphQLCases.server.SIP_Character_SIS>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<org.allGraphQLCases.server.SIP_Character_SIS>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<org.allGraphQLCases.server.SIP_Character_SIS>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      withList in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      name - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      characters - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • error

      public SIP_Character_SIS error(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String errorLabel)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the error field:
      ################################################################################ # error always returns an error! (used to check the error management)
      This method loads the data for MyQueryType.error. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.SIP_Character_SIS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.SIP_Character_SIS> or a Flux<org.allGraphQLCases.server.SIP_Character_SIS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.SIP_Character_SIS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.SIP_Character_SIS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      error in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      errorLabel - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • allFieldCases

      public STP_AllFieldCases_STS allFieldCases(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_AllFieldCasesInput_SINS input)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the allFieldCases field:
      ################################################################################ # Complementary tests with the AllFieldCases Object
      This method loads the data for MyQueryType.allFieldCases. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.STP_AllFieldCases_STS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.STP_AllFieldCases_STS> or a Flux<org.allGraphQLCases.server.STP_AllFieldCases_STS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.STP_AllFieldCases_STS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.STP_AllFieldCases_STS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      allFieldCases in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      input - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • aBreak

      public STP_break_STS aBreak(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the aBreak field:
      Check for GraphQL identifier that are java keywords
      This method loads the data for MyQueryType.aBreak. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.STP_break_STS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.STP_break_STS> or a Flux<org.allGraphQLCases.server.STP_break_STS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.STP_break_STS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.STP_break_STS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      aBreak in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • directiveOnQuery

      public List<String> directiveOnQuery(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Boolean uppercase)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the directiveOnQuery field:
      # Returns the value, and potentially the anotherValue of the @testDirective directive set on the directiveOnQuery query. # List is null if the directive is not present.
      This method loads the data for MyQueryType.directiveOnQuery. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<java.lang.String>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<java.lang.String>> or a Flux<List<java.lang.String>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<java.lang.String>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<java.lang.String>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      directiveOnQuery in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      uppercase - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • directiveOnField

      public SIP_Character_SIS directiveOnField(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the directiveOnField field:
      # Returns the value, and potentially the anotherValue of the @testDirective directive set on the @directiveOnQuery. # List is null if the directive is not present.
      This method loads the data for MyQueryType.directiveOnField. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.SIP_Character_SIS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.SIP_Character_SIS> or a Flux<org.allGraphQLCases.server.SIP_Character_SIS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.SIP_Character_SIS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.SIP_Character_SIS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      directiveOnField in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • unionTest

      public List<SUP_AnyCharacter_SUS> unionTest(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_HumanInput_SINS human1, SINP_HumanInput_SINS human2, SINP_DroidInput_SINS droid1, SINP_DroidInput_SINS droid2)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the unionTest field:
      ################################################################################ # Test for unions
      This method loads the data for MyQueryType.unionTest. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<org.allGraphQLCases.server.SUP_AnyCharacter_SUS>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<org.allGraphQLCases.server.SUP_AnyCharacter_SUS>> or a Flux<List<org.allGraphQLCases.server.SUP_AnyCharacter_SUS>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<org.allGraphQLCases.server.SUP_AnyCharacter_SUS>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<org.allGraphQLCases.server.SUP_AnyCharacter_SUS>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      unionTest in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      human1 - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      human2 - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      droid1 - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      droid2 - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • withOneMandatoryParamDefaultValue

      public Integer withOneMandatoryParamDefaultValue(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Integer result)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.withOneMandatoryParamDefaultValue. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.Integer)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.Integer> or a Flux<java.lang.Integer>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.Integer>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.Integer>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      withOneMandatoryParamDefaultValue in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      result - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • withTwoMandatoryParamDefaultVal

      public STP_Droid_STS withTwoMandatoryParamDefaultVal(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_DroidInput_SINS theHero, Integer num)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.withTwoMandatoryParamDefaultVal. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.STP_Droid_STS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.STP_Droid_STS> or a Flux<org.allGraphQLCases.server.STP_Droid_STS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.STP_Droid_STS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.STP_Droid_STS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      withTwoMandatoryParamDefaultVal in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      theHero - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      num - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • relay

      public STP_MyQueryType_STS relay(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.relay. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.STP_MyQueryType_STS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.STP_MyQueryType_STS> or a Flux<org.allGraphQLCases.server.STP_MyQueryType_STS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.STP_MyQueryType_STS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.STP_MyQueryType_STS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      relay in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • connectionWithoutParameters

      public SIP_CharacterConnection_SIS connectionWithoutParameters(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.connectionWithoutParameters. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.SIP_CharacterConnection_SIS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.SIP_CharacterConnection_SIS> or a Flux<org.allGraphQLCases.server.SIP_CharacterConnection_SIS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.SIP_CharacterConnection_SIS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.SIP_CharacterConnection_SIS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      connectionWithoutParameters in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • connectionOnHuman

      public STP_HumanConnection_STS connectionOnHuman(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String planet, SEP_Episode_SES SEP_Episode_SES)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.connectionOnHuman. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.STP_HumanConnection_STS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.STP_HumanConnection_STS> or a Flux<org.allGraphQLCases.server.STP_HumanConnection_STS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.STP_HumanConnection_STS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.STP_HumanConnection_STS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      connectionOnHuman in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      planet - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      SEP_Episode_SES - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • issue53

      public Date issue53(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Date date)
      No action. It just returns the date parameter, to check serialization and deserialization on both sides
      Specified by:
      issue53 in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      date - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • issue82Float

      public Double issue82Float(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Double aFloat)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the issue82Float field:
      #issue82 is about hard coded values as parameters. Other types are tests with other queries, but there was no method with a simple float parameter
      This method loads the data for MyQueryType.issue82Float. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.Double)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.Double> or a Flux<java.lang.Double>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.Double>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.Double>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      issue82Float in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      aFloat - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • issue82ID

      public UUID issue82ID(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, UUID id)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.issue82ID. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.util.UUID)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.util.UUID> or a Flux<java.util.UUID>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.util.UUID>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.util.UUID>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      issue82ID in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      id - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • issue128

      public SIP_Client_SIS issue128(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the issue128 field:
      test for issue #128 (compilation error when a Query returns a type 'Client')
      This method loads the data for MyQueryType.issue128. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.SIP_Client_SIS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.SIP_Client_SIS> or a Flux<org.allGraphQLCases.server.SIP_Client_SIS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.SIP_Client_SIS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.SIP_Client_SIS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      issue128 in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • foo140

      public STP_Foo140_STS foo140(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the foo140 field:
      test for issue #140 (error for type that implements multiple interfaces)
      This method loads the data for MyQueryType.foo140. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.STP_Foo140_STS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.STP_Foo140_STS> or a Flux<org.allGraphQLCases.server.STP_Foo140_STS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.STP_Foo140_STS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.STP_Foo140_STS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      foo140 in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • enumWithReservedJavaKeywordAsValues

      public SEP_EnumWithReservedJavaKeywordAsValues_SES enumWithReservedJavaKeywordAsValues(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the enumWithReservedJavaKeywordAsValues field:
      test for issue #139 (use of java reserved keyword)
      This method loads the data for MyQueryType.enumWithReservedJavaKeywordAsValues. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES> or a Flux<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      enumWithReservedJavaKeywordAsValues in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • listOfEnumWithReservedJavaKeywordAsValues

      public List<SEP_EnumWithReservedJavaKeywordAsValues_SES> listOfEnumWithReservedJavaKeywordAsValues(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SEP_EnumWithReservedJavaKeywordAsValues_SES param1, List<SEP_EnumWithReservedJavaKeywordAsValues_SES> param2)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.listOfEnumWithReservedJavaKeywordAsValues. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>> or a Flux<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      listOfEnumWithReservedJavaKeywordAsValues in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      param1 - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      param2 - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • _if

      public String _if(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.if. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _if in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _implements

      public String _implements(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String _if)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the implements field:
      Test for PR 177 (on server side, the returned value is the content of the if input parameter)
      This method loads the data for MyQueryType.implements. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _implements in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _import

      public String _import(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.import. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _import in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _instanceof

      public String _instanceof(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.instanceof. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _instanceof in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _int

      public String _int(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.int. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _int in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _interface

      public String _interface(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.interface. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _interface in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _long

      public String _long(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.long. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _long in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _native

      public String _native(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.native. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _native in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _new

      public String _new(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.new. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _new in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _package

      public String _package(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.package. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _package in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _private

      public String _private(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.private. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _private in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _protected

      public String _protected(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.protected. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _protected in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _public

      public String _public(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.public. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _public in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _return

      public String _return(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.return. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _return in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _short

      public String _short(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.short. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _short in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _static

      public String _static(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.static. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _static in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _strictfp

      public String _strictfp(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.strictfp. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _strictfp in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _super

      public String _super(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.super. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _super in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _switch

      public String _switch(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.switch. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _switch in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _synchronized

      public String _synchronized(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.synchronized. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _synchronized in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _this

      public String _this(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.this. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _this in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _throw

      public String _throw(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.throw. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _throw in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _throws

      public String _throws(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.throws. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _throws in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _transient

      public String _transient(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.transient. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _transient in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _try

      public String _try(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.try. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _try in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _void

      public String _void(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.void. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _void in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _volatile

      public String _volatile(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.volatile. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _volatile in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _while

      public String _while(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.while. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _while in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • reservedJavaKeywordAllFieldCases

      public STP_ReservedJavaKeywordAllFieldCases_STS reservedJavaKeywordAllFieldCases(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.reservedJavaKeywordAllFieldCases. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.STP_ReservedJavaKeywordAllFieldCases_STS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.STP_ReservedJavaKeywordAllFieldCases_STS> or a Flux<org.allGraphQLCases.server.STP_ReservedJavaKeywordAllFieldCases_STS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.STP_ReservedJavaKeywordAllFieldCases_STS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.STP_ReservedJavaKeywordAllFieldCases_STS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      reservedJavaKeywordAllFieldCases in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • testBase64String

      public byte[] testBase64String(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, byte[] input)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the testBase64String field:
      Test for issue #174: a custom scalar which Java type is an array
      This method loads the data for MyQueryType.testBase64String. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a byte[])
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<byte[]> or a Flux<byte[]>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<byte[]>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<byte[]>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      testBase64String in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      input - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • returnEnum

      public SEP_EnumWithReservedJavaKeywordAsValues_SES returnEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.returnEnum. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES> or a Flux<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      returnEnum in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnMandatoryEnum

      public SEP_EnumWithReservedJavaKeywordAsValues_SES returnMandatoryEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.returnMandatoryEnum. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES> or a Flux<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      returnMandatoryEnum in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnListOfEnums

      public List<SEP_EnumWithReservedJavaKeywordAsValues_SES> returnListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.returnListOfEnums. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>> or a Flux<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      returnListOfEnums in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnListOfListOfEnums

      public List<List<SEP_EnumWithReservedJavaKeywordAsValues_SES>> returnListOfListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.returnListOfListOfEnums. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>> or a Flux<List<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      returnListOfListOfEnums in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnListOfMandatoryEnums

      public List<SEP_EnumWithReservedJavaKeywordAsValues_SES> returnListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.returnListOfMandatoryEnums. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>> or a Flux<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      returnListOfMandatoryEnums in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnMandatoryListOfEnums

      public List<SEP_EnumWithReservedJavaKeywordAsValues_SES> returnMandatoryListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.returnMandatoryListOfEnums. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>> or a Flux<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      returnMandatoryListOfEnums in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnMandatoryListOfMandatoryEnums

      public List<SEP_EnumWithReservedJavaKeywordAsValues_SES> returnMandatoryListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.returnMandatoryListOfMandatoryEnums. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>> or a Flux<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<org.allGraphQLCases.server.SEP_EnumWithReservedJavaKeywordAsValues_SES>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      returnMandatoryListOfMandatoryEnums in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _null

      public String _null(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the null field:
      Issue #188: null is not identified as a java keyword
      This method loads the data for MyQueryType.null. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      _null in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • issue200

      public Boolean issue200(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Boolean param)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.issue200. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.Boolean)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.Boolean> or a Flux<java.lang.Boolean>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.Boolean>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.Boolean>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      issue200 in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      param - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • json

      public com.fasterxml.jackson.databind.node.ObjectNode json(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, com.fasterxml.jackson.databind.node.ObjectNode json)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the json field:
      Test of JSON scalar, for issue #205
      This method loads the data for MyQueryType.json. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a com.fasterxml.jackson.databind.node.ObjectNode)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<com.fasterxml.jackson.databind.node.ObjectNode> or a Flux<com.fasterxml.jackson.databind.node.ObjectNode>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<com.fasterxml.jackson.databind.node.ObjectNode>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<com.fasterxml.jackson.databind.node.ObjectNode>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      json in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      json - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • jsons

      public List<com.fasterxml.jackson.databind.node.ObjectNode> jsons(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<com.fasterxml.jackson.databind.node.ObjectNode> jsons)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.jsons. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<com.fasterxml.jackson.databind.node.ObjectNode>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<com.fasterxml.jackson.databind.node.ObjectNode>> or a Flux<List<com.fasterxml.jackson.databind.node.ObjectNode>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<com.fasterxml.jackson.databind.node.ObjectNode>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<com.fasterxml.jackson.databind.node.ObjectNode>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      jsons in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      jsons - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • object

      public Object object(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Object object)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.object. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.Object)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.Object> or a Flux<java.lang.Object>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.Object>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.Object>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      object in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      object - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • objects

      public List<Object> objects(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<Object> objects)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.objects. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<java.lang.Object>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<java.lang.Object>> or a Flux<List<java.lang.Object>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<java.lang.Object>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<java.lang.Object>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      objects in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      objects - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • jsonWithInput

      public STP_TypeWithJson_STS jsonWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_InputWithJson_SINS input)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.jsonWithInput. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.STP_TypeWithJson_STS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.STP_TypeWithJson_STS> or a Flux<org.allGraphQLCases.server.STP_TypeWithJson_STS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.STP_TypeWithJson_STS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.STP_TypeWithJson_STS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      jsonWithInput in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      input - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • jsonsWithInput

      public List<STP_TypeWithJson_STS> jsonsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<SINP_InputWithJson_SINS> input)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.jsonsWithInput. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<org.allGraphQLCases.server.STP_TypeWithJson_STS>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<org.allGraphQLCases.server.STP_TypeWithJson_STS>> or a Flux<List<org.allGraphQLCases.server.STP_TypeWithJson_STS>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<org.allGraphQLCases.server.STP_TypeWithJson_STS>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<org.allGraphQLCases.server.STP_TypeWithJson_STS>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      jsonsWithInput in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      input - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • objectWithInput

      public STP_TypeWithObject_STS objectWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_InputWithObject_SINS input)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.objectWithInput. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.STP_TypeWithObject_STS)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<org.allGraphQLCases.server.STP_TypeWithObject_STS> or a Flux<org.allGraphQLCases.server.STP_TypeWithObject_STS>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<org.allGraphQLCases.server.STP_TypeWithObject_STS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.STP_TypeWithObject_STS>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      objectWithInput in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      input - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • objectsWithInput

      public List<STP_TypeWithObject_STS> objectsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<SINP_InputWithObject_SINS> input)
      Description copied from interface: DataFetchersDelegateMyQueryType
      This method loads the data for MyQueryType.objectsWithInput. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<org.allGraphQLCases.server.STP_TypeWithObject_STS>)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<List<org.allGraphQLCases.server.STP_TypeWithObject_STS>> or a Flux<List<org.allGraphQLCases.server.STP_TypeWithObject_STS>>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<List<org.allGraphQLCases.server.STP_TypeWithObject_STS>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<org.allGraphQLCases.server.STP_TypeWithObject_STS>>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      objectsWithInput in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      input - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • buildWithArguments

      public static String buildWithArguments(graphql.language.OperationDefinition operation)

    • Issue217

      public String Issue217(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String AnArg)
      Description copied from interface: DataFetchersDelegateMyQueryType
      Description for the Issue217 field:
      Issue 217: issue when a field name starts with an uppercase letter
      This method loads the data for MyQueryType.Issue217. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.lang.String)
      • Mono and Flux for asynchronous value(s). Supported for controller methods and for any DataFetcher as described in Reactive DataFetcher. This would typically be a Mono<java.lang.String> or a Flux<java.lang.String>
      • Kotlin coroutine and Flow are adapted to Mono and Flux
      • java.util.concurrent.Callable to have the value(s) produced asynchronously. For this to work, AnnotatedControllerConfigurer must be configured with an Executor. This would typically by a Callable<java.lang.String>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.lang.String>. 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.
      • A Publisher (instead of a Flux), for Subscription for instance
      Specified by:
      Issue217 in interface DataFetchersDelegateMyQueryType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher