Add support to unwrap CompletableFuture and override with config (#11)

Author: brennantaylor

example/pom.xml

@@ -5,7 +5,7 @@
 
     <groupId>com.expedia.www</groupId>
     <artifactId>graphql-kotlin-example</artifactId>
-    <version>0.0.8-SNAPSHOT</version>
+    <version>0.0.1-SNAPSHOT</version>
     <name>graphql-kotlin-example</name>
     <description>Example SpringBoot app using graphql-kotlin</description>
     <url>https://github.com/ExpediaDotCom/graphql-kotlin</url>

example/src/main/kotlin/com.expedia.graphql.sample/query/AsyncQuery.kt

@@ -0,0 +1,24 @@
+package com.expedia.graphql.sample.query
+
+import com.expedia.graphql.annotations.GraphQLDescription
+import org.springframework.stereotype.Component
+import java.util.concurrent.CompletableFuture
+
+/**
+ * Example async queries.
+ */
+@Component
+class AsyncQuery : Query {
+
+    @GraphQLDescription("Delays for given amount and then echos the string back."
+            + " The default async executor will work with CompletableFuture."
+            + " To use other rx frameworks you'll need to install a custom one to handle the types correctly.")
+    fun delayedEchoUsingCompletableFuture(msg: String, delaySeconds: Int): CompletableFuture<String> {
+        val future = CompletableFuture<String>()
+        Thread {
+            Thread.sleep(delaySeconds * 1000L)
+            future.complete(msg)
+        }.start()
+        return future
+    }
+}

pom.xml

@@ -162,6 +162,12 @@
             <version>${junit.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>io.reactivex.rxjava2</groupId>
+            <artifactId>rxjava</artifactId>
+            <version>2.1.0</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <profiles>

src/main/kotlin/com/expedia/graphql/schema/SchemaGenerator.kt

@@ -130,7 +130,7 @@ internal class SchemaGenerator(
             val hookDataFetcher = config.hooks.didGenerateDataFetcher(fn, dataFetcher)
             builder.dataFetcher(hookDataFetcher)
         }
-        builder.type(graphQLTypeOf(fn.returnType) as GraphQLOutputType)
+        builder.type(graphQLTypeOf(config.monadResolver(fn.returnType)) as GraphQLOutputType)
         return builder.build()
     }
 

src/main/kotlin/com/expedia/graphql/schema/SchemaGeneratorConfig.kt

@@ -2,7 +2,7 @@ package com.expedia.graphql.schema
 
 import com.expedia.graphql.schema.hooks.NoopSchemaGeneratorHooks
 import com.expedia.graphql.schema.hooks.SchemaGeneratorHooks
-import graphql.schema.GraphQLDirective
+import kotlin.reflect.KType
 
 /**
  * Settings for generating the schema.
@@ -11,5 +11,6 @@ data class SchemaGeneratorConfig(
     val supportedPackages: String,
     val topLevelQueryName: String = "TopLevelQuery",
     val topLevelMutationName: String = "TopLevelMutation",
-    val hooks: SchemaGeneratorHooks = NoopSchemaGeneratorHooks()
+    val hooks: SchemaGeneratorHooks = NoopSchemaGeneratorHooks(),
+    val monadResolver: (KType) -> KType = completableFutureResolver
 )

src/main/kotlin/com/expedia/graphql/schema/typeMappers.kt

@@ -6,6 +6,7 @@ import graphql.schema.GraphQLNonNull
 import graphql.schema.GraphQLType
 import java.math.BigDecimal
 import java.math.BigInteger
+import java.util.concurrent.CompletableFuture
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
 
@@ -35,3 +36,11 @@ internal fun getGraphQLClassName(klass: KClass<*>, inputClass: Boolean): String?
 }
 
 private fun getInputClassName(className: String?) = "${className}Input"
+
+internal val completableFutureResolver = { type: KType ->
+    if (type.classifier == CompletableFuture::class) {
+        type.arguments.firstOrNull()?.type ?: type
+    } else {
+        type
+    }
+}

src/test/kotlin/com/expedia/graphql/schema/SchemaGeneratorAsyncTests.kt

@@ -0,0 +1,76 @@
+package com.expedia.graphql.schema
+
+import com.expedia.graphql.TopLevelObjectDef
+import com.expedia.graphql.toSchema
+import graphql.schema.GraphQLNonNull
+import io.reactivex.Maybe
+import io.reactivex.Observable
+import io.reactivex.Single
+import java.util.concurrent.CompletableFuture
+import kotlin.reflect.KType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class SchemaGeneratorAsyncTests {
+
+    private val rxJavaMonadResolver: (KType) -> KType = { type ->
+        when (type.classifier) {
+            Observable::class, Single::class, Maybe::class -> type.arguments.firstOrNull()?.type
+            else -> type
+        } ?: type
+    }
+    private val testSchemaConfigWithRxJavaMonads =
+        SchemaGeneratorConfig(supportedPackages = "com.expedia", monadResolver = rxJavaMonadResolver)
+
+    @Test
+    fun `SchemaGenerator strips type argument from CompletableFuture to support async servlet`() {
+        val schema = toSchema(listOf(TopLevelObjectDef(AsyncQuery())), config = testSchemaConfig)
+        val returnTypeName =
+            (schema.getObjectType("TopLevelQuery").getFieldDefinition("asynchronouslyDo").type as GraphQLNonNull).wrappedType.name
+        assertEquals("Int", returnTypeName)
+    }
+
+    @Test
+    fun `SchemaGenerator strips type argument from RxJava2 Observable`() {
+        val schema = toSchema(listOf(TopLevelObjectDef(RxJava2Query())), config = testSchemaConfigWithRxJavaMonads)
+        val returnTypeName =
+            (schema.getObjectType("TopLevelQuery").getFieldDefinition("asynchronouslyDo").type as GraphQLNonNull).wrappedType.name
+        assertEquals("Int", returnTypeName)
+    }
+
+    @Test
+    fun `SchemaGenerator strips type argument from RxJava2 Single`() {
+        val schema = toSchema(listOf(TopLevelObjectDef(RxJava2Query())), config = testSchemaConfigWithRxJavaMonads)
+        val returnTypeName =
+            (schema.getObjectType("TopLevelQuery").getFieldDefinition("asynchronouslyDoSingle").type as GraphQLNonNull).wrappedType.name
+        assertEquals("Int", returnTypeName)
+    }
+
+    @Test
+    fun `SchemaGenerator strips type argument from RxJava2 Maybe`() {
+        val schema = toSchema(listOf(TopLevelObjectDef(RxJava2Query())), config = testSchemaConfigWithRxJavaMonads)
+        val returnTypeName =
+            (schema.getObjectType("TopLevelQuery").getFieldDefinition("maybe").type as GraphQLNonNull).wrappedType.name
+        assertEquals("Int", returnTypeName)
+    }
+
+    class AsyncQuery {
+        fun asynchronouslyDo(): CompletableFuture<Int> {
+            return CompletableFuture.completedFuture(1)
+        }
+    }
+
+    class RxJava2Query {
+        fun asynchronouslyDo(): Observable<Int> {
+            return Observable.just(1)
+        }
+
+        fun asynchronouslyDoSingle(): Single<Int> {
+            return Single.just(1)
+        }
+
+        fun maybe(): Maybe<Int> {
+            return Maybe.empty()
+        }
+    }
+}