[generator] allow interfaces to implement other interfaces (#732)

Adding support for creating schemas where interfaces implement other interfaces

Resolves: #589

Author: dariuszkuc

graphql-kotlin-schema-generator/build.gradle.kts

@@ -28,7 +28,7 @@ tasks {
                 limit {
                     counter = "BRANCH"
                     value = "COVEREDRATIO"
-                    minimum = "0.96".toBigDecimal()
+                    minimum = "0.95".toBigDecimal()
                 }
             }
         }

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

@@ -51,9 +51,8 @@ internal fun KClass<*>.getValidSuperclasses(hooks: SchemaGeneratorHooks): List<K
     this.superclasses
         .filter { hooks.isValidSuperclass(it) }
         .filter { kClass -> superclassFilters.all { it.invoke(kClass) } }
-        .ifEmpty {
-            this.superclasses.flatMap { it.getValidSuperclasses(hooks) }
-        }
+        .plus(this.superclasses.flatMap { it.getValidSuperclasses(hooks) })
+        .distinct()
 
 internal fun KClass<*>.findConstructorParameter(name: String): KParameter? =
     this.primaryConstructor?.findParameterByName(name)

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

@@ -16,7 +16,7 @@
 
 package com.expediagroup.graphql.generator.types
 
-import com.expediagroup.graphql.exceptions.InvalidInterfaceException
+import com.expediagroup.graphql.extensions.unwrapType
 import com.expediagroup.graphql.generator.SchemaGenerator
 import com.expediagroup.graphql.generator.extensions.getGraphQLDescription
 import com.expediagroup.graphql.generator.extensions.getSimpleName
@@ -27,15 +27,11 @@ import com.expediagroup.graphql.generator.extensions.isGraphQLIgnored
 import com.expediagroup.graphql.generator.extensions.safeCast
 import graphql.TypeResolutionEnvironment
 import graphql.schema.GraphQLInterfaceType
+import graphql.schema.GraphQLTypeReference
 import kotlin.reflect.KClass
 import kotlin.reflect.full.createType
 
 internal fun generateInterface(generator: SchemaGenerator, kClass: KClass<*>): GraphQLInterfaceType {
-    // Interfaces can not implement another interface in GraphQL
-    if (kClass.getValidSuperclasses(generator.config.hooks).isNotEmpty()) {
-        throw InvalidInterfaceException(klazz = kClass)
-    }
-
     val builder = GraphQLInterfaceType.newInterface()
 
     builder.name(kClass.getSimpleName())
@@ -45,6 +41,15 @@ internal fun generateInterface(generator: SchemaGenerator, kClass: KClass<*>): G
         builder.withDirective(it)
     }
 
+    kClass.getValidSuperclasses(generator.config.hooks)
+        .map { generateGraphQLType(generator, it.createType()) }
+        .forEach {
+            when (val unwrappedType = it.unwrapType()) {
+                is GraphQLTypeReference -> builder.withInterface(unwrappedType)
+                is GraphQLInterfaceType -> builder.withInterface(unwrappedType)
+            }
+        }
+
     kClass.getValidProperties(generator.config.hooks)
         .forEach { builder.field(generateProperty(generator, it, kClass)) }
 

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

@@ -54,7 +54,7 @@ internal class GenerateInterfaceTest : TypeTestHelper() {
     }
 
     @Test
-    fun `absctract classes generate interfaces`() {
+    fun `abstract classes generate interfaces`() {
         assertEquals(0, generator.additionalTypes.size)
         val result = generateInterface(generator, Shape::class) as? GraphQLInterfaceType
         assertEquals("Shape", result?.name)

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

@@ -17,21 +17,36 @@
 package com.expediagroup.graphql.test.integration
 
 import com.expediagroup.graphql.TopLevelObject
-import com.expediagroup.graphql.exceptions.InvalidInterfaceException
 import com.expediagroup.graphql.testSchemaConfig
 import com.expediagroup.graphql.toSchema
+import graphql.schema.GraphQLInterfaceType
 import org.junit.jupiter.api.Test
-import kotlin.test.assertFailsWith
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
 
 class InterfaceOfInterfaceTest {
 
     @Test
     fun `interface of interface`() {
         val queries = listOf(TopLevelObject(InterfaceOfInterfaceQuery()))
+        val schema = toSchema(queries = queries, config = testSchemaConfig)
+        assertEquals(expected = 1, actual = schema.queryType.fieldDefinitions.size)
 
-        assertFailsWith(InvalidInterfaceException::class) {
-            toSchema(queries = queries, config = testSchemaConfig)
-        }
+        val implementation = schema.getObjectType("MyClass")
+        assertNotNull(implementation)
+        val interfaces = implementation.interfaces
+        assertEquals(2, interfaces.size)
+        assertNotNull(interfaces.firstOrNull { it.name == "FirstLevel" })
+        assertNotNull(interfaces.firstOrNull { it.name == "SecondLevel" })
+
+        val secondLevelInterface = schema.getType("SecondLevel") as? GraphQLInterfaceType
+        assertNotNull(secondLevelInterface)
+        val interfaceOfInterface = secondLevelInterface.interfaces
+        assertEquals(1, interfaceOfInterface.size)
+        assertNotNull(interfaceOfInterface.firstOrNull { it.name == "FirstLevel" })
+
+        val firstLevelInterface = schema.getType("FirstLevel") as? GraphQLInterfaceType
+        assertNotNull(firstLevelInterface)
     }
 
     interface FirstLevel {