feat: add superclass hooks (#139)

* feat: add superclass hooks

* test: superclassFilters unit tests

Author: smyrick

src/main/kotlin/com/expedia/graphql/generator/extensions/kCallableExtensions.kt

@@ -0,0 +1,6 @@
+package com.expedia.graphql.generator.extensions
+
+import kotlin.reflect.KCallable
+import kotlin.reflect.KVisibility
+
+internal fun KCallable<*>.isPublic(): Boolean = this.visibility == KVisibility.PUBLIC

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

@@ -1,8 +1,9 @@
 package com.expedia.graphql.generator.extensions
 
 import com.expedia.graphql.exceptions.CouldNotGetNameOfKClassException
-import com.expedia.graphql.generator.functionFilters
-import com.expedia.graphql.generator.propertyFilters
+import com.expedia.graphql.generator.filters.functionFilters
+import com.expedia.graphql.generator.filters.propertyFilters
+import com.expedia.graphql.generator.filters.superclassFilters
 import com.expedia.graphql.hooks.SchemaGeneratorHooks
 import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
@@ -14,6 +15,7 @@ import kotlin.reflect.full.declaredMemberProperties
 import kotlin.reflect.full.findParameterByName
 import kotlin.reflect.full.isSubclassOf
 import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.full.superclasses
 
 internal fun KClass<*>.getValidProperties(hooks: SchemaGeneratorHooks): List<KProperty<*>> =
     this.declaredMemberProperties
@@ -25,6 +27,11 @@ internal fun KClass<*>.getValidFunctions(hooks: SchemaGeneratorHooks): List<KFun
         .filter { hooks.isValidFunction(it) }
         .filter { func -> functionFilters.all { it.invoke(func) } }
 
+internal fun KClass<*>.getValidSuperclasses(hooks: SchemaGeneratorHooks): List<KClass<*>> =
+    this.superclasses
+        .filter { hooks.isValidSuperclass(it) }
+        .filter { kClass -> superclassFilters.all { it.invoke(kClass) } }
+
 internal fun KClass<*>.findConstructorParamter(name: String): KParameter? =
     this.primaryConstructor?.findParameterByName(name)
 

src/main/kotlin/com/expedia/graphql/generator/filters/callableFilters.kt

@@ -0,0 +1,18 @@
+package com.expedia.graphql.generator.filters
+
+import com.expedia.graphql.generator.extensions.isGraphQLIgnored
+import com.expedia.graphql.generator.extensions.isPublic
+import kotlin.reflect.KCallable
+
+private typealias CallableFilter = (KCallable<*>) -> Boolean
+
+private val blacklistFunctions: List<String> = listOf("annotationType", "toString", "copy", "equals", "hashCode")
+private val componentFunctionRegex = Regex("component([0-9]+)")
+
+private val isPublic: CallableFilter = { it.isPublic() }
+private val isNotGraphQLIgnored: CallableFilter = { it.isGraphQLIgnored().not() }
+private val isBlacklistedFunction: CallableFilter = { blacklistFunctions.contains(it.name) }
+private val isComponentFunction: CallableFilter = { it.name.matches(componentFunctionRegex) }
+private val isNotBlacklistedFunction: CallableFilter = { isBlacklistedFunction(it).not() && isComponentFunction(it).not() }
+
+internal val functionFilters: List<CallableFilter> = listOf(isPublic, isNotGraphQLIgnored, isNotBlacklistedFunction)

src/main/kotlin/com/expedia/graphql/generator/filters/propertyFilters.kt

@@ -0,0 +1,17 @@
+package com.expedia.graphql.generator.filters
+
+import com.expedia.graphql.generator.extensions.isPropertyGraphQLIgnored
+import com.expedia.graphql.generator.extensions.isPublic
+import com.expedia.graphql.generator.extensions.qualifiedName
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+
+private typealias PropertyFilter = (KProperty<*>, KClass<*>) -> Boolean
+
+private val blacklistTypes: List<String> = listOf("kotlin.reflect.KClass")
+
+private val isPropertyPublic: PropertyFilter = { prop, _ -> prop.isPublic() }
+private val isPropertyNotGraphQLIgnored: PropertyFilter = { prop, parentClass -> prop.isPropertyGraphQLIgnored(parentClass).not() }
+private val isNotBlacklistedType: PropertyFilter = { prop, _ -> blacklistTypes.contains(prop.returnType.qualifiedName).not() }
+
+internal val propertyFilters: List<PropertyFilter> = listOf(isPropertyPublic, isNotBlacklistedType, isPropertyNotGraphQLIgnored)

src/main/kotlin/com/expedia/graphql/generator/filters/superclassFilters.kt

@@ -0,0 +1,14 @@
+package com.expedia.graphql.generator.filters
+
+import com.expedia.graphql.generator.extensions.isInterface
+import com.expedia.graphql.generator.extensions.isPublic
+import com.expedia.graphql.generator.extensions.isUnion
+import kotlin.reflect.KClass
+
+private typealias SuperclassFilter = (KClass<*>) -> Boolean
+
+private val isPublic: SuperclassFilter = { it.isPublic() }
+private val isInterface: SuperclassFilter = { it.isInterface() }
+private val isNotUnion: SuperclassFilter = { it.isUnion().not() }
+
+internal val superclassFilters: List<SuperclassFilter> = listOf(isPublic, isInterface, isNotUnion)

src/main/kotlin/com/expedia/graphql/generator/schemaFilters.kt

@@ -6,15 +6,12 @@ import com.expedia.graphql.generator.extensions.getGraphQLDescription
 import com.expedia.graphql.generator.extensions.getSimpleName
 import com.expedia.graphql.generator.extensions.getValidFunctions
 import com.expedia.graphql.generator.extensions.getValidProperties
-import com.expedia.graphql.generator.extensions.isInterface
-import com.expedia.graphql.generator.extensions.isPublic
-import com.expedia.graphql.generator.extensions.isUnion
+import com.expedia.graphql.generator.extensions.getValidSuperclasses
 import graphql.schema.GraphQLInterfaceType
 import graphql.schema.GraphQLObjectType
 import graphql.schema.GraphQLType
 import kotlin.reflect.KClass
 import kotlin.reflect.full.createType
-import kotlin.reflect.full.superclasses
 
 internal class ObjectTypeBuilder(generator: SchemaGenerator) : TypeBuilder(generator) {
 
@@ -32,9 +29,7 @@ internal class ObjectTypeBuilder(generator: SchemaGenerator) : TypeBuilder(gener
             if (interfaceType != null) {
                 builder.withInterface(interfaceType)
             } else {
-                kClass.superclasses
-                    .asSequence()
-                    .filter { it.isPublic() && it.isInterface() && !it.isUnion() }
+                kClass.getValidSuperclasses(config.hooks)
                     .map { objectFromReflection(it.createType(), false) as? GraphQLInterfaceType }
                     .forEach { builder.withInterface(it) }
             }

src/main/kotlin/com/expedia/graphql/generator/types/ObjectTypeBuilder.kt

@@ -5,6 +5,7 @@ import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.GraphQLSchema
 import graphql.schema.GraphQLType
 import java.util.concurrent.CompletableFuture
+import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
 import kotlin.reflect.KProperty
 import kotlin.reflect.KType
@@ -39,6 +40,13 @@ interface SchemaGeneratorHooks {
             type
         }
 
+    /**
+     * Called when looking at the KClass superclasses to determine if it valid for adding to the generated schema.
+     * If any filter returns false, it is rejected.
+     */
+    @Suppress("Detekt.FunctionOnlyReturningConstant")
+    fun isValidSuperclass(kClass: KClass<*>): Boolean = true
+
     /**
      * Called when looking at the KClass properties to determine if it valid for adding to the generated schema.
      * If any filter returns false, it is rejected.

src/main/kotlin/com/expedia/graphql/hooks/SchemaGeneratorHooks.kt

@@ -0,0 +1,28 @@
+package com.expedia.graphql.generator.extensions
+
+import org.junit.jupiter.api.Test
+import kotlin.reflect.full.functions
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+internal class KCallableExtensionsKtTest {
+
+    @Suppress("Detekt.FunctionOnlyReturningConstant", "Detekt.UnusedPrivateMember")
+    internal open class MyTestClass {
+        fun public() = 1
+
+        protected fun protected() = 2
+
+        internal fun internal() = 3
+
+        private fun private() = 4
+    }
+
+    @Test
+    fun isPublic() {
+        assertTrue(MyTestClass::public.isPublic())
+        assertFalse(MyTestClass::internal.isPublic())
+        assertFalse(MyTestClass::class.functions.find { it.name == "protected" }?.isPublic().isTrue())
+        assertFalse(MyTestClass::class.functions.find { it.name == "private" }?.isPublic().isTrue())
+    }
+}