Package org.allGraphQLCases.server.impl

Class DataFetchersDelegateTheSubscriptionTypeImpl

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

  • Constructor Details

    • DataFetchersDelegateTheSubscriptionTypeImpl

      public DataFetchersDelegateTheSubscriptionTypeImpl()

  • Method Details

    • subscribeNewHumanForEpisode

      public reactor.core.publisher.Flux<STP_Human_STS> subscribeNewHumanForEpisode(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SEP_Episode_SES SEP_Episode_SES)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      subscribeNewHumanForEpisode in interface DataFetchersDelegateTheSubscriptionType
      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.

    • subscribeToAList

      public reactor.core.publisher.Flux<List<Integer>> subscribeToAList(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      subscribeToAList in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • issue53

      public reactor.core.publisher.Flux<Date> issue53(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, Date date)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      issue53 in interface DataFetchersDelegateTheSubscriptionType
      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.

    • subscriptionTest

      public reactor.core.publisher.Flux<String> subscriptionTest(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_SubscriptionTestParam_SINS param)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      subscriptionTest in interface DataFetchersDelegateTheSubscriptionType
      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.

    • allGraphQLCasesInput

      public reactor.core.publisher.Flux<STP_AllFieldCases_STS> allGraphQLCasesInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SINP_AllFieldCasesInput_SINS input)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      allGraphQLCasesInput in interface DataFetchersDelegateTheSubscriptionType
      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.

    • allGraphQLCasesParam

      public reactor.core.publisher.Flux<STP_AllFieldCases_STS> 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)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      allGraphQLCasesParam in interface DataFetchersDelegateTheSubscriptionType
      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.

    • subscriptionWithNullResponse

      public reactor.core.publisher.Flux<Optional<String>> subscriptionWithNullResponse(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      subscriptionWithNullResponse in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • subscribeToAListOfScalars

      public reactor.core.publisher.Flux<Optional<List<Date>>> subscribeToAListOfScalars(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Returns a Flux, that will produce a list of two random dates, every 0.1s
      Specified by:
      subscribeToAListOfScalars in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _if

      public reactor.core.publisher.Flux<Optional<String>> _if(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      _if in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _implements

      public reactor.core.publisher.Flux<Optional<String>> _implements(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      _implements in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • enumWithReservedJavaKeywordAsValues

      public org.reactivestreams.Publisher<Optional<SEP_EnumWithReservedJavaKeywordAsValues_SES>> enumWithReservedJavaKeywordAsValues(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      enumWithReservedJavaKeywordAsValues in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • listOfEnumWithReservedJavaKeywordAsValues

      public reactor.core.publisher.Flux<Optional<List<SEP_EnumWithReservedJavaKeywordAsValues_SES>>> listOfEnumWithReservedJavaKeywordAsValues(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      listOfEnumWithReservedJavaKeywordAsValues in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnEnum

      public reactor.core.publisher.Flux<Optional<SEP_EnumWithReservedJavaKeywordAsValues_SES>> returnEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      returnEnum in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnMandatoryEnum

      public reactor.core.publisher.Flux<SEP_EnumWithReservedJavaKeywordAsValues_SES> returnMandatoryEnum(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, SEP_EnumWithReservedJavaKeywordAsValues_SES _enum)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      returnMandatoryEnum in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnListOfEnums

      public reactor.core.publisher.Flux<Optional<List<SEP_EnumWithReservedJavaKeywordAsValues_SES>>> returnListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      returnListOfEnums in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnListOfMandatoryEnums

      public reactor.core.publisher.Flux<Optional<List<SEP_EnumWithReservedJavaKeywordAsValues_SES>>> returnListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      returnListOfMandatoryEnums in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnListOfListOfEnums

      public reactor.core.publisher.Flux<Optional<List<List<SEP_EnumWithReservedJavaKeywordAsValues_SES>>>> returnListOfListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      returnListOfListOfEnums in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnMandatoryListOfEnums

      public reactor.core.publisher.Flux<List<SEP_EnumWithReservedJavaKeywordAsValues_SES>> returnMandatoryListOfEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      returnMandatoryListOfEnums in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • returnMandatoryListOfMandatoryEnums

      public reactor.core.publisher.Flux<List<SEP_EnumWithReservedJavaKeywordAsValues_SES>> returnMandatoryListOfMandatoryEnums(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      returnMandatoryListOfMandatoryEnums in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • _null

      public org.reactivestreams.Publisher<Optional<String>> _null(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      _null in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher

    • json

      public org.reactivestreams.Publisher<Optional<com.fasterxml.jackson.databind.node.ObjectNode>> json(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, com.fasterxml.jackson.databind.node.ObjectNode jsonParam)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      json in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      jsonParam - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • jsons

      public org.reactivestreams.Publisher<Optional<List<com.fasterxml.jackson.databind.node.ObjectNode>>> jsons(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<com.fasterxml.jackson.databind.node.ObjectNode> jsonsParam)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      jsons in interface DataFetchersDelegateTheSubscriptionType
      Parameters:
      dataFetchingEnvironment - The GraphQL DataFetchingEnvironment. It gives you access to the full GraphQL context for this DataFetcher
      jsonsParam - The input parameter sent in the query by the GraphQL consumer, as defined in the GraphQL schema.

    • jsonsWithInput

      public org.reactivestreams.Publisher<List<STP_TypeWithJson_STS>> jsonsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<SINP_InputWithJson_SINS> input)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      jsonsWithInput in interface DataFetchersDelegateTheSubscriptionType
      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 org.reactivestreams.Publisher<List<STP_TypeWithObject_STS>> objectsWithInput(graphql.schema.DataFetchingEnvironment dataFetchingEnvironment, List<SINP_InputWithObject_SINS> input)
      Description copied from interface: DataFetchersDelegateTheSubscriptionType
      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
      Specified by:
      objectsWithInput in interface DataFetchersDelegateTheSubscriptionType
      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.