[generator] Support subscriptions of Publisher<DataFetcherResult<T>> (#786)

* Support subscriptions of Publisher<DataFetcherResult<T>>

* Update javadocs and example

* Update graphql-kotlin-schema-generator/src/main/kotlin/com/expediagroup/graphql/generator/types/utils/functionReturnTypes.kt

Co-authored-by: Dariusz Kuc <[email protected]>

Co-authored-by: Shane Myrick <[email protected]>
Co-authored-by: Dariusz Kuc <[email protected]>

Author: 3 people

examples/spring/src/main/kotlin/com/expediagroup/graphql/examples/subscriptions/SimpleSubscription.kt

@@ -18,7 +18,9 @@ package com.expediagroup.graphql.examples.subscriptions
 
 import com.expediagroup.graphql.annotations.GraphQLDescription
 import com.expediagroup.graphql.examples.context.MyGraphQLContext
+import com.expediagroup.graphql.spring.exception.SimpleKotlinGraphQLError
 import com.expediagroup.graphql.spring.operations.Subscription
+import graphql.execution.DataFetcherResult
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.reactive.asPublisher
 import org.reactivestreams.Publisher
@@ -57,9 +59,19 @@ class SimpleSubscription : Subscription {
     fun singleValueThenError(): Flux<Int> = Flux.just(1, 2)
         .map { if (it == 2) throw Exception("Second value") else it }
 
-    @GraphQLDescription("Returns list of values")
+    @GraphQLDescription("Returns stream of values")
     fun flow(): Publisher<Int> = flowOf(1, 2, 4).asPublisher()
 
+    @GraphQLDescription("Returns stream of errors")
+    fun flowOfErrors(): Publisher<DataFetcherResult<String?>> {
+        val dfr: DataFetcherResult<String?> = DataFetcherResult.newResult<String?>()
+            .data(null)
+            .error(SimpleKotlinGraphQLError(Exception("error thrown")))
+            .build()
+
+        return flowOf(dfr, dfr).asPublisher()
+    }
+
     @GraphQLDescription("Returns a value from the subscription context")
     fun subscriptionContext(myGraphQLContext: MyGraphQLContext): Publisher<String> =
         flowOf(myGraphQLContext.subscriptionValue ?: "", "value 2", "value3").asPublisher()

graphql-kotlin-schema-generator/src/main/kotlin/com/expediagroup/graphql/generator/types/utils/functionReturnTypes.kt

@@ -33,24 +33,35 @@ import kotlin.reflect.KType
  *
  * We can return the following combination of types:
  *      Valid type T
- *      Publisher<T>
  *      DataFetcherResult<T>
+ *      Publisher<T>
+ *      Publisher<DataFetcherResult<T>>
  *      CompletableFuture<T>
  *      CompletableFuture<DataFetcherResult<T>>
  */
 internal fun getWrappedReturnType(returnType: KType): KType {
     return when {
-        returnType.isSubclassOf(Publisher::class) -> returnType.getTypeOfFirstArgument()
         returnType.isSubclassOf(DataFetcherResult::class) -> returnType.getTypeOfFirstArgument()
-        returnType.isSubclassOf(CompletableFuture::class) -> {
-            val wrappedType = returnType.getTypeOfFirstArgument()
+        returnType.isSubclassOf(Publisher::class) -> { checkTypeForDataFetcherResult(returnType) }
+        returnType.isSubclassOf(CompletableFuture::class) -> { checkTypeForDataFetcherResult(returnType) }
+        else -> returnType
+    }
+}
 
-            if (wrappedType.isSubclassOf(DataFetcherResult::class)) {
-                return wrappedType.getTypeOfFirstArgument()
-            }
+/**
+ * Both Publisher and CompletableFuture can be optional wrapped internally with DataFetcherResult.
+ *
+ *      Publisher<T>
+ *      Published<DataFetcherResult<T>>
+ *      CompletableFuture<T>
+ *      CompletableFuture<DataFetcherResult<T>>
+ */
+private fun checkTypeForDataFetcherResult(returnType: KType): KType {
+    val wrappedType = returnType.getTypeOfFirstArgument()
 
-            wrappedType
-        }
-        else -> returnType
+    return if (wrappedType.isSubclassOf(DataFetcherResult::class)) {
+        wrappedType.getTypeOfFirstArgument()
+    } else {
+        wrappedType
     }
 }

graphql-kotlin-schema-generator/src/test/kotlin/com/expediagroup/graphql/generator/types/utils/FunctionReturnTypesKtTest.kt

@@ -23,38 +23,41 @@ import org.reactivestreams.Publisher
 import java.util.concurrent.CompletableFuture
 import kotlin.test.assertEquals
 
-internal class FunctionReturnTypesKtTest {
+class FunctionReturnTypesKtTest {
 
-    internal class MyClass {
+    class MyClass {
+        // Valid Types
         val string = "my string"
-
+        val dataFetcherResult: DataFetcherResult<String> = DataFetcherResult.newResult<String>().data(string).build()
         val publisher: Publisher<String> = Flowable.just(string)
         val flowable: Flowable<String> = Flowable.just(string)
-        val dataFetcherResult: DataFetcherResult<String> = DataFetcherResult.newResult<String>().data(string).build()
+        val publisherDataFetcherResult: Publisher<DataFetcherResult<String>> = Flowable.just(dataFetcherResult)
         val completableFuture: CompletableFuture<String> = CompletableFuture.completedFuture(string)
+        val completableFutureDataFetcher: CompletableFuture<DataFetcherResult<String>> = CompletableFuture.completedFuture(dataFetcherResult)
 
-        val invalidPublisher: Publisher<DataFetcherResult<String>> = Flowable.just(dataFetcherResult)
-        val invalidDataFetcherResult: DataFetcherResult<CompletableFuture<String>> = DataFetcherResult.newResult<CompletableFuture<String>>().data(completableFuture).build()
-        val validCompletableFutureDataFetcher: CompletableFuture<DataFetcherResult<String>> = CompletableFuture.completedFuture(dataFetcherResult)
+        // Invalid types
+        val invalidDataFetcherResultCompletableFuture: DataFetcherResult<CompletableFuture<String>> = DataFetcherResult.newResult<CompletableFuture<String>>().data(completableFuture).build()
+        val invalidDataFetcherResultPublisher: DataFetcherResult<Publisher<String>> = DataFetcherResult.newResult<Publisher<String>>().data(publisher).build()
         val invalidCompletableFuture: CompletableFuture<Publisher<String>> = CompletableFuture.completedFuture(publisher)
     }
 
     @Test
     fun `getWrappedReturnType of Publisher`() {
         assertEquals(MyClass::string.returnType, actual = getWrappedReturnType(MyClass::publisher.returnType))
-        assertEquals(MyClass::dataFetcherResult.returnType, actual = getWrappedReturnType(MyClass::invalidPublisher.returnType))
+        assertEquals(MyClass::string.returnType, actual = getWrappedReturnType(MyClass::publisherDataFetcherResult.returnType))
     }
 
     @Test
     fun `getWrappedReturnType of DataFetcherResult`() {
         assertEquals(MyClass::string.returnType, actual = getWrappedReturnType(MyClass::dataFetcherResult.returnType))
-        assertEquals(MyClass::completableFuture.returnType, actual = getWrappedReturnType(MyClass::invalidDataFetcherResult.returnType))
+        assertEquals(MyClass::completableFuture.returnType, actual = getWrappedReturnType(MyClass::invalidDataFetcherResultCompletableFuture.returnType))
+        assertEquals(MyClass::publisher.returnType, actual = getWrappedReturnType(MyClass::invalidDataFetcherResultPublisher.returnType))
     }
 
     @Test
     fun `getWrappedReturnType of CompletableFuture`() {
         assertEquals(MyClass::string.returnType, actual = getWrappedReturnType(MyClass::completableFuture.returnType))
-        assertEquals(MyClass::string.returnType, actual = getWrappedReturnType(MyClass::validCompletableFutureDataFetcher.returnType))
+        assertEquals(MyClass::string.returnType, actual = getWrappedReturnType(MyClass::completableFutureDataFetcher.returnType))
         assertEquals(MyClass::publisher.returnType, actual = getWrappedReturnType(MyClass::invalidCompletableFuture.returnType))
     }