Valid polymorphic types in lists as input (ExpediaGroup#801)

* Valid polymorphic types in lists as input

* Add more unit tests for listtype

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

Author: smyrick

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

@@ -59,7 +59,7 @@ class Application {
                 graphQLHandler.handle(request, response)
             }
 
-            internalServerError() { _, response ->
+            internalServerError { _, response ->
                 response.status(500)
                 response.type("application/text")
                 "Unable to process request"

examples/spark/src/main/kotlin/com/expediagroup/graphql/examples/spark/schema/LoginMutationService.kt

@@ -19,7 +19,7 @@ import com.expediagroup.graphql.examples.spark.schema.models.User
 
 data class AuthPayload(val token: String? = null, val user: User? = null)
 
-class LoginMutationService() {
+class LoginMutationService {
     suspend fun login(email: String, password: String, aliasUUID: String?): AuthPayload {
         val token = "fake-token"
         val user = User(

examples/spring/src/main/kotlin/com/expediagroup/graphql/examples/model/Fruit.kt

@@ -18,5 +18,5 @@ package com.expediagroup.graphql.examples.model
 
 sealed class Fruit(val color: String) {
     class Apple(private val variety: String) : Fruit(if (variety == "red delicious") "red" else "green")
-    class Orange() : Fruit("orange")
+    class Orange : Fruit("orange")
 }

graphql-kotlin-schema-generator/src/main/kotlin/com/expediagroup/graphql/generator/extensions/kParameterExtensions.kt

@@ -26,6 +26,8 @@ internal fun KParameter.isInterface() = this.type.getKClass().isInterface()
 
 internal fun KParameter.isList() = this.type.getKClass().isSubclassOf(List::class)
 
+internal fun KParameter.isListType() = this.isList() || this.type.getJavaClass().isArray
+
 internal fun KParameter.isGraphQLContext() = this.type.getKClass().isSubclassOf(GraphQLContext::class)
 
 internal fun KParameter.isDataFetchingEnvironment() = this.type.classifier == DataFetchingEnvironment::class

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

@@ -19,17 +19,25 @@ package com.expediagroup.graphql.generator.types
 import com.expediagroup.graphql.exceptions.InvalidInputFieldTypeException
 import com.expediagroup.graphql.generator.SchemaGenerator
 import com.expediagroup.graphql.generator.extensions.getGraphQLDescription
+import com.expediagroup.graphql.generator.extensions.getKClass
 import com.expediagroup.graphql.generator.extensions.getName
+import com.expediagroup.graphql.generator.extensions.getWrappedType
 import com.expediagroup.graphql.generator.extensions.isInterface
-import com.expediagroup.graphql.generator.extensions.isList
+import com.expediagroup.graphql.generator.extensions.isListType
+import com.expediagroup.graphql.generator.extensions.isUnion
 import com.expediagroup.graphql.generator.extensions.safeCast
 import graphql.schema.GraphQLArgument
+import kotlin.reflect.KClass
 import kotlin.reflect.KParameter
 
 @Throws(InvalidInputFieldTypeException::class)
 internal fun generateArgument(generator: SchemaGenerator, parameter: KParameter): GraphQLArgument {
 
-    if (parameter.isInterface() && parameter.isList().not()) {
+    // Validate that the input is not a polymorphic type
+    // This is not currently supported by the GraphQL spec
+    // https://github.com/graphql/graphql-spec/blob/master/rfcs/InputUnion.md
+    val unwrappedClass = getUnwrappedClass(parameter)
+    if (unwrappedClass.isInterface() || unwrappedClass.isUnion()) {
         throw InvalidInputFieldTypeException(parameter)
     }
 
@@ -47,3 +55,10 @@ internal fun generateArgument(generator: SchemaGenerator, parameter: KParameter)
 
     return generator.config.hooks.onRewireGraphQLType(builder.build()).safeCast()
 }
+
+private fun getUnwrappedClass(parameter: KParameter): KClass<*> =
+    if (parameter.isListType()) {
+        parameter.type.getWrappedType().getKClass()
+    } else {
+        parameter.type.getKClass()
+    }

graphql-kotlin-schema-generator/src/test/kotlin/com/expediagroup/graphql/generator/extensions/FieldExtenstionsKtTest.kt

@@ -40,7 +40,7 @@ internal class FieldExtenstionsKtTest {
 
     @Test
     fun `verify @Deprecated on fields`() {
-        val propertyDeprecation = AnnotatedEnum::class.java.getField("ONE")?.getDeprecationReason()
+        val propertyDeprecation = AnnotatedEnum::class.java.getField("ONE").getDeprecationReason()
         assertEquals(expected = "do not use, replace with TWO", actual = propertyDeprecation)
     }
 }

graphql-kotlin-schema-generator/src/test/kotlin/com/expediagroup/graphql/generator/extensions/KParameterExtensionsKtTest.kt

@@ -30,40 +30,42 @@ import kotlin.test.assertFalse
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
-internal class KParameterExtensionsKtTest {
+class KParameterExtensionsKtTest {
 
     @GraphQLDescription("class description")
-    internal data class MyClass(val foo: String)
+    data class MyClass(val foo: String)
 
-    internal interface MyInterface {
+    interface MyInterface {
         val value: String
     }
 
-    internal abstract class MyAbstractClass {
+    abstract class MyAbstractClass {
 
         abstract val implementMe: String
 
         val value: String = "test"
     }
 
-    internal class Container {
+    class Container {
 
-        internal fun interfaceInput(myInterface: MyInterface) = myInterface
+        fun interfaceInput(myInterface: MyInterface) = myInterface
 
-        internal fun absctractInput(myAbstractClass: MyAbstractClass) = myAbstractClass
+        fun absctractInput(myAbstractClass: MyAbstractClass) = myAbstractClass
 
-        internal fun listInput(myList: List<Int>) = myList
+        fun listInput(myList: List<Int>) = myList
 
-        internal fun arrayInput(myArray: IntArray) = myArray
+        fun arrayListInput(myList: ArrayList<Int>) = myList
 
-        internal fun noDescription(myClass: MyClass) = myClass
+        fun arrayInput(myArray: IntArray) = myArray
 
-        internal fun paramDescription(@GraphQLDescription("param description") myClass: MyClass) = myClass
+        fun noDescription(myClass: MyClass) = myClass
 
-        internal fun dataFetchingEnvironment(environment: DataFetchingEnvironment) = environment.field.name
+        fun paramDescription(@GraphQLDescription("param description") myClass: MyClass) = myClass
+
+        fun dataFetchingEnvironment(environment: DataFetchingEnvironment) = environment.field.name
     }
 
-    internal class MyKotlinClass {
+    class MyKotlinClass {
         fun stringFun(string: String) = "hello $string"
     }
 
@@ -131,4 +133,12 @@ internal class KParameterExtensionsKtTest {
         assertTrue(Container::arrayInput.findParameterByName("myArray")?.isList() == false)
         assertTrue(Container::interfaceInput.findParameterByName("myInterface")?.isList() == false)
     }
+
+    @Test
+    fun isListType() {
+        assertTrue(Container::listInput.findParameterByName("myList")?.isListType() == true)
+        assertTrue(Container::arrayListInput.findParameterByName("myList")?.isListType() == true)
+        assertTrue(Container::arrayInput.findParameterByName("myArray")?.isListType() == true)
+        assertTrue(Container::interfaceInput.findParameterByName("myInterface")?.isListType() == false)
+    }
 }

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

@@ -34,11 +34,13 @@ import kotlin.test.assertNotNull
 
 class GenerateArgumentTest : TypeTestHelper() {
 
-    internal interface MyInterface {
+    interface MyInterface {
         val id: String
     }
 
-    internal class ArgumentTestClass {
+    interface MyUnion
+
+    class ArgumentTestClass {
         fun description(@GraphQLDescription("Argument description") input: String) = input
 
         fun directive(@SimpleDirective input: String) = input
@@ -53,7 +55,15 @@ class GenerateArgumentTest : TypeTestHelper() {
 
         fun arrayListArg(input: ArrayList<String>) = input
 
+        fun arrayListInterfaceArg(input: ArrayList<MyInterface>) = input
+
+        fun arrayListUnionArg(input: ArrayList<MyUnion>) = input
+
         fun listArg(input: List<String>) = input
+
+        fun listInterfaceArg(input: List<MyInterface>) = input
+
+        fun listUnionArg(input: List<MyUnion>) = input
     }
 
     @Test
@@ -127,6 +137,26 @@ class GenerateArgumentTest : TypeTestHelper() {
         assertNotNull(GraphQLTypeUtil.unwrapNonNull(result.type) as? GraphQLList)
     }
 
+    @Test
+    fun `ArrayList of interfaces as input is invalid`() {
+        val kParameter = ArgumentTestClass::arrayListInterfaceArg.findParameterByName("input")
+        assertNotNull(kParameter)
+
+        assertFailsWith(InvalidInputFieldTypeException::class) {
+            generateArgument(generator, kParameter)
+        }
+    }
+
+    @Test
+    fun `ArrayList of unions as input is invalid`() {
+        val kParameter = ArgumentTestClass::arrayListUnionArg.findParameterByName("input")
+        assertNotNull(kParameter)
+
+        assertFailsWith(InvalidInputFieldTypeException::class) {
+            generateArgument(generator, kParameter)
+        }
+    }
+
     @Test
     fun `List argument type is valid`() {
         val kParameter = ArgumentTestClass::listArg.findParameterByName("input")
@@ -136,4 +166,24 @@ class GenerateArgumentTest : TypeTestHelper() {
         assertEquals(expected = "input", actual = result.name)
         assertNotNull(GraphQLTypeUtil.unwrapNonNull(result.type) as? GraphQLList)
     }
+
+    @Test
+    fun `List of interfaces as input is invalid`() {
+        val kParameter = ArgumentTestClass::listInterfaceArg.findParameterByName("input")
+        assertNotNull(kParameter)
+
+        assertFailsWith(InvalidInputFieldTypeException::class) {
+            generateArgument(generator, kParameter)
+        }
+    }
+
+    @Test
+    fun `List of unions as input is invalid`() {
+        val kParameter = ArgumentTestClass::listUnionArg.findParameterByName("input")
+        assertNotNull(kParameter)
+
+        assertFailsWith(InvalidInputFieldTypeException::class) {
+            generateArgument(generator, kParameter)
+        }
+    }
 }