feat: move the default handling of CompletableFuture to code (#166)

This will have no impact on existing clients. I just moved the handling of CompletableFutures into the code so that it will always happen. Right now, clients need to remember to still handle CompletableFutures if they override the  hook.

We now resolve the type from the hook first, which defaults to the same type. Then we check after if it is on of the default supported wrapped types which right now only include CompletableFuture, but will extend to Publisher when we support subscriptions

Author: smyrick

src/main/kotlin/com/expedia/graphql/generator/types/FunctionTypeBuilder.kt

@@ -6,14 +6,17 @@ import com.expedia.graphql.generator.TypeBuilder
 import com.expedia.graphql.generator.extensions.getDeprecationReason
 import com.expedia.graphql.generator.extensions.getGraphQLDescription
 import com.expedia.graphql.generator.extensions.getName
+import com.expedia.graphql.generator.extensions.getTypeOfFirstArgument
 import com.expedia.graphql.generator.extensions.isGraphQLContext
 import com.expedia.graphql.generator.extensions.isInterface
 import graphql.schema.GraphQLArgument
 import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.GraphQLInputType
 import graphql.schema.GraphQLOutputType
+import java.util.concurrent.CompletableFuture
 import kotlin.reflect.KFunction
 import kotlin.reflect.KParameter
+import kotlin.reflect.KType
 import kotlin.reflect.full.valueParameters
 
 @Suppress("Detekt.UnsafeCast")
@@ -43,12 +46,20 @@ internal class FunctionTypeBuilder(generator: SchemaGenerator) : TypeBuilder(gen
             builder.dataFetcherFactory(config.dataFetcherFactoryProvider.functionDataFetcherFactory(target = target, kFunction = fn))
         }
 
-        val monadType = config.hooks.willResolveMonad(fn.returnType)
-        builder.type(graphQLTypeOf(monadType) as GraphQLOutputType)
+        val typeFromHooks = config.hooks.willResolveMonad(fn.returnType)
+        val returnType = getWrappedReturnType(typeFromHooks)
+        builder.type(graphQLTypeOf(returnType) as GraphQLOutputType)
         val graphQLType = builder.build()
-        return config.hooks.onRewireGraphQLType(monadType, graphQLType) as GraphQLFieldDefinition
+
+        return config.hooks.onRewireGraphQLType(returnType, graphQLType) as GraphQLFieldDefinition
     }
 
+    private fun getWrappedReturnType(returnType: KType): KType =
+        when (returnType.classifier) {
+            CompletableFuture::class -> returnType.getTypeOfFirstArgument()
+            else -> returnType
+        }
+
     @Throws(InvalidInputFieldTypeException::class)
     private fun argument(parameter: KParameter): GraphQLArgument {
 

src/main/kotlin/com/expedia/graphql/hooks/SchemaGeneratorHooks.kt

@@ -1,11 +1,9 @@
 package com.expedia.graphql.hooks
 
 import com.expedia.graphql.execution.DataFetcherExecutionPredicate
-import com.expedia.graphql.generator.extensions.getTypeOfFirstArgument
 import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.GraphQLSchema
 import graphql.schema.GraphQLType
-import java.util.concurrent.CompletableFuture
 import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
 import kotlin.reflect.KProperty
@@ -31,15 +29,10 @@ interface SchemaGeneratorHooks {
     fun willGenerateGraphQLType(type: KType): GraphQLType? = null
 
     /**
-     * Called before resolving a Monad or Future type to its wrapped KType.
-     * This allows for a custom resolver on how to extract the wrapped value.
+     * Called before resolving a KType to the GraphQL type.
+     * This allows for a custom resolver on how to extract wrapped values, like in a CompletableFuture.
      */
-    fun willResolveMonad(type: KType): KType =
-        if (type.classifier == CompletableFuture::class) {
-            type.getTypeOfFirstArgument()
-        } else {
-            type
-        }
+    fun willResolveMonad(type: KType): KType = type
 
     /**
      * Called when looking at the KClass superclasses to determine if it valid for adding to the generated schema.

src/test/kotlin/com/expedia/graphql/generator/types/FunctionTypeBuilderTest.kt

@@ -1,14 +1,15 @@
 package com.expedia.graphql.generator.types
 
-import com.expedia.graphql.execution.FunctionDataFetcher
 import com.expedia.graphql.annotations.GraphQLContext
 import com.expedia.graphql.annotations.GraphQLDescription
 import com.expedia.graphql.annotations.GraphQLDirective
+import com.expedia.graphql.execution.FunctionDataFetcher
 import graphql.Scalars
 import graphql.introspection.Introspection
 import graphql.schema.GraphQLNonNull
 import org.junit.jupiter.api.Test
 import java.util.UUID
+import java.util.concurrent.CompletableFuture
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
@@ -49,6 +50,8 @@ internal class FunctionTypeBuilderTest : TypeTestHelper() {
         fun saw(tree: String) = tree
 
         fun context(@GraphQLContext context: String, string: String) = "$context and $string"
+
+        fun completableFuture(num: Int): CompletableFuture<Int> = CompletableFuture.completedFuture(num)
     }
 
     @Test
@@ -148,4 +151,13 @@ internal class FunctionTypeBuilderTest : TypeTestHelper() {
         assertEquals(expected = 1, actual = result.arguments.size)
         assertFalse(result.dataFetcher is FunctionDataFetcher)
     }
+
+    @Test
+    fun `completable future return type is valid`() {
+        val kFunction = Happy::completableFuture
+        val result = builder.function(fn = kFunction)
+
+        assertEquals(expected = 1, actual = result.arguments.size)
+        assertEquals("Int", (result.type as? GraphQLNonNull)?.wrappedType?.name)
+    }
 }

src/test/kotlin/com/expedia/graphql/hooks/SchemaGeneratorHooksTest.kt

@@ -9,7 +9,6 @@ import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.GraphQLObjectType
 import graphql.schema.GraphQLSchema
 import graphql.schema.GraphQLType
-import java.util.concurrent.CompletableFuture
 import kotlin.reflect.KFunction
 import kotlin.reflect.KProperty
 import kotlin.reflect.KType
@@ -177,14 +176,6 @@ class SchemaGeneratorHooksTest {
         assertEquals("Hijacked Description", query.description)
     }
 
-    @Test
-    fun `willResolveMonad returns CompletableFuture wrapped type`() {
-        val hooks = NoopSchemaGeneratorHooks()
-        val type = TestQueryFuture::comepletableFutre.returnType
-
-        assertEquals(expected = "SomeData", actual = hooks.willResolveMonad(type).getSimpleName())
-    }
-
     @Test
     fun `willResolveMonad returns basic type`() {
         val hooks = NoopSchemaGeneratorHooks()
@@ -197,9 +188,5 @@ class SchemaGeneratorHooksTest {
         fun query(): SomeData = SomeData(0)
     }
 
-    class TestQueryFuture {
-        fun comepletableFutre(): CompletableFuture<SomeData> = CompletableFuture.completedFuture(SomeData(1))
-    }
-
     data class SomeData(val someNumber: Int)
 }