Add support for Kotlin builtin arrays of primitives (#94)

Resolves #90

Author: dariuszkuc

example/src/main/kotlin/com.expedia.graphql.sample/query/SimpleQuery.kt

@@ -47,6 +47,15 @@ class SimpleQuery: Query {
         return (1..10).map { random.nextInt(100) }.toList()
     }
 
+    @GraphQLDescription("generates pseudo random array of ints")
+    fun generatePrimitiveArray(): IntArray {
+        val random = Random()
+        return (1..10).map { random.nextInt(100) }.toIntArray()
+    }
+
+    @GraphQLDescription("query with array input")
+    fun doSomethingWithIntArray(ints: IntArray) = "received ints=[${ints.joinToString()}]"
+
     @GraphQLDescription("query with optional input")
     fun doSomethingWithOptionalInput(
             @GraphQLDescription("this field is required") requiredValue: Int,

src/main/kotlin/com/expedia/graphql/schema/extensions/kClassExtensions.kt

@@ -23,4 +23,6 @@ internal fun KClass<*>.isGraphQLUnion(): Boolean =
 
 internal fun KClass<*>.isEnum(): Boolean = this.isSubclassOf(Enum::class)
 
-internal fun KClass<*>.isGraphQLList(): Boolean = this.isSubclassOf(List::class) || this.java.isArray
+internal fun KClass<*>.isList(): Boolean = this.isSubclassOf(List::class)
+
+internal fun KClass<*>.isArray(): Boolean = this.java.isArray

src/main/kotlin/com/expedia/graphql/schema/extensions/kTypeExtensions.kt

@@ -3,9 +3,28 @@ package com.expedia.graphql.schema.extensions
 import com.expedia.graphql.schema.exceptions.InvalidListTypeException
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
+import kotlin.reflect.full.createType
+import kotlin.reflect.full.isSubclassOf
 
 internal fun KType.graphQLDescription(): String? = (classifier as? KClass<*>)?.graphQLDescription()
 
 @Throws(InvalidListTypeException::class)
 internal fun KType.getTypeOfFirstArgument(): KType =
-    this.arguments.first().type ?: throw InvalidListTypeException(this)
+    this.arguments.firstOrNull()?.type ?: throw InvalidListTypeException(this)
+
+@Suppress("Detekt.UnsafeCast")
+internal fun KType.getKClass() = this.classifier as KClass<*>
+
+internal fun KType.getArrayType(): KType {
+    val kClass = this.getKClass()
+    return when {
+        kClass.isSubclassOf(IntArray::class) -> Int::class.createType()
+        kClass.isSubclassOf(LongArray::class) -> Long::class.createType()
+        kClass.isSubclassOf(ShortArray::class) -> Short::class.createType()
+        kClass.isSubclassOf(FloatArray::class) -> Float::class.createType()
+        kClass.isSubclassOf(DoubleArray::class) -> Double::class.createType()
+        kClass.isSubclassOf(CharArray::class) -> Char::class.createType()
+        kClass.isSubclassOf(BooleanArray::class) -> Boolean::class.createType()
+        else -> this.getTypeOfFirstArgument()
+    }
+}

src/main/kotlin/com/expedia/graphql/schema/generator/SchemaGenerator.kt

@@ -21,6 +21,7 @@ import kotlin.reflect.KFunction
 import kotlin.reflect.KProperty
 import kotlin.reflect.KType
 
+@Suppress("Detekt.TooManyFunctions")
 internal class SchemaGenerator(
     private val queries: List<TopLevelObjectDef>,
     private val mutations: List<TopLevelObjectDef>,
@@ -100,6 +101,9 @@ internal class SchemaGenerator(
     internal fun listType(type: KType, inputType: Boolean) =
         listTypeBuilder.listType(type, inputType)
 
+    internal fun arrayType(type: KType, inputType: Boolean) =
+            listTypeBuilder.arrayType(type, inputType)
+
     internal fun objectType(kClass: KClass<*>, interfaceType: GraphQLInterfaceType? = null) =
         objectTypeBuilder.objectType(kClass, interfaceType)
 

src/main/kotlin/com/expedia/graphql/schema/generator/TypeBuilder.kt

@@ -1,9 +1,10 @@
 package com.expedia.graphql.schema.generator
 
+import com.expedia.graphql.schema.extensions.isArray
+import com.expedia.graphql.schema.extensions.isEnum
 import com.expedia.graphql.schema.extensions.isGraphQLInterface
-import com.expedia.graphql.schema.extensions.isGraphQLList
 import com.expedia.graphql.schema.extensions.isGraphQLUnion
-import com.expedia.graphql.schema.extensions.isEnum
+import com.expedia.graphql.schema.extensions.isList
 import com.expedia.graphql.schema.extensions.wrapInNonNull
 import com.expedia.graphql.schema.generator.models.KGraphQLType
 import graphql.schema.GraphQLType
@@ -43,7 +44,8 @@ internal open class TypeBuilder constructor(val generator: SchemaGenerator) {
 
     private fun getGraphQLType(kClass: KClass<*>, inputType: Boolean, type: KType): GraphQLType = when {
         kClass.isEnum() -> @Suppress("UNCHECKED_CAST") (generator.enumType(kClass as KClass<Enum<*>>))
-        kClass.isGraphQLList() -> generator.listType(type, inputType)
+        kClass.isArray() -> generator.arrayType(type, inputType)
+        kClass.isList() -> generator.listType(type, inputType)
         kClass.isGraphQLUnion() -> generator.unionType(kClass)
         kClass.isGraphQLInterface() -> generator.interfaceType(kClass)
         inputType -> generator.inputObjectType(kClass)

src/main/kotlin/com/expedia/graphql/schema/generator/TypesCache.kt

@@ -4,6 +4,10 @@ import com.expedia.graphql.schema.exceptions.ConflictingTypesException
 import com.expedia.graphql.schema.exceptions.CouldNotGetJvmNameOfKTypeException
 import com.expedia.graphql.schema.exceptions.CouldNotGetNameOfEnumException
 import com.expedia.graphql.schema.exceptions.TypeNotSupportedException
+import com.expedia.graphql.schema.extensions.getKClass
+import com.expedia.graphql.schema.extensions.getTypeOfFirstArgument
+import com.expedia.graphql.schema.extensions.isArray
+import com.expedia.graphql.schema.extensions.isList
 import com.expedia.graphql.schema.generator.models.KGraphQLType
 import graphql.schema.GraphQLType
 import graphql.schema.GraphQLTypeReference
@@ -24,7 +28,7 @@ internal class TypesCache(private val supportedPackages: List<String>) {
         val cachedType = cache[cacheKeyString]
 
         if (cachedType != null) {
-            val kClass = getKClassFromKType(cacheKey.type)
+            val kClass = cacheKey.type.getKClass()
             val isSameNameButNotSameClass = cachedType.kClass != kClass
             when {
                 isSameNameButNotSameClass -> throw ConflictingTypesException(cachedType.kClass, kClass)
@@ -47,35 +51,43 @@ internal class TypesCache(private val supportedPackages: List<String>) {
 
     @Throws(CouldNotGetNameOfEnumException::class)
     private fun getCacheKeyString(cacheKey: TypesCacheKey): String {
-        val kClass = getKClassFromKType(cacheKey.type)
+        val kClass = cacheKey.type.getKClass()
 
         if (kClass.isSubclassOf(Enum::class)) {
             return kClass.simpleName ?: throw CouldNotGetNameOfEnumException(kClass)
         }
 
         val cacheKeyFromTypeName = when {
-            kClass.isSubclassOf(List::class) -> "List<${getJvmErasureNameFromList(cacheKey.type)}>"
-            kClass.java.isArray -> "Array<${getJvmErasureNameFromList(cacheKey.type)}>"
+            kClass.isList() -> "List<${getJvmErasureNameFromList(cacheKey.type)}>"
+            kClass.isArray() -> getArrayTypeName(kClass, cacheKey.type)
             else -> getCacheTypeName(cacheKey.type)
         }
 
         return "$cacheKeyFromTypeName:${cacheKey.inputType}"
     }
 
-    @Suppress("Detekt.UnsafeCast")
-    private fun getKClassFromKType(kType: KType) = kType.classifier as KClass<*>
+    private fun getArrayTypeName(kClass: KClass<*>, kType: KType) = when {
+        kClass.isSubclassOf(IntArray::class) -> IntArray::class.simpleName
+        kClass.isSubclassOf(LongArray::class) -> LongArray::class.simpleName
+        kClass.isSubclassOf(ShortArray::class) -> ShortArray::class.simpleName
+        kClass.isSubclassOf(FloatArray::class) -> FloatArray::class.simpleName
+        kClass.isSubclassOf(DoubleArray::class) -> DoubleArray::class.simpleName
+        kClass.isSubclassOf(CharArray::class) -> CharArray::class.simpleName
+        kClass.isSubclassOf(BooleanArray::class) -> BooleanArray::class.simpleName
+        else -> "Array<${getJvmErasureNameFromList(kType)}>"
+    }
 
     private fun getCacheTypeName(kType: KType): String {
         throwIfTypeIsNotSupported(kType)
         return getJvmErasureName(kType)
     }
 
     private fun getJvmErasureNameFromList(type: KType): String =
-        getJvmErasureName(type.arguments.first().type)
+        getJvmErasureName(type.getTypeOfFirstArgument())
 
     @Throws(CouldNotGetJvmNameOfKTypeException::class)
-    private fun getJvmErasureName(kType: KType?): String =
-        kType?.jvmErasure?.simpleName ?: throw CouldNotGetJvmNameOfKTypeException(kType)
+    private fun getJvmErasureName(kType: KType): String =
+        kType.jvmErasure.simpleName ?: throw CouldNotGetJvmNameOfKTypeException(kType)
 
     @Throws(TypeNotSupportedException::class)
     private fun throwIfTypeIsNotSupported(type: KType) {

src/main/kotlin/com/expedia/graphql/schema/generator/types/ListTypeBuilder.kt

@@ -1,12 +1,16 @@
 package com.expedia.graphql.schema.generator.types
 
+import com.expedia.graphql.schema.extensions.getArrayType
 import com.expedia.graphql.schema.extensions.getTypeOfFirstArgument
 import com.expedia.graphql.schema.generator.SchemaGenerator
 import com.expedia.graphql.schema.generator.TypeBuilder
 import graphql.schema.GraphQLList
 import kotlin.reflect.KType
 
 internal class ListTypeBuilder(generator: SchemaGenerator) : TypeBuilder(generator) {
+    internal fun arrayType(type: KType, inputType: Boolean): GraphQLList =
+        GraphQLList.list(graphQLTypeOf(type.getArrayType(), inputType))
+
     internal fun listType(type: KType, inputType: Boolean): GraphQLList =
         GraphQLList.list(graphQLTypeOf(type.getTypeOfFirstArgument(), inputType))
 }

src/test/kotlin/com/expedia/graphql/schema/extensions/KClassExtensionsTest.kt

@@ -84,10 +84,18 @@ internal class KClassExtensionsTest {
 
     @Test
     fun `test list extension`() {
-        assertTrue(listOf(1)::class.isGraphQLList())
-        assertTrue(arrayListOf(1)::class.isGraphQLList())
-        assertTrue(arrayOf(1)::class.isGraphQLList())
-        assertFalse(MyTestClass::class.isGraphQLList())
+        assertTrue(listOf(1)::class.isList())
+        assertTrue(arrayListOf(1)::class.isList())
+        assertFalse(arrayOf(1)::class.isList())
+        assertFalse(MyTestClass::class.isList())
+    }
+
+    @Test
+    fun `test array extension`() {
+        assertTrue(arrayOf(1)::class.isArray())
+        assertTrue(intArrayOf(1)::class.isArray())
+        assertFalse(listOf(1)::class.isArray())
+        assertFalse(MyTestClass::class.isArray())
     }
 
     @Test

src/test/kotlin/com/expedia/graphql/schema/generator/PolymorphicTests.kt

@@ -20,17 +20,15 @@ internal class PolymorphicTests {
 
         val graphqlType = schema.getType("BodyPart") as? GraphQLUnionType
         assertNotNull(graphqlType)
-        graphqlType?.let { union ->
-            assertTrue(union.types.any { it.name == "LeftHand" })
-            assertTrue(union.types.any { it.name == "RightHand" })
-            assertTrue(union.types.any { it.name == "Arm" })
-        }
+        assertTrue(graphqlType.types.any { it.name == "LeftHand" })
+        assertTrue(graphqlType.types.any { it.name == "RightHand" })
+        assertTrue(graphqlType.types.any { it.name == "Arm" })
 
         assertNotNull(schema.getType("RightHand"))
         val leftHandType = schema.getType("LeftHand") as? GraphQLObjectType
 
         assertNotNull(leftHandType)
-        assertNotNull(leftHandType?.getFieldDefinition("associatedWith"))
+        assertNotNull(leftHandType.getFieldDefinition("associatedWith"))
     }
 
     @Test
@@ -66,17 +64,12 @@ internal class PolymorphicTests {
 
         val carType = schema.getType("Car") as? GraphQLObjectType
         assertNotNull(carType)
-
-        carType?.let {
-            assertNotNull(it.getFieldDefinition("model"))
-            assertNotNull(it.getFieldDefinition("color"))
-        }
+        assertNotNull(carType.getFieldDefinition("model"))
+        assertNotNull(carType.getFieldDefinition("color"))
 
         val productType = schema.getType("Product") as? GraphQLUnionType
         assertNotNull(productType)
-        productType?.let {
-            assertTrue { it.types.contains(carType) }
-        }
+        assertTrue(productType.types.contains(carType))
     }
 
     @Test

src/test/kotlin/com/expedia/graphql/schema/generator/SchemaGeneratorTest.kt

@@ -241,9 +241,9 @@ class SchemaGeneratorTest {
         val bobChildren = res?.get("children") as? List<Map<String, Any>>
         assertNotNull(bobChildren)
 
-        val firstChild = bobChildren?.get(0)
-        assertEquals("Alice", firstChild?.get("name"))
-        assertNull(firstChild?.get("children"))
+        val firstChild = bobChildren.get(0)
+        assertEquals("Alice", firstChild["name"])
+        assertNull(firstChild["children"])
     }
 
     @Test
@@ -281,8 +281,7 @@ class SchemaGeneratorTest {
     }
 
     class QueryWithArray {
-        @Suppress("Detekt.ArrayPrimitive")
-        fun sumOf(ints: Array<Int>): Int = ints.sum()
+        fun sumOf(ints: IntArray): Int = ints.sum()
         fun sumOfComplexArray(objects: Array<ComplexWrappingType>): Int = objects.map { it.value }.sum()
     }