feat: allow directive with Enums (#116)

* feat: allow directive with KClass

* test: update test names

* fix: simplify imports

Author: smyrick

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

@@ -4,6 +4,7 @@ import com.expedia.graphql.SchemaGeneratorConfig
 import com.expedia.graphql.TopLevelObjectDef
 import com.expedia.graphql.generator.extensions.getValidFunctions
 import com.expedia.graphql.generator.state.SchemaGeneratorState
+import com.expedia.graphql.generator.types.DirectiveTypeBuilder
 import com.expedia.graphql.generator.types.EnumTypeBuilder
 import com.expedia.graphql.generator.types.FunctionTypeBuilder
 import com.expedia.graphql.generator.types.InputObjectTypeBuilder
@@ -16,6 +17,7 @@ import com.expedia.graphql.generator.types.UnionTypeBuilder
 import graphql.schema.GraphQLInterfaceType
 import graphql.schema.GraphQLObjectType
 import graphql.schema.GraphQLSchema
+import kotlin.reflect.KAnnotatedElement
 import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
 import kotlin.reflect.KProperty
@@ -40,6 +42,7 @@ internal class SchemaGenerator(
     private val functionTypeBuilder = FunctionTypeBuilder(this)
     private val enumTypeBuilder = EnumTypeBuilder(this)
     private val scalarTypeBuilder = ScalarTypeBuilder(this)
+    private val directiveTypeBuilder = DirectiveTypeBuilder(this)
 
     internal fun generate(): GraphQLSchema {
         val builder = GraphQLSchema.newSchema()
@@ -121,4 +124,7 @@ internal class SchemaGenerator(
 
     internal fun scalarType(type: KType, annotatedAsID: Boolean = false) =
         scalarTypeBuilder.scalarType(type, annotatedAsID)
+
+    internal fun directives(element: KAnnotatedElement) =
+        directiveTypeBuilder.directives(element)
 }

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

@@ -20,8 +20,9 @@ internal open class TypeBuilder constructor(val generator: SchemaGenerator) {
 
     internal fun graphQLTypeOf(type: KType, inputType: Boolean = false, annotatedAsID: Boolean = false): GraphQLType {
         val hookGraphQLType = config.hooks.willGenerateGraphQLType(type)
-        val graphQLType = hookGraphQLType ?: generator.scalarType(type, annotatedAsID)
-        ?: objectFromReflection(type, inputType)
+        val graphQLType = hookGraphQLType
+            ?: generator.scalarType(type, annotatedAsID)
+            ?: objectFromReflection(type, inputType)
         val typeWithNullityTakenIntoAccount = graphQLType.wrapInNonNull(type)
         config.hooks.didGenerateGraphQLType(type, typeWithNullityTakenIntoAccount)
         return typeWithNullityTakenIntoAccount

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

@@ -2,28 +2,27 @@ package com.expedia.graphql.generator
 
 import com.expedia.graphql.generator.extensions.isGraphQLIgnored
 import com.expedia.graphql.generator.extensions.isPropertyGraphQLIgnored
-import kotlin.reflect.KAnnotatedElement
+import com.expedia.graphql.generator.extensions.qualifiedName
 import kotlin.reflect.KCallable
 import kotlin.reflect.KClass
-import kotlin.reflect.KFunction
 import kotlin.reflect.KProperty
 import kotlin.reflect.KVisibility
 
 private typealias CallableFilter = (KCallable<*>) -> Boolean
-private typealias AnnotatedElementFilter = (KAnnotatedElement) -> Boolean
 private typealias PropertyFilter = (KProperty<*>, KClass<*>) -> Boolean
-private typealias FunctionFilter = (KFunction<*>) -> Boolean
 
-private val blackListFunctions: List<String> = listOf("annotationType", "toString", "copy", "equals", "hashCode")
+private val blacklistFunctions: List<String> = listOf("annotationType", "toString", "copy", "equals", "hashCode")
+private val blacklistTypes: List<String> = listOf("kotlin.reflect.KClass")
 private val componentFunctionRegex = Regex("component([0-9]+)")
 
 private val isPublic: CallableFilter = { it.visibility == KVisibility.PUBLIC }
 private val isPropertyPublic: PropertyFilter = { prop, _ -> isPublic(prop) }
-private val isNotGraphQLIgnored: AnnotatedElementFilter = { it.isGraphQLIgnored().not() }
+private val isNotGraphQLIgnored: CallableFilter = { it.isGraphQLIgnored().not() }
 private val isPropertyNotGraphQLIgnored: PropertyFilter = { prop, parentClass -> prop.isPropertyGraphQLIgnored(parentClass).not() }
-private val isBlacklistedFunction: FunctionFilter = { blackListFunctions.contains(it.name) }
-private val isComponentFunction: FunctionFilter = { it.name.matches(componentFunctionRegex) }
-private val isNotBlackListed: FunctionFilter = { (isBlacklistedFunction(it) || isComponentFunction(it)).not() }
+private val isNotBlacklistedType: PropertyFilter = { prop, _ -> blacklistTypes.contains(prop.returnType.qualifiedName).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 propertyFilters: List<PropertyFilter> = listOf(isPropertyPublic, isPropertyNotGraphQLIgnored)
-internal val functionFilters: List<FunctionFilter> = listOf(isPublic, isNotGraphQLIgnored, isNotBlackListed)
+internal val propertyFilters: List<PropertyFilter> = listOf(isPropertyPublic, isNotBlacklistedType, isPropertyNotGraphQLIgnored)
+internal val functionFilters: List<CallableFilter> = listOf(isPublic, isNotGraphQLIgnored, isNotBlacklistedFunction)

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

@@ -0,0 +1,64 @@
+package com.expedia.graphql.generator.types
+
+import com.expedia.graphql.generator.SchemaGenerator
+import com.expedia.graphql.generator.TypeBuilder
+import com.expedia.graphql.generator.extensions.getSimpleName
+import com.expedia.graphql.generator.extensions.getValidProperties
+import com.google.common.base.CaseFormat
+import graphql.schema.GraphQLArgument
+import graphql.schema.GraphQLDirective
+import graphql.schema.GraphQLInputType
+import kotlin.reflect.KAnnotatedElement
+import com.expedia.graphql.annotations.GraphQLDirective as GraphQLDirectiveAnnotation
+
+internal class DirectiveTypeBuilder(generator: SchemaGenerator) : TypeBuilder(generator) {
+
+    internal fun directives(element: KAnnotatedElement): List<GraphQLDirective> =
+        element.annotations.asSequence()
+            .mapNotNull { it.getDirectiveInfo() }
+            .map(this::getDirective)
+            .toList()
+
+    private fun getDirective(directiveInfo: DirectiveInfo): GraphQLDirective {
+
+        val directiveClass = directiveInfo.directive.annotationClass
+
+        val builder = GraphQLDirective.newDirective()
+            .name(directiveInfo.effectiveName)
+            .description(directiveInfo.directiveAnnotation.description)
+
+        directiveInfo.directiveAnnotation.locations.forEach {
+            builder.validLocation(it)
+        }
+
+        directiveClass.getValidProperties(config.hooks).forEach { prop ->
+            val propertyName = prop.name
+            val value = prop.call(directiveInfo.directive)
+            val type = graphQLTypeOf(prop.returnType)
+
+            val argument = GraphQLArgument.newArgument()
+                .name(propertyName)
+                .value(value)
+                .type(type as? GraphQLInputType)
+                .build()
+
+            builder.argument(argument)
+        }
+
+        return builder.build()
+    }
+}
+
+private fun String.normalizeDirectiveName() = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, this)
+
+private fun Annotation.getDirectiveInfo(): DirectiveInfo? = this.annotationClass.annotations
+    .filterIsInstance(GraphQLDirectiveAnnotation::class.java)
+    .map { DirectiveInfo(this, it) }
+    .firstOrNull()
+
+private data class DirectiveInfo(val directive: Annotation, val directiveAnnotation: GraphQLDirectiveAnnotation) {
+    val effectiveName: String = when {
+        directiveAnnotation.name.isNotEmpty() -> directiveAnnotation.name
+        else -> directive.annotationClass.getSimpleName().normalizeDirectiveName()
+    }
+}

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

@@ -4,7 +4,6 @@ import com.expedia.graphql.KotlinDataFetcher
 import com.expedia.graphql.Parameter
 import com.expedia.graphql.generator.SchemaGenerator
 import com.expedia.graphql.generator.TypeBuilder
-import com.expedia.graphql.generator.extensions.directives
 import com.expedia.graphql.generator.extensions.getDeprecationReason
 import com.expedia.graphql.generator.extensions.getGraphQLDescription
 import com.expedia.graphql.generator.extensions.getName
@@ -32,7 +31,7 @@ internal class FunctionTypeBuilder(generator: SchemaGenerator) : TypeBuilder(gen
             builder.deprecate(it)
         }
 
-        fn.directives(generator).forEach {
+        generator.directives(fn).forEach {
             builder.withDirective(it)
             state.directives.add(it)
         }
@@ -68,7 +67,7 @@ internal class FunctionTypeBuilder(generator: SchemaGenerator) : TypeBuilder(gen
             .description(parameter.getGraphQLDescription() ?: parameter.type.getGraphQLDescription())
             .type(graphQLTypeOf(parameter.type, true) as GraphQLInputType)
 
-        parameter.directives(generator).forEach {
+        generator.directives(parameter).forEach {
             builder.withDirective(it)
             state.directives.add(it)
         }

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

@@ -2,7 +2,6 @@ package com.expedia.graphql.generator.types
 
 import com.expedia.graphql.generator.SchemaGenerator
 import com.expedia.graphql.generator.TypeBuilder
-import com.expedia.graphql.generator.extensions.directives
 import com.expedia.graphql.generator.extensions.getGraphQLDescription
 import com.expedia.graphql.generator.extensions.getSimpleName
 import com.expedia.graphql.generator.extensions.getValidFunctions
@@ -25,7 +24,7 @@ internal class ObjectTypeBuilder(generator: SchemaGenerator) : TypeBuilder(gener
             builder.name(kClass.getSimpleName())
             builder.description(kClass.getGraphQLDescription())
 
-            kClass.directives(generator).forEach {
+            generator.directives(kClass).forEach {
                 builder.withDirective(it)
                 state.directives.add(it)
             }

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

@@ -1,11 +1,10 @@
 package com.expedia.graphql.generator.types
 
-import com.expedia.graphql.generator.extensions.directives
+import com.expedia.graphql.generator.SchemaGenerator
+import com.expedia.graphql.generator.TypeBuilder
 import com.expedia.graphql.generator.extensions.getPropertyDeprecationReason
 import com.expedia.graphql.generator.extensions.getPropertyDescription
 import com.expedia.graphql.generator.extensions.isPropertyGraphQLID
-import com.expedia.graphql.generator.SchemaGenerator
-import com.expedia.graphql.generator.TypeBuilder
 import graphql.schema.DataFetcherFactory
 import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.GraphQLNonNull
@@ -24,7 +23,7 @@ internal class PropertyTypeBuilder(generator: SchemaGenerator) : TypeBuilder(gen
             .type(propertyType)
             .deprecate(prop.getPropertyDeprecationReason(parentClass))
 
-        prop.directives(generator).forEach {
+        generator.directives(prop).forEach {
             fieldBuilder.withDirective(it)
             state.directives.add(it)
         }

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

@@ -64,7 +64,7 @@ class DirectiveTests {
 
         assertEquals("arenaming", directive.arguments[0].value)
         assertEquals("arg", directive.arguments[0].name)
-        assertEquals(Scalars.GraphQLString, directive.arguments[0].type)
+        assertEquals(GraphQLNonNull(Scalars.GraphQLString), directive.arguments[0].type)
     }
 }
 

src/test/kotlin/com/expedia/graphql/generator/DirectiveTests.kt

@@ -26,6 +26,8 @@ internal class SchemaFiltersTest {
 
         internal val nonPublicProperty: Int = 0
 
+        val kClass: KClass<*> = MyDataClass::class
+
         @GraphQLIgnore
         internal val ignoredProperty: Int = 0
 
@@ -56,6 +58,7 @@ internal class SchemaFiltersTest {
         assertTrue(testProperty(MyClass::publicProperty, MyClass::class))
         assertFalse(testProperty(MyClass::nonPublicProperty, MyClass::class))
         assertFalse(testProperty(MyClass::ignoredProperty, MyClass::class))
+        assertFalse(testProperty(MyClass::kClass, MyDataClass::class))
         assertTrue(testProperty(MyDataClass::id, MyDataClass::class))
         assertFalse(testProperty(MyDataClass::ignoredProperty, MyDataClass::class))
     }