Support List for input arguments (#546)

* Support List for input arguments

Fixes #509

Adds support for using List<*> as the type for function arguments instead of the concrete class ArrayList or arrays

* Remove unused unit test

We don't cache values in the generateUnion method anymore so we don't need to validate the cache there

* Remove unused exception:

* Update unit tests for coverage levels

Author: smyrick

docs/writing-schemas/lists.md

@@ -1,56 +1,55 @@
----
-id: lists
-title: Lists
----
-
-Both `kotlin.Array` and `kotlin.collections.List` are automatically mapped to the GraphQL `List` type (for unsupported
-use cases see below). Type arguments provided to Kotlin collections are used as the type arguments in the GraphQL `List`
-type. Kotlin specialized classes representing arrays of Java primitive types without boxing overhead (e.g. `IntArray`)
-are also supported.
-
-```kotlin
-class SimpleQuery {
-  fun generateList(): List<Int> {
-    // some logic here that generates list
-  }
-
-  fun doSomethingWithIntArray(ints: IntArray): String {
-    // some logic here that processes array
-  }
-```
-
-The above Kotlin class would produce the following GraphQL schema:
-
-```graphql
-schema {
-  query: Query
-}
-
-type Query {
-  generateList: [Int!]!
-  doSomethingWithIntArray(ints: [Int!]!): String!
-}
-```
-
-### Primitive Arrays
-
-`graphql-kotlin-schema-generator` supports the following primitive array types without autoboxing overhead. Similarly to
-the `kotlin.Array` of objects the underlying type is automatically mapped to GraphQL `List` type.
-
-| Kotlin Type           |
-|-----------------------|
-| `kotlin.IntArray`     | | `kotlin.LongArray`    | | `kotlin.ShortArray`   | | `kotlin.FloatArray`   | |
-`kotlin.DoubleArray`  | | `kotlin.CharArray`    | | `kotlin.BooleanArray` |
-
-> NOTE: Underlying GraphQL types of primitive arrays will be corresponding to the built-in scalar types or extended
-> scalar types provided by `graphql-java`.
-
-### Unsupported Collection Types
-
-Currently GraphQL spec only supports `Lists`. Therefore even though Java and Kotlin support number of other collection
-types, `graphql-kotlin-schema-generator` only explicitly supports `Lists` and primitive arrays. Other collection types
-such as `Sets` (see [#201](https://github.com/ExpediaGroup/graphql-kotlin/issues/201)) and arbitrary `Map` data
-structures are not supported.
-
-Additionally, GraphQL spec does not allow interfaces/union types to be used for a query input arguments which means you
-can only use lists of concrete GraphQL types as your query input arguments.
+---
+id: lists
+title: Lists
+---
+
+Both `kotlin.Array` and `kotlin.collections.List` are automatically mapped to the GraphQL `List` type (for unsupported
+use cases see below). Type arguments provided to Kotlin collections are used as the type arguments in the GraphQL `List`
+type. Kotlin specialized classes representing arrays of Java primitive types without boxing overhead (e.g. `IntArray`)
+are also supported.
+
+```kotlin
+class SimpleQuery {
+    fun generateList(): List<Int> {
+        // some logic here that generates list
+    }
+
+    fun doSomethingWithIntArray(ints: IntArray): String {
+        // some logic here that processes array
+    }
+
+    fun doSomethingWithIntList(ints: List<Int>): String {
+        // some logic here that processes list
+    }
+}
+```
+
+The above Kotlin class would produce the following GraphQL schema:
+
+```graphql
+type Query {
+    generateList: [Int!]!
+    doSomethingWithIntArray(ints: [Int!]!): String!
+    doSomethingWithIntList(ints: [Int!]!): String!
+}
+```
+
+### Primitive Arrays
+
+`graphql-kotlin-schema-generator` supports the following primitive array types without autoboxing overhead. Similarly to
+the `kotlin.Array` of objects the underlying type is automatically mapped to GraphQL `List` type.
+
+| Kotlin Type           |
+|-----------------------|
+| `kotlin.IntArray`     | | `kotlin.LongArray`    | | `kotlin.ShortArray`   | | `kotlin.FloatArray`   | |
+`kotlin.DoubleArray`  | | `kotlin.CharArray`    | | `kotlin.BooleanArray` |
+
+> NOTE: Underlying GraphQL types of primitive arrays will be corresponding to the built-in scalar types or extended
+> scalar types provided by `graphql-java`.
+
+### Unsupported Collection Types
+
+Currently GraphQL spec only supports `Lists`. Therefore even though Java and Kotlin support number of other collection
+types, `graphql-kotlin-schema-generator` only explicitly supports `Lists` and primitive arrays. Other collection types
+such as `Sets` (see [#201](https://github.com/ExpediaGroup/graphql-kotlin/issues/201)) and arbitrary `Map` data
+structures are not supported.

graphql-kotlin-schema-generator/src/main/kotlin/com/expediagroup/graphql/exceptions/CouldNotCastArgumentException.kt

@@ -17,15 +17,17 @@
 package com.expediagroup.graphql.generator.extensions
 
 import com.expediagroup.graphql.annotations.GraphQLContext
-import com.expediagroup.graphql.exceptions.CouldNotCastArgumentException
 import com.expediagroup.graphql.exceptions.CouldNotGetNameOfKParameterException
 import graphql.schema.DataFetchingEnvironment
 import kotlin.reflect.KParameter
 import kotlin.reflect.full.findAnnotation
+import kotlin.reflect.full.isSubclassOf
 import kotlin.reflect.jvm.javaType
 
 internal fun KParameter.isInterface() = this.type.getKClass().isInterface()
 
+internal fun KParameter.isList() = this.type.getKClass().isSubclassOf(List::class)
+
 internal fun KParameter.isGraphQLContext() = this.findAnnotation<GraphQLContext>() != null
 
 internal fun KParameter.isDataFetchingEnvironment() = this.type.classifier == DataFetchingEnvironment::class
@@ -34,6 +36,9 @@ internal fun KParameter.isDataFetchingEnvironment() = this.type.classifier == Da
 internal fun KParameter.getName(): String =
     this.getGraphQLName() ?: this.name ?: throw CouldNotGetNameOfKParameterException(this)
 
-@Throws(CouldNotCastArgumentException::class)
 internal fun KParameter.javaTypeClass(): Class<*> =
-    this.type.javaType as? Class<*> ?: throw CouldNotCastArgumentException(this)
+    if (this.isList()) {
+        this.type.getKClass().java
+    } else {
+        this.type.javaType as Class<*>
+    }

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

@@ -70,8 +70,6 @@ internal class TypesCache(private val supportedPackages: List<String>) {
     internal fun doesNotContainGraphQLType(graphQLType: GraphQLType) =
         cache.none { (_, v) -> v.graphQLType.name == graphQLType.name }
 
-    internal fun doesNotContain(kClass: KClass<*>): Boolean = cache.none { (_, ktype) -> ktype.kClass == kClass }
-
     /**
      * We do not want to cache list types since it is just a simple wrapper.
      * Enums do not have a different name for input and output.

graphql-kotlin-schema-generator/src/main/kotlin/com/expediagroup/graphql/generator/state/TypesCache.kt

@@ -22,14 +22,15 @@ import com.expediagroup.graphql.generator.extensions.getGraphQLDescription
 import com.expediagroup.graphql.generator.extensions.getName
 import com.expediagroup.graphql.generator.extensions.isGraphQLID
 import com.expediagroup.graphql.generator.extensions.isInterface
+import com.expediagroup.graphql.generator.extensions.isList
 import com.expediagroup.graphql.generator.extensions.safeCast
 import graphql.schema.GraphQLArgument
 import kotlin.reflect.KParameter
 
 @Throws(InvalidInputFieldTypeException::class)
 internal fun generateArgument(generator: SchemaGenerator, parameter: KParameter): GraphQLArgument {
 
-    if (parameter.isInterface()) {
+    if (parameter.isInterface() && parameter.isList().not()) {
         throw InvalidInputFieldTypeException(parameter)
     }
 

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

@@ -18,7 +18,6 @@ package com.expediagroup.graphql.execution
 
 import com.expediagroup.graphql.annotations.GraphQLContext
 import com.expediagroup.graphql.annotations.GraphQLName
-import com.expediagroup.graphql.exceptions.CouldNotCastArgumentException
 import com.fasterxml.jackson.annotation.JsonProperty
 import graphql.GraphQLException
 import graphql.schema.DataFetchingEnvironment
@@ -28,7 +27,6 @@ import kotlinx.coroutines.coroutineScope
 import org.junit.jupiter.api.Test
 import java.util.concurrent.CompletableFuture
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
@@ -110,14 +108,12 @@ internal class FunctionDataFetcherTest {
     }
 
     @Test
-    fun `list inputs throws exception`() {
+    fun `list can be converted by the object mapper`() {
         val dataFetcher = FunctionDataFetcher(target = MyClass(), fn = MyClass::printList)
         val mockEnvironmet: DataFetchingEnvironment = mockk()
         every { mockEnvironmet.arguments } returns mapOf("items" to listOf("foo", "bar"))
 
-        assertFailsWith(CouldNotCastArgumentException::class) {
-            dataFetcher.get(mockEnvironmet)
-        }
+        assertEquals(expected = "foo:bar", actual = dataFetcher.get(mockEnvironmet))
     }
 
     @Test

graphql-kotlin-schema-generator/src/test/kotlin/com/expediagroup/graphql/execution/FunctionDataFetcherTest.kt

@@ -218,7 +218,7 @@ class GraphQLSchemaExtensionsTest {
     }
 
     @GraphQLDirective(locations = [Introspection.DirectiveLocation.FIELD_DEFINITION])
-    internal annotation class CustomDirective
+    annotation class CustomDirective
 
     class QueryWithDirectives {
         fun echo(msg: String): String = msg

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

@@ -49,6 +49,7 @@ import kotlin.test.assertTrue
     "Detekt.LargeClass",
     "Detekt.MethodOverloading")
 class ToSchemaTest {
+
     @Test
     fun `SchemaGenerator generates a simple GraphQL schema`() {
         val schema = toSchema(
@@ -82,21 +83,26 @@ class ToSchemaTest {
     }
 
     @Test
-    fun `Schema generator exposes arrays of primitive types as function arguments`() {
-        val schema = toSchema(queries = listOf(TopLevelObject(QueryWithArray())), config = testSchemaConfig)
+    fun `Schema generator exposes arrays and lists as function arguments`() {
+        val schema = toSchema(queries = listOf(TopLevelObject(QueryWithLists())), config = testSchemaConfig)
         val firstArgumentType = schema.queryType.getFieldDefinition("sumOf").arguments[0].type.deepName
         assertEquals("[Int!]!", firstArgumentType)
+        val secondArgumentType = schema.queryType.getFieldDefinition("sumOfList").arguments[0].type.deepName
+        assertEquals("[Int!]!", secondArgumentType)
 
         val graphQL = GraphQL.newGraphQL(schema).build()
-        val result = graphQL.execute("{ sumOf(ints: [1, 2, 3]) }")
-        val sum = result.getData<Map<String, Int>>().values.first()
+        val arrayResult = graphQL.execute("{ sumOf(ints: [1, 2, 3]) }")
+        val arraySum = arrayResult.getData<Map<String, Int>>().values.first()
+        assertEquals(6, arraySum)
 
-        assertEquals(6, sum)
+        val listResult = graphQL.execute("{ sumOfList(ints: [1, 2, 3]) }")
+        val listSum = listResult.getData<Map<String, Int>>().values.first()
+        assertEquals(6, listSum)
     }
 
     @Test
     fun `Schema generator exposes arrays of complex types as function arguments`() {
-        val schema = toSchema(queries = listOf(TopLevelObject(QueryWithArray())), config = testSchemaConfig)
+        val schema = toSchema(queries = listOf(TopLevelObject(QueryWithLists())), config = testSchemaConfig)
         val firstArgumentType = schema.queryType.getFieldDefinition("sumOfComplexArray").arguments[0].type.deepName
         assertEquals("[ComplexWrappingTypeInput!]!", firstArgumentType)
 
@@ -342,9 +348,10 @@ class ToSchemaTest {
         fun query(@GraphQLDescription("A GraphQL value") value: Int): Geography = Geography(value, GeoType.CITY, listOf())
     }
 
-    class QueryWithArray {
+    class QueryWithLists {
         fun sumOf(ints: IntArray): Int = ints.sum()
         fun sumOfComplexArray(objects: Array<ComplexWrappingType>): Int = objects.map { it.value }.sum()
+        fun sumOfList(ints: List<Int>): Int = ints.sum()
     }
 
     class QueryWithIgnored {

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

@@ -52,6 +52,10 @@ internal class KParameterExtensionsKtTest {
 
         internal fun absctractInput(myAbstractClass: MyAbstractClass) = myAbstractClass
 
+        internal fun listInput(myList: List<Int>) = myList
+
+        internal fun arrayInput(myArray: IntArray) = myArray
+
         internal fun noDescription(myClass: MyClass) = myClass
 
         internal fun paramDescription(@GraphQLDescription("param description") myClass: MyClass) = myClass
@@ -124,5 +128,14 @@ internal class KParameterExtensionsKtTest {
     @Test
     fun javaTypeClass() {
         assertEquals(expected = String::class.java, actual = MyKotlinClass::stringFun.findParameterByName("string")?.javaTypeClass())
+        assertEquals(expected = List::class.java, actual = Container::listInput.findParameterByName("myList")?.javaTypeClass())
+        assertEquals(expected = MyInterface::class.java, actual = Container::interfaceInput.findParameterByName("myInterface")?.javaTypeClass())
+    }
+
+    @Test
+    fun isList() {
+        assertTrue(Container::listInput.findParameterByName("myList")?.isList() == true)
+        assertTrue(Container::arrayInput.findParameterByName("myArray")?.isList() == false)
+        assertTrue(Container::interfaceInput.findParameterByName("myInterface")?.isList() == false)
     }
 }

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

@@ -22,7 +22,9 @@ import com.expediagroup.graphql.annotations.GraphQLName
 import com.expediagroup.graphql.exceptions.InvalidInputFieldTypeException
 import com.expediagroup.graphql.test.utils.SimpleDirective
 import graphql.Scalars
+import graphql.schema.GraphQLList
 import graphql.schema.GraphQLNonNull
+import graphql.schema.GraphQLTypeUtil
 import org.junit.jupiter.api.Test
 import kotlin.reflect.full.findParameterByName
 import kotlin.test.assertEquals
@@ -45,6 +47,12 @@ internal class GenerateArgumentTest : TypeTestHelper() {
         fun id(@GraphQLID idArg: String) = "Your id is $idArg"
 
         fun interfaceArg(input: MyInterface) = input.id
+
+        fun arrayArg(input: IntArray) = input
+
+        fun arrayListArg(input: ArrayList<String>) = input
+
+        fun listArg(input: List<String>) = input
     }
 
     @Test
@@ -97,4 +105,34 @@ internal class GenerateArgumentTest : TypeTestHelper() {
             generateArgument(generator, kParameter)
         }
     }
+
+    @Test
+    fun `Primitive array argument type is valid`() {
+        val kParameter = ArgumentTestClass::arrayArg.findParameterByName("input")
+        assertNotNull(kParameter)
+        val result = generateArgument(generator, kParameter)
+
+        assertEquals(expected = "input", actual = result.name)
+        assertNotNull(GraphQLTypeUtil.unwrapNonNull(result.type) as? GraphQLList)
+    }
+
+    @Test
+    fun `ArrayList argument type is valid`() {
+        val kParameter = ArgumentTestClass::arrayListArg.findParameterByName("input")
+        assertNotNull(kParameter)
+        val result = generateArgument(generator, kParameter)
+
+        assertEquals(expected = "input", actual = result.name)
+        assertNotNull(GraphQLTypeUtil.unwrapNonNull(result.type) as? GraphQLList)
+    }
+
+    @Test
+    fun `List argument type is valid`() {
+        val kParameter = ArgumentTestClass::listArg.findParameterByName("input")
+        assertNotNull(kParameter)
+        val result = generateArgument(generator, kParameter)
+
+        assertEquals(expected = "input", actual = result.name)
+        assertNotNull(GraphQLTypeUtil.unwrapNonNull(result.type) as? GraphQLList)
+    }
 }