[server] spring aware data fetcher (#813)

* [server] spring aware data fetcher

Create new `SpringDataFetcher` that automatically resolves Spring `@Autowired` beans that are specified as function arguments.

```kotlin
class SpringQuery : Query {
    fun getWidget(@GraphQLIgnore @Autowired repository: WidgetRepository, id: Int): Widget = repository.findWidget(id)
}
```

NOTE: `@Autowired` arguments should be explicitly excluded from the GraphQL schema by also specifying `@GraphQLIgnore`.

* examples

* documentation

* update spring bean docs

* update junit

* fix docs

Author: dariuszkuc

docs/schema-generator/writing-schemas/arguments.md

@@ -21,7 +21,7 @@ type Query {
 
 This behavior is true for all arguments except for the special classes for the [GraphQLContext](../execution/contextual-data) and the [DataFetchingEnvironment](../execution/data-fetching-environment)
 
-### Input Types
+## Input Types
 
 Query and mutation function arguments are automatically converted to corresponding GraphQL input fields. GraphQL makes a
 distinction between input and output types and requires unique names for all the types. Since we can use the same
@@ -69,7 +69,7 @@ If you know a type will only be used for input types you can call your class som
 append `Input` if the class name already ends with `Input` but that means you can not use this type as output because
 the schema would have two types with the same name and that would be invalid.
 
-### Optional input fields
+## Optional input fields
 
 Kotlin requires variables/values to be initialized upon their declaration either from the user input OR by providing
 defaults (even if they are marked as nullable). Therefore in order for a GraphQL input field to be optional it needs to be
@@ -82,12 +82,16 @@ fun doSomethingWithOptionalInput(requiredValue: Int, optionalValue: Int?) = "req
 NOTE: Non nullable input fields will always require users to specify the value regardless of whether a default Kotlin value
 is provided or not.
 
-NOTE: Even though you could specify a default value in Kotlin `optionalValue: Int? = null`, this will not be used. This is because
-if no value is provided to the schema, `graphql-java` passes null as the value. The Kotlin default value will never be
-used. For example, with argument `optionalList: List<Int>? = emptyList()`, the value will be null if not passed a value by
-the client.
+NOTE: Even though you could specify a default values for arguments in Kotlin `optionalValue: Int? = null`, this will not
+be used. If query does not explicitly specify root argument values, our function data fetcher will default to use null as
+the value. This is because Kotlin properties always have to be initialized, and we cannot determine whether underlying
+argument has default value or not. As a result, Kotlin default value will never be used. For example, with argument
+`optionalList: List<Int>? = emptyList()`, the value will be null if not passed a value by the client.
 
-### Default values
+See [optional undefined arguments](../execution/optional-undefined-arguments) for details how to determine whether argument
+was specified or not.
 
-Default argument values are currently not supported. See issue
-[#53](https://github.com/ExpediaGroup/graphql-kotlin/issues/53) for more details.
+## Default values
+
+Default argument values are currently not supported. See issue [#53](https://github.com/ExpediaGroup/graphql-kotlin/issues/53)
+for more details.

docs/schema-generator/writing-schemas/nested-arguments.md

@@ -1,9 +1,9 @@
 ---
 id: nested-arguments
-title: Nested Arguments
+title: Nested Resolvers and Shared Arguments
 ---
 
-There are a few ways in which you can access data in a query from different levels of arguments. Say we have the following schema:
+There are a few ways in which shared arguments can be accessed from different resolver levels. Say we have the following schema:
 
 ```graphql
 type Query {
@@ -19,13 +19,14 @@ type Photo {
 }
 ```
 
-In Kotlin code, when we are in the `photos` function, if we want access to the parent field `findUser` and its
-arguments there are a couple ways we can access it:
+In Kotlin code, when we are resolving  `photos`, if we want access to the parent field `findUser` and its arguments there
+are a couple ways we can access it:
 
 
 ## DataFetchingEnvironment
-You can add the `DataFetchingEnvironment` as an argument. This class will be ignored by the schema generator and will allow you to view the entire query sent to the
-  server. See more in the [DataFetchingEnvironment documentation](../execution/data-fetching-environment)
+
+You can add the `DataFetchingEnvironment` as an argument. This class will be ignored by the schema generator and will allow
+you to view the entire query sent to the server. See more in the [DataFetchingEnvironment documentation](../execution/data-fetching-environment)
 
 ```kotlin
 class User {
@@ -37,8 +38,9 @@ class User {
 ```
 
 ## GraphQL Context
-You can add the `GraphQLContext` as an argument. This class will be ignored by the schema generator and will allow you to view the context object you set up in the
-  data fetchers. See more in the [GraphQLContext documentation](../execution/contextual-data)
+
+You can add the `GraphQLContext` as an argument. This class will be ignored by the schema generator and will allow you to
+view the context object you set up in the data fetchers. See more in the [GraphQLContext documentation](../execution/contextual-data)
 
 ```kotlin
 class User {
@@ -49,7 +51,7 @@ class User {
 }
 ```
 
-## Excluding from the Schema
+## Excluding Arguments from the Schema
 You can construct the child objects by passing down arguments as non-public fields or annotate the argument with [@GraphQLIgnore](../customizing-schemas/excluding-fields)
 
 ```kotlin
@@ -65,35 +67,6 @@ class User(private val userId: String) {
 }
 ```
 
-## Spring BeanFactoryAware
-You can use Spring beans to wire different objects together at runtime.
-There is an example of how to set this up in the example app in [TopLevelBeanFactoryQuery.kt](https://github.com/ExpediaGroup/graphql-kotlin/blob/master/examples/spring/src/main/kotlin/com/expediagroup/graphql/examples/query/TopLevelBeanFactoryQuery.kt)
-
-```kotlin
-@Component
-class UsersQuery : Query, BeanFactoryAware {
-    private lateinit var beanFactory: BeanFactory
-
-    @GraphQLIgnore
-    override fun setBeanFactory(beanFactory: BeanFactory) {
-        this.beanFactory = beanFactory
-    }
-
-    fun findUser(id: String): SubQuery = beanFactory.getBean(User::class.java, id)
-}
-
-@Component
-@Scope("prototype")
-class User @Autowired(required = false) constructor(private val userId: String) {
-
-    @Autowired
-    private lateinit var service: PhotoService
-
-    fun photos(numberOfPhotos: Int): List<Photo> = service.findPhotos(userId, numberOfPhotos)
-}
-```
-
-------
+## Spring Integration
 
-We have examples of these techniques implemented in Spring boot in the [example
-app](https://github.com/ExpediaGroup/graphql-kotlin/blob/master/examples/spring/src/main/kotlin/com/expediagroup/graphql/examples/query/NestedQueries.kt).
+See [Writing Schemas with Spring](../../spring-server/spring-schema.md) for integration details.

docs/spring-server/spring-beans.md

@@ -14,7 +14,7 @@ can be customized by providing custom beans in your application context. See sec
 | FederatedSchemaGeneratorConfig | Federated schema generator configuration information. You can customize the configuration by providing `TopLevelNames`, `FederatedSchemaGeneratorHooks` and `KotlinDataFetcherFactoryProvider` beans.<br><br>_Created instead of default `SchemaGeneratorConfig` if federation is enabled_. |
 | FederatedTypeRegistry          | Default type registry without any resolvers. See [Federated Type Resolution](../federated/type-resolution.md) for more details.<br><br>_Created only if federation is enabled. You should register your custom type registry bean whenever implementing federated GraphQL schema with extended types_. |
 | GraphQLSchema                  | GraphQL schema generated based on the schema generator configuration and  `Query`, `Mutation` and `Subscription` objects available in the application context. |
-| KotlinDataFetcherFactoryProvider | Factory used during schema construction to obtain `DataFetcherFactory` that should be used for target function and property resolution.|
+| KotlinDataFetcherFactoryProvider | Factory used during schema construction to obtain `DataFetcherFactory` that should be used for target function (using Spring aware `SpringDataFetcher`) and property resolution. |
 | SchemaGeneratorConfig          | Schema generator configuration information, see [Schema Generator Configuration](../schema-generator/customizing-schemas/generator-config.md) for details. Can be customized by providing `TopLevelNames`, [SchemaGeneratorHooks](../schema-generator/customizing-schemas/generator-config.md) and `KotlinDataFetcherFactoryProvider` beans. |
 
 ## Execution

docs/spring-server/spring-overview.md

@@ -88,7 +88,7 @@ type Query {
 }
 
 type Mutation {
-  myAwesomeMutation(widget: Widget!): Widget!
+  myAwesomeMutation(widget: WidgetInput!): Widget!
 }
 
 type Subscription {
@@ -99,6 +99,11 @@ type Widget {
   id: Int!
   value: String!
 }
+
+input WidgetInput {
+  id: Int!
+  value: String!
+}
 ```
 
 ## Default Routes

docs/spring-server/spring-schema.md

@@ -0,0 +1,120 @@
+---
+id: spring-schema
+title: Writing Schemas with Spring
+---
+
+In order to expose your queries, mutations and/or subscriptions in the GraphQL schema you simply need to create beans that
+implement corresponding marker interface and they will be automatically picked up by `graphql-kotlin-spring-server`
+auto-configuration library.
+
+```kotlin
+@Component
+class MyAwesomeQuery : Query {
+  fun myAwesomeQuery(): Widget { ... }
+}
+
+@Component
+class MyAwesomeMutation : Mutation {
+  fun myAwesomeMutation(widget: Widget): Widget { ... }
+}
+
+@Component
+class MyAwesomeSubscription : Subscription {
+  fun myAwesomeSubscription(): Publisher<Widget> { ... }
+}
+
+data class Widget(val id: Int, val value: String)
+```
+
+will result in a Spring Boot reactive GraphQL web application with following schema.
+
+```graphql
+schema {
+  query: Query
+  mutation: Mutation
+  subscription: Subscription
+}
+
+type Query {
+  myAwesomeQuery: Widget!
+}
+
+type Mutation {
+  myAwesomeMutation(widget: WidgetInput!): Widget!
+}
+
+type Subscription {
+  myAwesomeSubscription: Widget!
+}
+
+type Widget {
+  id: Int!
+  value: String!
+}
+
+input WidgetInput {
+  id: Int!
+  value: String!
+}
+```
+
+## Spring Query Beans
+
+Spring will automatically autowire dependent beans to our Spring query beans. Refer to [Spring Documentation](https://docs.spring.io/spring/docs/current/spring-framework-reference/) for details.
+
+```kotlin
+@Component
+class WidgetQuery(private val repository: WidgetRepository) : Query {
+    fun getWidget(id: Int): Widget = repository.findWidget(id)
+}
+```
+
+## Spring Data Fetcher
+
+`graphql-kotlin-spring-server` provides Spring aware data fetcher that automatically autowires Spring beans when they are
+specified as function arguments. `@Autowired` arguments should be explicitly excluded from the GraphQL schema by also
+specifying `@GraphQLIgnore`.
+
+```kotlin
+@Component
+class SpringQuery : Query {
+    fun getWidget(@GraphQLIgnore @Autowired repository: WidgetRepository, id: Int): Widget = repository.findWidget(id)
+}
+```
+
+> NOTE: if you are using custom data fetcher make sure that you extend `SpringDataFetcher` instead of a base `FunctionDataFetcher`.
+
+## Spring BeanFactoryAware
+
+You can use Spring beans to wire different objects together at runtime. Instead of autowiring specific beans as properties,
+you can also dynamically resolve beans by using bean factories. There is an example of how to set this up in the example
+app in the [TopLevelBeanFactoryQuery.kt](https://github.com/ExpediaGroup/graphql-kotlin/blob/master/examples/spring/src/main/kotlin/com/expediagroup/graphql/examples/query/TopLevelBeanFactoryQuery.kt).
+
+```kotlin
+@Component
+class UsersQuery : Query, BeanFactoryAware {
+    private lateinit var beanFactory: BeanFactory
+
+    @GraphQLIgnore
+    override fun setBeanFactory(beanFactory: BeanFactory) {
+        this.beanFactory = beanFactory
+    }
+
+    fun findUser(id: String): SubQuery = beanFactory.getBean(User::class.java, id)
+}
+
+@Component
+@Scope("prototype")
+class User @Autowired(required = false) constructor(private val userId: String) {
+
+    @Autowired
+    private lateinit var service: PhotoService
+
+    fun photos(numberOfPhotos: Int): List<Photo> = service.findPhotos(userId, numberOfPhotos)
+}
+```
+
+------
+
+We have examples of these techniques implemented in Spring boot in the [example
+app](https://github.com/ExpediaGroup/graphql-kotlin/blob/master/examples/spring/src/main/kotlin/com/expediagroup/graphql/examples/query/NestedQueries.kt).

examples/spring/src/main/kotlin/com/expediagroup/graphql/examples/Application.kt

@@ -28,6 +28,7 @@ import com.fasterxml.jackson.databind.ObjectMapper
 import graphql.execution.DataFetcherExceptionHandler
 import org.springframework.boot.autoconfigure.SpringBootApplication
 import org.springframework.boot.runApplication
+import org.springframework.context.ApplicationContext
 import org.springframework.context.annotation.Bean
 
 @SpringBootApplication
@@ -40,8 +41,11 @@ class Application {
     fun hooks(wiringFactory: KotlinDirectiveWiringFactory) = CustomSchemaGeneratorHooks(wiringFactory)
 
     @Bean
-    fun dataFetcherFactoryProvider(springDataFetcherFactory: SpringDataFetcherFactory, objectMapper: ObjectMapper) =
-        CustomDataFetcherFactoryProvider(springDataFetcherFactory, objectMapper)
+    fun dataFetcherFactoryProvider(
+        springDataFetcherFactory: SpringDataFetcherFactory,
+        objectMapper: ObjectMapper,
+        applicationContext: ApplicationContext
+    ) = CustomDataFetcherFactoryProvider(springDataFetcherFactory, objectMapper, applicationContext)
 
     @Bean
     fun dataFetcherExceptionHandler(): DataFetcherExceptionHandler = CustomDataFetcherExceptionHandler()

examples/spring/src/main/kotlin/com/expediagroup/graphql/examples/dataloaders/DataLoaderConfiguration.kt

@@ -1,16 +1,17 @@
 package com.expediagroup.graphql.examples.dataloaders
 
-import com.expediagroup.graphql.examples.model.Company
-import com.expediagroup.graphql.examples.query.CompanyService
+import com.expediagroup.graphql.examples.query.Company
 import com.expediagroup.graphql.spring.execution.DataLoaderRegistryFactory
 import org.dataloader.DataLoader
 import org.dataloader.DataLoaderRegistry
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
+import org.springframework.stereotype.Component
 import java.util.concurrent.CompletableFuture
 
 @Configuration
 class DataLoaderConfiguration(private val companyService: CompanyService) {
+
     @Bean
     fun dataLoaderRegistryFactory(): DataLoaderRegistryFactory {
         return object : DataLoaderRegistryFactory {
@@ -25,3 +26,13 @@ class DataLoaderConfiguration(private val companyService: CompanyService) {
         }
     }
 }
+
+@Component
+class CompanyService {
+    private val companies = listOf(
+        Company(id = 1, name = "FirstCompany"),
+        Company(id = 2, name = "SecondCompany")
+    )
+
+    fun getCompanies(ids: List<Int>): List<Company> = companies
+}

examples/spring/src/main/kotlin/com/expediagroup/graphql/examples/execution/CustomDataFetcherFactoryProvider.kt

@@ -19,6 +19,7 @@ package com.expediagroup.graphql.examples.execution
 import com.expediagroup.graphql.execution.SimpleKotlinDataFetcherFactoryProvider
 import com.fasterxml.jackson.databind.ObjectMapper
 import graphql.schema.DataFetcherFactory
+import org.springframework.context.ApplicationContext
 import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
 import kotlin.reflect.KProperty
@@ -28,14 +29,16 @@ import kotlin.reflect.KProperty
  */
 class CustomDataFetcherFactoryProvider(
     private val springDataFetcherFactory: SpringDataFetcherFactory,
-    private val objectMapper: ObjectMapper
+    private val objectMapper: ObjectMapper,
+    private val applicationContext: ApplicationContext
 ) : SimpleKotlinDataFetcherFactoryProvider(objectMapper) {
 
     override fun functionDataFetcherFactory(target: Any?, kFunction: KFunction<*>) = DataFetcherFactory {
         CustomFunctionDataFetcher(
             target = target,
             fn = kFunction,
-            objectMapper = objectMapper
+            objectMapper = objectMapper,
+            appContext = applicationContext
         )
     }
 

examples/spring/src/main/kotlin/com/expediagroup/graphql/examples/execution/CustomFunctionDataFetcher.kt

@@ -16,16 +16,22 @@
 
 package com.expediagroup.graphql.examples.execution
 
-import com.expediagroup.graphql.execution.FunctionDataFetcher
+import com.expediagroup.graphql.spring.execution.SpringDataFetcher
 import com.fasterxml.jackson.databind.ObjectMapper
 import graphql.schema.DataFetchingEnvironment
+import org.springframework.context.ApplicationContext
 import reactor.core.publisher.Mono
 import kotlin.reflect.KFunction
 
 /**
  * Custom function data fetcher that adds support for Reactor Mono.
  */
-class CustomFunctionDataFetcher(target: Any?, fn: KFunction<*>, objectMapper: ObjectMapper) : FunctionDataFetcher(target, fn, objectMapper) {
+class CustomFunctionDataFetcher(
+    target: Any?,
+    fn: KFunction<*>,
+    objectMapper: ObjectMapper,
+    appContext: ApplicationContext
+) : SpringDataFetcher(target, fn, objectMapper, appContext) {
 
     override fun get(environment: DataFetchingEnvironment): Any? = when (val result = super.get(environment)) {
         is Mono<*> -> result.toFuture()