Add support for Kotlin suspend functions

Author: varahash

pom.xml

@@ -14,7 +14,7 @@
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <java.version>1.8</java.version>
-        <kotlin.version>1.2.71</kotlin.version>
+        <kotlin.version>1.3.0</kotlin.version>
         <jackson.version>2.9.6</jackson.version>
 
         <maven.compiler.source>${java.version}</maven.compiler.source>
@@ -29,6 +29,16 @@
             <artifactId>kotlin-stdlib</artifactId>
             <version>${kotlin.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-reflect</artifactId>
+            <version>${kotlin.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlinx</groupId>
+            <artifactId>kotlinx-coroutines-jdk8</artifactId>
+            <version>1.0.0</version>
+        </dependency>
         <dependency>
             <groupId>com.graphql-java</groupId>
             <artifactId>graphql-java</artifactId>

src/main/kotlin/com/coxautodev/graphql/tools/FieldResolverScanner.kt

@@ -9,6 +9,8 @@ import org.apache.commons.lang3.reflect.FieldUtils
 import org.slf4j.LoggerFactory
 import java.lang.reflect.Modifier
 import java.lang.reflect.ParameterizedType
+import kotlin.reflect.full.valueParameters
+import kotlin.reflect.jvm.kotlinFunction
 
 /**
  * @author Andrew Potter
@@ -112,7 +114,9 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) {
             true
         }
 
-        val correctParameterCount = method.parameterCount == requiredCount || (method.parameterCount == (requiredCount + 1) && allowedLastArgumentTypes.contains(method.parameterTypes.last()))
+        val correctParameterCount = method.parameterCount == requiredCount ||
+                (method.parameterCount == (requiredCount + 1) && allowedLastArgumentTypes.contains(method.parameterTypes.last())) ||
+                (method.kotlinFunction?.run { isSuspend && valueParameters.size == requiredCount } == true)
         return correctParameterCount && appropriateFirstParameter
     }
 

src/main/kotlin/com/coxautodev/graphql/tools/MethodFieldResolver.kt

@@ -8,10 +8,14 @@ import graphql.language.FieldDefinition
 import graphql.language.NonNullType
 import graphql.schema.DataFetcher
 import graphql.schema.DataFetchingEnvironment
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.future.future
 import java.lang.reflect.Method
-import java.lang.reflect.ParameterizedType
-import java.lang.reflect.TypeVariable
 import java.util.*
+import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
+import kotlin.reflect.full.valueParameters
+import kotlin.reflect.jvm.javaType
+import kotlin.reflect.jvm.kotlinFunction
 
 /**
  * @author Andrew Potter
@@ -31,7 +35,7 @@ internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolver
         }
     }
 
-    private val additionalLastArgument = method.parameterCount == (field.inputValueDefinitions.size + getIndexOffset() + 1)
+    private val additionalLastArgument = method.kotlinFunction?.valueParameters?.size ?: method.parameterCount == (field.inputValueDefinitions.size + getIndexOffset() + 1)
 
     override fun createDataFetcher(): DataFetcher<*> {
         val batched = isBatched(method, search)
@@ -99,7 +103,7 @@ internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolver
 
     override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> {
         val batched = isBatched(method, search)
-        val unwrappedGenericType = genericType.unwrapGenericType(method.genericReturnType)
+        val unwrappedGenericType = genericType.unwrapGenericType(method.kotlinFunction?.returnType?.javaType ?: method.returnType)
         val returnValueMatch = TypeClassMatcher.PotentialMatch.returnValue(field.type, unwrappedGenericType, genericType, SchemaClassScanner.ReturnValueReference(method), batched)
 
         return field.inputValueDefinitions.mapIndexed { i, inputDefinition ->
@@ -136,6 +140,7 @@ open class MethodFieldResolverDataFetcher(private val sourceResolver: SourceReso
     // Convert to reflactasm reflection
     private val methodAccess = MethodAccess.get(method.declaringClass)!!
     private val methodIndex = methodAccess.getIndex(method.name, *method.parameterTypes)
+    private val isSuspendFunction = method.kotlinFunction?.isSuspend == true
 
     private class CompareGenericWrappers {
         companion object : Comparator<GenericWrapper> {
@@ -149,9 +154,18 @@ open class MethodFieldResolverDataFetcher(private val sourceResolver: SourceReso
     override fun get(environment: DataFetchingEnvironment): Any? {
         val source = sourceResolver(environment)
         val args = this.args.map { it(environment) }.toTypedArray()
-        val result = methodAccess.invoke(source, methodIndex, *args)
+
+        val result = if (isSuspendFunction) {
+            GlobalScope.future(options.coroutineContext) {
+                suspendCoroutineUninterceptedOrReturn<Any?> { continuation ->
+                    methodAccess.invoke(source, methodIndex, *args + continuation)
+                }
+            }
+        } else {
+            methodAccess.invoke(source, methodIndex, *args)
+        }
         return if (result == null) {
-            result
+            null
         } else {
             val wrapper = options.genericWrappers
                     .asSequence()

src/main/kotlin/com/coxautodev/graphql/tools/SchemaParserBuilder.kt

@@ -8,13 +8,15 @@ import graphql.language.Document
 import graphql.parser.Parser
 import graphql.schema.DataFetchingEnvironment
 import graphql.schema.GraphQLScalarType
+import kotlinx.coroutines.Dispatchers
 import org.antlr.v4.runtime.RecognitionException
 import org.antlr.v4.runtime.misc.ParseCancellationException
 import org.reactivestreams.Publisher
 import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.CompletionStage
 import java.util.concurrent.Future
+import kotlin.coroutines.CoroutineContext
 import kotlin.reflect.KClass
 
 /**
@@ -247,7 +249,16 @@ class SchemaParserDictionary {
     }
 }
 
-data class SchemaParserOptions internal constructor(val contextClass: Class<*>?, val genericWrappers: List<GenericWrapper>, val allowUnimplementedResolvers: Boolean, val objectMapperProvider: PerFieldObjectMapperProvider, val proxyHandlers: List<ProxyHandler>, val preferGraphQLResolver: Boolean, val introspectionEnabled: Boolean) {
+data class SchemaParserOptions internal constructor(
+        val contextClass: Class<*>?,
+        val genericWrappers: List<GenericWrapper>,
+        val allowUnimplementedResolvers: Boolean,
+        val objectMapperProvider: PerFieldObjectMapperProvider,
+        val proxyHandlers: List<ProxyHandler>,
+        val preferGraphQLResolver: Boolean,
+        val introspectionEnabled: Boolean,
+        val coroutineContext: CoroutineContext
+) {
     companion object {
         @JvmStatic
         fun newOptions() = Builder()
@@ -265,6 +276,7 @@ data class SchemaParserOptions internal constructor(val contextClass: Class<*>?,
         private val proxyHandlers: MutableList<ProxyHandler> = mutableListOf(Spring4AopProxyHandler(), GuiceAopProxyHandler(), JavassistProxyHandler())
         private var preferGraphQLResolver = false
         private var introspectionEnabled = true
+        private var coroutineContext: CoroutineContext? = null
 
         fun contextClass(contextClass: Class<*>) = this.apply {
             this.contextClass = contextClass
@@ -314,6 +326,10 @@ data class SchemaParserOptions internal constructor(val contextClass: Class<*>?,
             this.introspectionEnabled = introspectionEnabled
         }
 
+        fun coroutineContext(context: CoroutineContext) = this.apply {
+            this.coroutineContext = context
+        }
+
         fun build(): SchemaParserOptions {
             val wrappers = if (useDefaultGenericWrappers) {
                 genericWrappers + listOf(
@@ -326,7 +342,9 @@ data class SchemaParserOptions internal constructor(val contextClass: Class<*>?,
                 genericWrappers
             }
 
-            return SchemaParserOptions(contextClass, wrappers, allowUnimplementedResolvers, objectMapperProvider, proxyHandlers, preferGraphQLResolver, introspectionEnabled)
+            return SchemaParserOptions(contextClass, wrappers, allowUnimplementedResolvers, objectMapperProvider,
+                    proxyHandlers, preferGraphQLResolver, introspectionEnabled,
+                    coroutineContext ?: Dispatchers.Default)
         }
     }
 

src/test/groovy/com/coxautodev/graphql/tools/EndToEndSpec.groovy

@@ -560,4 +560,21 @@ class EndToEndSpec extends Specification {
         then:
             data.dataFetcherResult.name == "item1"
     }
+
+    def "generated schema supports Kotlin suspend functions"() {
+        when:
+        def data = Utils.assertNoGraphQlErrors(gql) {
+            '''
+                {
+                    coroutineItems {
+                        id
+                        name
+                    }
+                }
+                '''
+        }
+
+        then:
+        data.coroutineItems == [[id:0, name:"item1"], [id:1, name:"item2"]]
+    }
 }

src/test/kotlin/com/coxautodev/graphql/tools/EndToEndSpec.kt

@@ -7,6 +7,7 @@ import graphql.language.StringValue
 import graphql.schema.Coercing
 import graphql.schema.DataFetchingEnvironment
 import graphql.schema.GraphQLScalarType
+import kotlinx.coroutines.CompletableDeferred
 import org.reactivestreams.Publisher
 import java.util.Optional
 import java.util.UUID
@@ -73,6 +74,8 @@ type Query {
 
     propertyField: String!
     dataFetcherResult: Item!
+
+    coroutineItems: [Item!]!
 }
 
 type ExtendedType {
@@ -268,12 +271,13 @@ class Query: GraphQLQueryResolver, ListListResolver<String>() {
     fun propertyMapWithComplexItems() = propertyMapWithComplexItems
     fun propertyMapWithNestedComplexItems() = propertyMapWithNestedComplexItems
 
-
     private val propertyField = "test"
 
     fun dataFetcherResult(): DataFetcherResult<Item> {
         return DataFetcherResult(items.first(), listOf())
     }
+
+    suspend fun coroutineItems(): List<Item> = CompletableDeferred(items).await()
 }
 
 class UnusedRootResolver: GraphQLQueryResolver

src/test/kotlin/com/coxautodev/graphql/tools/MethodFieldResolverDataFetcherTest.kt

@@ -0,0 +1,83 @@
+package com.coxautodev.graphql.tools
+
+import graphql.ExecutionResult
+import graphql.execution.*
+import graphql.execution.instrumentation.SimpleInstrumentation
+import graphql.language.FieldDefinition
+import graphql.language.InputValueDefinition
+import graphql.language.TypeName
+import graphql.schema.DataFetcher
+import graphql.schema.DataFetchingEnvironment
+import graphql.schema.DataFetchingEnvironmentBuilder
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import org.junit.Assert
+import org.junit.Test
+import java.util.concurrent.CompletableFuture
+import kotlin.coroutines.coroutineContext
+
+class MethodFieldResolverDataFetcherTest {
+    @Test
+    fun `data fetcher executes suspend function on coroutineContext defined by options`() {
+        // setup
+        val dispatcher = Dispatchers.IO
+        val job = Job()
+        val options = SchemaParserOptions.Builder()
+                .coroutineContext(dispatcher + job)
+                .build()
+
+        val resolver = createFetcher("active", object : GraphQLResolver<DataClass> {
+            suspend fun isActive(data: DataClass): Boolean {
+                return coroutineContext[dispatcher.key] == dispatcher &&
+                        coroutineContext[Job] == job.children.first()
+            }
+        }, options = options)
+
+        // expect
+        @Suppress("UNCHECKED_CAST")
+        val future = resolver.get(createEnvironment(DataClass())) as CompletableFuture<Boolean>
+        Assert.assertTrue(future.get())
+    }
+
+    private fun createFetcher(
+            methodName: String,
+            resolver: GraphQLResolver<*>,
+            arguments: List<InputValueDefinition> = emptyList(),
+            options: SchemaParserOptions = SchemaParserOptions.defaultOptions()
+    ): DataFetcher<*> {
+        val field = FieldDefinition(methodName, TypeName("Boolean")).apply { inputValueDefinitions.addAll(arguments) }
+        val resolverInfo = if (resolver is GraphQLQueryResolver) {
+            RootResolverInfo(listOf(resolver), options)
+        } else {
+            NormalResolverInfo(resolver, options)
+        }
+        return FieldResolverScanner(options).findFieldResolver(field, resolverInfo).createDataFetcher()
+    }
+
+    private fun createEnvironment(source: Any, arguments: Map<String, Any> = emptyMap(), context: Any? = null): DataFetchingEnvironment {
+        return DataFetchingEnvironmentBuilder.newDataFetchingEnvironment()
+                .source(source)
+                .arguments(arguments)
+                .context(context)
+                .executionContext(buildExecutionContext())
+                .build()
+    }
+
+    private fun buildExecutionContext(): ExecutionContext {
+        val executionStrategy = object : ExecutionStrategy() {
+            override fun execute(executionContext: ExecutionContext, parameters: ExecutionStrategyParameters): CompletableFuture<ExecutionResult> {
+                throw AssertionError("should not be called")
+            }
+        }
+        val executionId = ExecutionId.from("executionId123")
+        return ExecutionContextBuilder.newExecutionContextBuilder()
+                .instrumentation(SimpleInstrumentation.INSTANCE)
+                .executionId(executionId)
+                .queryStrategy(executionStrategy)
+                .mutationStrategy(executionStrategy)
+                .subscriptionStrategy(executionStrategy)
+                .build()
+    }
+
+    data class DataClass(val name: String = "TestName")
+}