Package org.allGraphQLCases.server

Interface DataFetchersDelegateTheSubscriptionType

All Known Implementing Classes:
DataFetchersDelegateTheSubscriptionTypeImpl
public interface DataFetchersDelegateTheSubscriptionType
This interface contains the fata fetchers that are delegated in the bean that the implementation has to provide, when fetching fields for the TheSubscriptionType GraphQL type, as defined in the provided GraphQL schema. Please read the wiki server page for more information on this.
Author:
generated by graphql-java-generator
See Also:

  • Method Summary

    Modifier and Type
    Method
    Description
    Object
    _if(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for TheSubscriptionType.if.
    Object
    _implements(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for TheSubscriptionType.implements.
    Object
    _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 TheSubscriptionType.null.
    Object
    allGraphQLCasesInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_AllFieldCasesInput_SINS input)
    Description for the allGraphQLCasesInput field:
    Some subscriptions to test all kind of input parameters (to check proper serialization and deserialization)
    This method loads the data for TheSubscriptionType.allGraphQLCasesInput.
    Object
    allGraphQLCasesParam(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String id, String name, Long age, Integer integer, Date date, List<Date> dates, List<List<Double>> matrix, SINP_AllFieldCasesWithoutIdSubtypeInput_SINS oneWithoutIdSubtype, List<SINP_AllFieldCasesWithoutIdSubtypeInput_SINS> listWithoutIdSubtype)
    This method loads the data for TheSubscriptionType.allGraphQLCasesParam.
    Object
    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 TheSubscriptionType.enumWithReservedJavaKeywordAsValues.
    Object
    issue53(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Date date)
    Description for the issue53 field:
    issue53 is about custom scalars as parameter for a query/mutation/subscription, that was not properly serialized/deserialized
    This method loads the data for TheSubscriptionType.issue53.
    Object
    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 TheSubscriptionType.json.
    Object
    jsons(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<com.fasterxml.jackson.databind.node.ObjectNode> jsons)
    This method loads the data for TheSubscriptionType.jsons.
    Object
    jsonsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<SINP_InputWithJson_SINS> input)
    This method loads the data for TheSubscriptionType.jsonsWithInput.
    Object
    listOfEnumWithReservedJavaKeywordAsValues(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for TheSubscriptionType.listOfEnumWithReservedJavaKeywordAsValues.
    Object
    objectsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<SINP_InputWithObject_SINS> input)
    This method loads the data for TheSubscriptionType.objectsWithInput.
    Object
    returnEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for TheSubscriptionType.returnEnum.
    Object
    returnListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for TheSubscriptionType.returnListOfEnums.
    Object
    returnListOfListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for TheSubscriptionType.returnListOfListOfEnums.
    Object
    returnListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for TheSubscriptionType.returnListOfMandatoryEnums.
    Object
    returnMandatoryEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SEP_EnumWithReservedJavaKeywordAsValues_SES _enum)
    This method loads the data for TheSubscriptionType.returnMandatoryEnum.
    Object
    returnMandatoryListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for TheSubscriptionType.returnMandatoryListOfEnums.
    Object
    returnMandatoryListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for TheSubscriptionType.returnMandatoryListOfMandatoryEnums.
    Object
    subscribeNewHumanForEpisode(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SEP_Episode_SES episode)
    Description for the subscribeNewHumanForEpisode field:
    Will be notified for each Human added to this Episode
    This method loads the data for TheSubscriptionType.subscribeNewHumanForEpisode.
    Object
    subscribeToAList(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    Description for the subscribeToAList field:
    Issue 54
    This method loads the data for TheSubscriptionType.subscribeToAList.
    Object
    subscribeToAListOfScalars(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    This method loads the data for TheSubscriptionType.subscribeToAListOfScalars.
    Object
    subscriptionTest(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_SubscriptionTestParam_SINS param)
    Description for the subscriptionTest field:
    A dummy subscription, that allows to test errors (and other strange behavior), and their return to the subscription's client
    This method loads the data for TheSubscriptionType.subscriptionTest.
    Object
    subscriptionWithNullResponse(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
    Description for the subscriptionWithNullResponse field:
    Issue 122: Check Subscription behavior when notification response is null
    This method loads the data for TheSubscriptionType.subscriptionWithNullResponse.

  • Method Details

    • subscribeNewHumanForEpisode

      Object subscribeNewHumanForEpisode(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SEP_Episode_SES episode)
      Description for the subscribeNewHumanForEpisode field:
      Will be notified for each Human added to this Episode
      This method loads the data for TheSubscriptionType.subscribeNewHumanForEpisode. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a org.allGraphQLCases.server.STP_Human_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_Human_STS> or a Flux<org.allGraphQLCases.server.STP_Human_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_Human_STS>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<org.allGraphQLCases.server.STP_Human_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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      episode - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • subscribeToAList

      Object subscribeToAList(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description for the subscribeToAList field:
      Issue 54
      This method loads the data for TheSubscriptionType.subscribeToAList. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<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<List<java.lang.Integer>> or a Flux<List<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<List<java.lang.Integer>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • subscribeToAListOfScalars

      Object subscribeToAListOfScalars(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      This method loads the data for TheSubscriptionType.subscribeToAListOfScalars. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a List<java.util.Date>)
      • 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.util.Date>> or a Flux<List<java.util.Date>>
      • 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.util.Date>>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<List<java.util.Date>>. 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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • issue53

      Object issue53(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Date date)
      Description for the issue53 field:
      issue53 is about custom scalars as parameter for a query/mutation/subscription, that was not properly serialized/deserialized
      This method loads the data for TheSubscriptionType.issue53. It may return whatever is accepted by the Spring Controller, that is:
      • A resolved value of any type (typically, a java.util.Date)
      • 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.Date> or a Flux<java.util.Date>
      • 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.Date>
      As a complement to the spring-graphql documentation, you may also return:
      • A CompletableFuture<?>, for instance CompletableFuture<java.util.Date>. 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
      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.
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • allGraphQLCasesInput

      Object allGraphQLCasesInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_AllFieldCasesInput_SINS input)
      Description for the allGraphQLCasesInput field:
      Some subscriptions to test all kind of input parameters (to check proper serialization and deserialization)
      This method loads the data for TheSubscriptionType.allGraphQLCasesInput. 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
      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.
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • allGraphQLCasesParam

      Object allGraphQLCasesParam(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, String id, String name, Long age, Integer integer, Date date, List<Date> dates, List<List<Double>> matrix, SINP_AllFieldCasesWithoutIdSubtypeInput_SINS oneWithoutIdSubtype, List<SINP_AllFieldCasesWithoutIdSubtypeInput_SINS> listWithoutIdSubtype)
      This method loads the data for TheSubscriptionType.allGraphQLCasesParam. 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
      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.
      name - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      age - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      integer - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      date - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      dates - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      matrix - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      oneWithoutIdSubtype - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      listWithoutIdSubtype - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • subscriptionTest

      Object subscriptionTest(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_SubscriptionTestParam_SINS param)
      Description for the subscriptionTest field:
      A dummy subscription, that allows to test errors (and other strange behavior), and their return to the subscription's client
      This method loads the data for TheSubscriptionType.subscriptionTest. 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
      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.
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • returnEnum

      Object returnEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      This method loads the data for TheSubscriptionType.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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • returnMandatoryEnum

      Object returnMandatoryEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SEP_EnumWithReservedJavaKeywordAsValues_SES _enum)
      This method loads the data for TheSubscriptionType.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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      enum - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • returnListOfEnums

      Object returnListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      This method loads the data for TheSubscriptionType.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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • returnListOfMandatoryEnums

      Object returnListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      This method loads the data for TheSubscriptionType.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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • returnListOfListOfEnums

      Object returnListOfListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      This method loads the data for TheSubscriptionType.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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • returnMandatoryListOfEnums

      Object returnMandatoryListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      This method loads the data for TheSubscriptionType.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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • returnMandatoryListOfMandatoryEnums

      Object returnMandatoryListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      This method loads the data for TheSubscriptionType.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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • subscriptionWithNullResponse

      Object subscriptionWithNullResponse(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description for the subscriptionWithNullResponse field:
      Issue 122: Check Subscription behavior when notification response is null
      This method loads the data for TheSubscriptionType.subscriptionWithNullResponse. 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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • enumWithReservedJavaKeywordAsValues

      Object 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 TheSubscriptionType.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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • listOfEnumWithReservedJavaKeywordAsValues

      Object listOfEnumWithReservedJavaKeywordAsValues(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      This method loads the data for TheSubscriptionType.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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • _if

      Object _if(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      This method loads the data for TheSubscriptionType.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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • _implements

      Object _implements(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      This method loads the data for TheSubscriptionType.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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • _null

      Object _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 TheSubscriptionType.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
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • json

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

    • jsons

      Object jsons(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<com.fasterxml.jackson.databind.node.ObjectNode> jsons)
      This method loads the data for TheSubscriptionType.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
      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.
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • jsonsWithInput

      Object jsonsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<SINP_InputWithJson_SINS> input)
      This method loads the data for TheSubscriptionType.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
      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.
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.

    • objectsWithInput

      Object objectsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<SINP_InputWithObject_SINS> input)
      This method loads the data for TheSubscriptionType.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
      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.
      Throws:
      NoSuchElementException - This method may return a NoSuchElementException exception. In this case, the exception is trapped by the calling method, and the return is consider as null. This allows to use the Optional.get() method directly, without caring of whether or not there is a value. The generated code will take care of the NoSuchElementException exception.