feat: support primitive arrays (#543)

Adds support for `IntArray`, `LongArray`, `ShortArray`, `FloatArray`,
`DoubleArray`, `CharArray`, and `BooleanArray`.

Author: stuebingerb

kgraphql/src/main/kotlin/com/apurebase/kgraphql/Extensions.kt

@@ -8,6 +8,7 @@ import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.withContext
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
+import kotlin.reflect.full.createType
 import kotlin.reflect.full.isSubclassOf
 import kotlin.reflect.jvm.jvmErasure
 
@@ -21,13 +22,23 @@ internal fun String.dropQuotes(): String = if (isLiteral()) {
 
 internal fun String.isLiteral(): Boolean = startsWith('\"') && endsWith('\"')
 
-internal fun KClass<*>.isIterable() = isSubclassOf(Iterable::class)
+internal fun KClass<*>.isIterable() = isSubclassOf(Iterable::class) || this in typeByPrimitiveArrayClass.keys
 
 internal fun KType.isIterable() = jvmErasure.isIterable() || toString().startsWith("kotlin.Array")
 
+internal val typeByPrimitiveArrayClass = mapOf(
+    IntArray::class to Int::class.createType(),
+    LongArray::class to Long::class.createType(),
+    ShortArray::class to Short::class.createType(),
+    FloatArray::class to Float::class.createType(),
+    DoubleArray::class to Double::class.createType(),
+    CharArray::class to Char::class.createType(),
+    BooleanArray::class to Boolean::class.createType()
+)
+
 internal fun KType.getIterableElementType(): KType {
     require(isIterable()) { "KType $this is not collection type" }
-    return arguments.firstOrNull()?.type ?: throw NoSuchElementException("KType $this has no type arguments")
+    return typeByPrimitiveArrayClass[jvmErasure] ?: arguments.firstOrNull()?.type ?: throw NoSuchElementException("KType $this has no type arguments")
 }
 
 internal suspend fun <T, R> Iterable<T>.mapIndexedParallel(

kgraphql/src/main/kotlin/com/apurebase/kgraphql/schema/execution/ParallelRequestExecutor.kt

@@ -14,6 +14,7 @@ import com.apurebase.kgraphql.schema.scalar.serializeScalar
 import com.apurebase.kgraphql.schema.structure.Field
 import com.apurebase.kgraphql.schema.structure.InputValue
 import com.apurebase.kgraphql.schema.structure.Type
+import com.apurebase.kgraphql.typeByPrimitiveArrayClass
 import com.fasterxml.jackson.databind.JsonNode
 import com.fasterxml.jackson.databind.node.ArrayNode
 import com.fasterxml.jackson.databind.node.NullNode
@@ -180,10 +181,17 @@ class ParallelRequestExecutor(val schema: DefaultSchema) : RequestExecutor {
 
         return when {
             // Check value, not returnType, because this method can be invoked with element value
-            value is Collection<*> || value is Array<*> || value is ArrayNode -> ctx.scope.async {
+            value is Collection<*> || value is Array<*> || value is ArrayNode || value::class in typeByPrimitiveArrayClass.keys -> ctx.scope.async {
                 val values: Collection<*> = when (value) {
                     is Array<*> -> value.toList()
                     is ArrayNode -> value.toList()
+                    is IntArray -> value.toList()
+                    is ShortArray -> value.toList()
+                    is LongArray -> value.toList()
+                    is FloatArray -> value.toList()
+                    is DoubleArray -> value.toList()
+                    is CharArray -> value.toList()
+                    is BooleanArray -> value.toList()
                     else -> value as Collection<*>
                 }
                 if (returnType.isList()) {

kgraphql/src/test/kotlin/com/apurebase/kgraphql/specification/typesystem/ListsSpecificationTest.kt

@@ -249,4 +249,61 @@ class ListsSpecificationTest {
         response.extract<List<*>>("data/createNestedLists/nested2") shouldBe listOf(listOf(listOf(listOf(listOf("foobar")))))
         response.extract<List<*>>("data/createNestedLists/nested3") shouldBe null
     }
+
+    @Test
+    fun `primitive arrays can be used`() {
+        class Model(
+            val intArray: IntArray,
+            val shortArray: ShortArray,
+            val longArray: LongArray,
+            val floatArray: FloatArray,
+            val doubleArray: DoubleArray,
+            val charArray: CharArray,
+            val booleanArray: BooleanArray
+        )
+
+        val schema = KGraphQL.schema {
+            extendedScalars()
+            query("model") {
+                resolver { ->
+                    Model(
+                        intArrayOf(1, 2, 3),
+                        shortArrayOf(5, 6),
+                        longArrayOf(7, 8),
+                        floatArrayOf(0.0f, 1.0f),
+                        doubleArrayOf(2.0, 3.0),
+                        charArrayOf('a', 'b'),
+                        booleanArrayOf(true, false)
+                    )
+                }
+            }
+        }
+
+        schema.printSchema() shouldBe """
+            scalar Char
+
+            scalar Long
+            
+            scalar Short
+            
+            type Model {
+              booleanArray: [Boolean!]!
+              charArray: [Char!]!
+              doubleArray: [Float!]!
+              floatArray: [Float!]!
+              intArray: [Int!]!
+              longArray: [Long!]!
+              shortArray: [Short!]!
+            }
+            
+            type Query {
+              model: Model!
+            }
+
+        """.trimIndent()
+
+        schema.executeBlocking("{ model { intArray shortArray longArray floatArray doubleArray charArray booleanArray } }") shouldBe """
+            {"data":{"model":{"intArray":[1,2,3],"shortArray":[5,6],"longArray":[7,8],"floatArray":[0.0,1.0],"doubleArray":[2.0,3.0],"charArray":["a","b"],"booleanArray":[true,false]}}}
+        """.trimIndent()
+    }
 }