Add support for recursive polymorphic types (#46)

Author: gscheibel

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

@@ -241,11 +241,7 @@ internal class SchemaGenerator(
         GraphQLList.list(graphQLTypeOf(type.arguments.first().type!!, inputType))
 
     private fun objectType(kClass: KClass<*>, interfaceType: GraphQLInterfaceType? = null): GraphQLType {
-        if (cache.isTypeUnderConstruction(kClass)) {
-            return GraphQLTypeReference.typeRef(kClass.simpleName)
-        } else {
-            cache.putTypeUnderConstruction(kClass)
-
+        return cache.buildIfNotUnderConstruction(kClass) {
             val builder = GraphQLObjectType.newObject()
 
             builder.name(kClass.simpleName)
@@ -272,7 +268,7 @@ internal class SchemaGenerator(
             kClass.getValidFunctions(config.hooks)
                     .forEach { builder.field(function(it)) }
 
-            return builder.build()
+            builder.build()
         }
     }
 
@@ -301,51 +297,59 @@ internal class SchemaGenerator(
     }
 
     private fun interfaceType(kClass: KClass<*>): GraphQLType {
-        val builder = GraphQLInterfaceType.newInterface()
+        return cache.buildIfNotUnderConstruction(kClass) {
+            val builder = GraphQLInterfaceType.newInterface()
 
-        builder.name(kClass.simpleName)
-        builder.description(kClass.graphQLDescription())
+            builder.name(kClass.simpleName)
+            builder.description(kClass.graphQLDescription())
 
-        kClass.getValidProperties(config.hooks)
-            .forEach { builder.field(property(it)) }
-
-        kClass.getValidFunctions(config.hooks)
-            .forEach { builder.field(function(it, abstract = true)) }
-
-        builder.typeResolver { env: TypeResolutionEnvironment -> env.schema.getObjectType(env.getObject<Any>().javaClass.simpleName) }
-        val interfaceType = builder.build()
-
-        val implementations = getSubTypesOf(kClass)
-        implementations
-            .filterNot { it.kotlin.isAbstract }
-            .forEach {
-                val objectType = objectType(it.kotlin, interfaceType)
-                val key = TypesCacheKey(it.kotlin.createType(), false)
-                additionTypes.add(objectType)
-                cache.put(key, KGraphQLType(it.kotlin, objectType))
-            }
+            kClass.getValidProperties(config.hooks)
+                    .forEach { builder.field(property(it)) }
+
+            kClass.getValidFunctions(config.hooks)
+                    .forEach { builder.field(function(it, abstract = true)) }
+
+            builder.typeResolver { env: TypeResolutionEnvironment -> env.schema.getObjectType(env.getObject<Any>().javaClass.simpleName) }
+            val interfaceType = builder.build()
 
-        return interfaceType
+            val implementations = getSubTypesOf(kClass)
+            implementations
+                    .filterNot { it.kotlin.isAbstract }
+                    .forEach {
+                        val objectType = objectType(it.kotlin, interfaceType)
+                        val key = TypesCacheKey(it.kotlin.createType(), false)
+                        additionTypes.add(objectType)
+                        cache.put(key, KGraphQLType(it.kotlin, objectType))
+                    }
+
+            interfaceType
+        }
     }
 
     private fun unionType(kClass: KClass<*>): GraphQLType {
-        val builder = GraphQLUnionType.newUnionType()
+        return cache.buildIfNotUnderConstruction(kClass) {
+            val builder = GraphQLUnionType.newUnionType()
 
-        builder.name(kClass.simpleName)
-        builder.description(kClass.graphQLDescription())
-        builder.typeResolver { env: TypeResolutionEnvironment -> env.schema.getObjectType(env.getObject<Any>().javaClass.simpleName) }
-
-        val implementations = getSubTypesOf(kClass)
-        implementations
-            .filterNot { it.kotlin.isAbstract }
-            .forEach {
-                val objectType = objectType(it.kotlin)
-                val key = TypesCacheKey(it.kotlin.createType(), false)
-                builder.possibleType(objectType(it.kotlin) as GraphQLObjectType)
-                cache.put(key, KGraphQLType(it.kotlin, objectType))
-            }
+            builder.name(kClass.simpleName)
+            builder.description(kClass.graphQLDescription())
+            builder.typeResolver { env: TypeResolutionEnvironment -> env.schema.getObjectType(env.getObject<Any>().javaClass.simpleName) }
 
-        return builder.build()
+            val implementations = getSubTypesOf(kClass)
+            implementations
+                    .filterNot { it.kotlin.isAbstract }
+                    .forEach {
+                        val objectType = objectType(it.kotlin)
+                        val key = TypesCacheKey(it.kotlin.createType(), false)
+                        if (objectType is GraphQLTypeReference) {
+                            builder.possibleType(objectType)
+                        } else {
+                            builder.possibleType(objectType as GraphQLObjectType)
+                        }
+                        cache.put(key, KGraphQLType(it.kotlin, objectType))
+                    }
+
+            builder.build()
+        }
     }
 
     private fun getSubTypesOf(kclass: KClass<*>): MutableSet<out Class<out Any>> =

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

@@ -7,6 +7,7 @@ import com.expedia.graphql.schema.exceptions.CouldNotGetNameOfEnumException
 import com.expedia.graphql.schema.exceptions.TypeNotSupportedException
 import com.expedia.graphql.schema.models.KGraphQLType
 import graphql.schema.GraphQLType
+import graphql.schema.GraphQLTypeReference
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
 import kotlin.reflect.full.isSubclassOf
@@ -88,7 +89,14 @@ internal class TypesCache(private val supportedPackages: List<String>) {
         }
     }
 
-    fun putTypeUnderConstruction(kClass: KClass<*>) = typeUnderConstruction.add(kClass)
+    private fun putTypeUnderConstruction(kClass: KClass<*>) = typeUnderConstruction.add(kClass)
 
-    fun isTypeUnderConstruction(kClass: KClass<*>) = typeUnderConstruction.contains(kClass)
+    fun buildIfNotUnderConstruction(kClass: KClass<*>, build: (KClass<*>) -> GraphQLType): GraphQLType {
+        return if (typeUnderConstruction.contains(kClass)) {
+            GraphQLTypeReference.typeRef(kClass.simpleName)
+        } else {
+            putTypeUnderConstruction(kClass)
+            build(kClass)
+        }
+    }
 }

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

@@ -23,10 +23,14 @@ class PolymorphicTests {
         graphqlType?.let { union ->
             assertTrue(union.types.any { it.name == "LeftHand" })
             assertTrue(union.types.any { it.name == "RightHand" })
+            assertTrue(union.types.any { it.name == "Arm" })
         }
 
         assertNotNull(schema.getType("RightHand"))
-        assertNotNull(schema.getType("LeftHand"))
+        val leftHandType = schema.getType("LeftHand") as? GraphQLObjectType
+
+        assertNotNull(leftHandType)
+        assertNotNull(leftHandType?.getFieldDefinition("associatedWith"))
     }
 
     @Test
@@ -74,6 +78,14 @@ class PolymorphicTests {
             assertTrue { it.types.contains(carType) }
         }
     }
+
+    @Test
+    fun `Interfaces can declare properties of their own type`() {
+        val schema = toSchema(listOf(TopLevelObjectDef(QueryWithRecursiveType())), config = testSchemaConfig)
+
+        val personType = schema.getType("Person")
+        assertNotNull(personType)
+    }
 }
 
 class QueryWithInterface {
@@ -101,20 +113,25 @@ data class AnImplementation(
 class QueryWithUnion {
     fun query(whichHand: String): BodyPart = when (whichHand) {
         "right" -> RightHand(12)
-        else -> LeftHand("hello world")
+        else -> LeftHand("hello world", Arm(true))
     }
 }
 
 interface BodyPart
 
 data class LeftHand(
-    val field: String
+    val field: String,
+    val associatedWith: BodyPart
 ) : BodyPart
 
 data class RightHand(
     val property: Int
 ) : BodyPart
 
+data class Arm(
+    val value: Boolean
+) : BodyPart
+
 class QueryWithInterfaceAnUnion {
     fun product(): Product = Car("DB9", "black")
 }
@@ -126,3 +143,20 @@ interface Vehicle {
 interface Product
 
 data class Car(val model: String, override val color: String) : Vehicle, Product
+
+class QueryWithRecursiveType {
+    fun query(): Person = Father("knock knock", Child())
+}
+
+interface Person {
+    val child: Person?
+}
+
+data class Child(
+    override val child: Person? = null
+) : Person
+
+data class Father(
+    val dadJoke: String,
+    override val child: Person?
+) : Person