feat: allow directives on other types (#174)

* feat: allow directives on other types

* feat: add example directives and SDL controller

Author: smyrick

example/src/main/kotlin/com/expedia/graphql/sample/Application.kt

@@ -64,6 +64,7 @@ class Application {
         SchemaPrinter.Options.defaultOptions()
             .includeScalarTypes(true)
             .includeExtendedScalarTypes(true)
+            .includeIntrospectionTypes(true)
             .includeSchemaDefintion(true)
     )
 

example/src/main/kotlin/com/expedia/graphql/sample/controllers/SDLController.kt

@@ -0,0 +1,20 @@
+package com.expedia.graphql.sample.controllers
+
+import graphql.schema.GraphQLSchema
+import graphql.schema.idl.SchemaPrinter
+import org.springframework.http.MediaType
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+class SDLController(
+    val schema: GraphQLSchema,
+    val schemaPrinter: SchemaPrinter
+) {
+
+    @GetMapping(
+        produces = [MediaType.TEXT_PLAIN_VALUE],
+        value = ["/sdl"]
+    )
+    fun sdl() = schemaPrinter.print(schema)
+}

example/src/main/kotlin/com/expedia/graphql/sample/directives/SimpleDirective.kt

@@ -0,0 +1,44 @@
+package com.expedia.graphql.sample.directives
+
+import com.expedia.graphql.annotations.GraphQLDirective
+import graphql.introspection.Introspection.DirectiveLocation.ARGUMENT_DEFINITION
+import graphql.introspection.Introspection.DirectiveLocation.ENUM
+import graphql.introspection.Introspection.DirectiveLocation.ENUM_VALUE
+import graphql.introspection.Introspection.DirectiveLocation.FIELD
+import graphql.introspection.Introspection.DirectiveLocation.FIELD_DEFINITION
+import graphql.introspection.Introspection.DirectiveLocation.FRAGMENT_DEFINITION
+import graphql.introspection.Introspection.DirectiveLocation.FRAGMENT_SPREAD
+import graphql.introspection.Introspection.DirectiveLocation.INLINE_FRAGMENT
+import graphql.introspection.Introspection.DirectiveLocation.INPUT_FIELD_DEFINITION
+import graphql.introspection.Introspection.DirectiveLocation.INPUT_OBJECT
+import graphql.introspection.Introspection.DirectiveLocation.INTERFACE
+import graphql.introspection.Introspection.DirectiveLocation.MUTATION
+import graphql.introspection.Introspection.DirectiveLocation.OBJECT
+import graphql.introspection.Introspection.DirectiveLocation.QUERY
+import graphql.introspection.Introspection.DirectiveLocation.SCALAR
+import graphql.introspection.Introspection.DirectiveLocation.SCHEMA
+import graphql.introspection.Introspection.DirectiveLocation.UNION
+
+/**
+ * Valid on all locations
+ */
+@GraphQLDirective(locations = [
+    QUERY,
+    MUTATION,
+    FIELD,
+    FRAGMENT_DEFINITION,
+    FRAGMENT_SPREAD,
+    INLINE_FRAGMENT,
+    SCHEMA,
+    SCALAR,
+    OBJECT,
+    FIELD_DEFINITION,
+    ARGUMENT_DEFINITION,
+    INTERFACE,
+    UNION,
+    ENUM,
+    ENUM_VALUE,
+    INPUT_OBJECT,
+    INPUT_FIELD_DEFINITION
+])
+annotation class SimpleDirective

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

@@ -0,0 +1,18 @@
+package com.expedia.graphql.sample.query
+
+import com.expedia.graphql.sample.directives.SimpleDirective
+import org.springframework.stereotype.Component
+
+@Component
+class DirectiveQuery : Query {
+
+    @SimpleDirective
+    fun directiveFunction(@SimpleDirective value: String) = SimpleDataClass(value)
+}
+
+@SimpleDirective
+data class SimpleDataClass(
+
+    @SimpleDirective
+    val value: String = "goodbye"
+)

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

@@ -14,10 +14,9 @@ import com.expedia.graphql.annotations.GraphQLDirective as GraphQLDirectiveAnnot
 internal class DirectiveTypeBuilder(generator: SchemaGenerator) : TypeBuilder(generator) {
 
     internal fun directives(element: KAnnotatedElement): List<GraphQLDirective> =
-        element.annotations.asSequence()
+        element.annotations
             .mapNotNull { it.getDirectiveInfo() }
             .map(this::getDirective)
-            .toList()
 
     private fun getDirective(directiveInfo: DirectiveInfo): GraphQLDirective {
 

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

@@ -16,18 +16,27 @@ internal class EnumTypeBuilder(generator: SchemaGenerator) : TypeBuilder(generat
         enumBuilder.name(kClass.getSimpleName())
         enumBuilder.description(kClass.getGraphQLDescription())
 
+        generator.directives(kClass).forEach {
+            enumBuilder.withDirective(it)
+        }
+
         kClass.java.enumConstants.forEach {
-            val valueBuilder = GraphQLEnumValueDefinition.newEnumValueDefinition()
+            enumBuilder.value(getEnumValueDefinition(it, kClass))
+        }
 
-            valueBuilder.name(it.name)
-            valueBuilder.value(it.name)
+        return enumBuilder.build()
+    }
 
-            val valueField = kClass.java.getField(it.name)
-            valueBuilder.description(valueField.getGraphQLDescription())
-            valueBuilder.deprecationReason(valueField.getDeprecationReason())
+    private fun getEnumValueDefinition(enum: Enum<*>, kClass: KClass<out Enum<*>>): GraphQLEnumValueDefinition {
+        val valueBuilder = GraphQLEnumValueDefinition.newEnumValueDefinition()
 
-            enumBuilder.value(valueBuilder.build())
-        }
-        return enumBuilder.build()
+        valueBuilder.name(enum.name)
+        valueBuilder.value(enum.name)
+
+        val valueField = kClass.java.getField(enum.name)
+        valueBuilder.description(valueField.getGraphQLDescription())
+        valueBuilder.deprecationReason(valueField.getDeprecationReason())
+
+        return valueBuilder.build()
     }
 }

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

@@ -21,6 +21,10 @@ internal class InputObjectTypeBuilder(generator: SchemaGenerator) : TypeBuilder(
         builder.name(kClass.getSimpleName(isInputClass = true))
         builder.description(kClass.getGraphQLDescription())
 
+        generator.directives(kClass).forEach {
+            builder.withDirective(it)
+        }
+
         // It does not make sense to run functions against the input types so we only process the properties
         kClass.getValidProperties(config.hooks)
             .forEach { builder.field(inputProperty(it, kClass)) }
@@ -35,6 +39,10 @@ internal class InputObjectTypeBuilder(generator: SchemaGenerator) : TypeBuilder(
         builder.name(prop.name)
         builder.type(graphQLTypeOf(prop.returnType, true, prop.isPropertyGraphQLID(parentClass)).safeCast<GraphQLInputType>())
 
+        generator.directives(prop).forEach {
+            builder.withDirective(it)
+        }
+
         return builder.build()
     }
 }

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

@@ -20,6 +20,10 @@ internal class InterfaceTypeBuilder(generator: SchemaGenerator) : TypeBuilder(ge
             builder.name(kClass.getSimpleName())
             builder.description(kClass.getGraphQLDescription())
 
+            generator.directives(kClass).forEach {
+                builder.withDirective(it)
+            }
+
             kClass.getValidProperties(config.hooks)
                 .forEach { builder.field(generator.property(it, kClass)) }
 

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

@@ -24,6 +24,10 @@ internal class MutationTypeBuilder(generator: SchemaGenerator) : TypeBuilder(gen
                 throw InvalidMutationTypeException(mutation.kClass)
             }
 
+            generator.directives(mutation.kClass).forEach {
+                mutationBuilder.withDirective(it)
+            }
+
             mutation.kClass.getValidFunctions(config.hooks)
                 .forEach {
                     val function = generator.function(it, mutation.obj)

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

@@ -26,6 +26,10 @@ internal class QueryTypeBuilder(generator: SchemaGenerator) : TypeBuilder(genera
                 throw InvalidQueryTypeException(query.kClass)
             }
 
+            generator.directives(query.kClass).forEach {
+                queryBuilder.withDirective(it)
+            }
+
             query.kClass.getValidFunctions(config.hooks)
                 .forEach {
                     val function = generator.function(it, query.obj)

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

@@ -23,6 +23,10 @@ internal class UnionTypeBuilder(generator: SchemaGenerator) : TypeBuilder(genera
             builder.description(kClass.getGraphQLDescription())
             builder.typeResolver { env: TypeResolutionEnvironment -> env.schema.getObjectType(env.getObject<Any>().javaClass.simpleName) }
 
+            generator.directives(kClass).forEach {
+                builder.withDirective(it)
+            }
+
             val implementations = subTypeMapper.getSubTypesOf(kClass)
             implementations.forEach {
                 val objectType = state.cache.get(TypesCacheKey(it.kotlin.createType(), false))

src/test/kotlin/com/expedia/graphql/generator/types/EnumTypeTest.kt renamed to src/test/kotlin/com/expedia/graphql/generator/types/EnumTypeBuilderTest.kt

@@ -1,19 +1,22 @@
 package com.expedia.graphql.generator.types
 
 import com.expedia.graphql.annotations.GraphQLDescription
+import com.expedia.graphql.utils.SimpleDirective
 import org.junit.jupiter.api.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
-internal class EnumTypeTest : TypeTestHelper() {
+internal class EnumTypeBuilderTest : TypeTestHelper() {
 
     @Suppress("Detekt.UnusedPrivateClass")
     @GraphQLDescription("MyTestEnum description")
+    @SimpleDirective
     private enum class MyTestEnum {
         @GraphQLDescription("enum 'ONE' description")
+        @SimpleDirective
         ONE,
 
         @GraphQLDescription("enum 'TWO' description")
@@ -67,4 +70,11 @@ internal class EnumTypeTest : TypeTestHelper() {
         assertTrue(three.isDeprecated)
         assertEquals("THREE is out, replace with TWO", three.deprecationReason)
     }
+
+    @Test
+    fun `Enum classes can have directives`() {
+        val gqlEnum = assertNotNull(builder.enumType(MyTestEnum::class))
+        assertEquals(1, gqlEnum.directives.size)
+        assertEquals("simpleDirective", gqlEnum.directives.first().name)
+    }
 }

src/test/kotlin/com/expedia/graphql/generator/types/InputObjectTypeBuilderTest.kt

@@ -0,0 +1,50 @@
+package com.expedia.graphql.generator.types
+
+import com.expedia.graphql.annotations.GraphQLDescription
+import com.expedia.graphql.utils.SimpleDirective
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+internal class InputObjectTypeBuilderTest : TypeTestHelper() {
+
+    private lateinit var builder: InputObjectTypeBuilder
+
+    override fun beforeTest() {
+        builder = InputObjectTypeBuilder(generator)
+    }
+
+    @Suppress("Detekt.UnusedPrivateClass")
+    @GraphQLDescription("The truth")
+    @SimpleDirective
+    private class InputClass {
+
+        @SimpleDirective
+        val myField: String = "car"
+    }
+
+    @Test
+    fun `Test naming`() {
+        val result = builder.inputObjectType(InputClass::class)
+        assertEquals("InputClassInput", result.name)
+    }
+
+    @Test
+    fun `Test description`() {
+        val result = builder.inputObjectType(InputClass::class)
+        assertEquals("The truth", result.description)
+    }
+
+    @Test
+    fun `directives should be on input objects`() {
+        val result = builder.inputObjectType(InputClass::class)
+        assertEquals(1, result.directives.size)
+        assertEquals("simpleDirective", result.directives.first().name)
+    }
+
+    @Test
+    fun `directives should be on input object fields`() {
+        val result = builder.inputObjectType(InputClass::class)
+        assertEquals(1, result.fields.first().directives.size)
+        assertEquals("simpleDirective", result.fields.first().directives.first().name)
+    }
+}

src/test/kotlin/com/expedia/graphql/generator/types/InputObjectTypeTest.kt

@@ -1,11 +1,12 @@
 package com.expedia.graphql.generator.types
 
 import com.expedia.graphql.annotations.GraphQLDescription
+import com.expedia.graphql.utils.SimpleDirective
 import graphql.schema.GraphQLInterfaceType
 import org.junit.jupiter.api.Test
 import kotlin.test.assertEquals
 
-internal class InterfaceTypeTest : TypeTestHelper() {
+internal class InterfaceTypeBuilderTest : TypeTestHelper() {
 
     private lateinit var builder: InterfaceTypeBuilder
 
@@ -15,6 +16,7 @@ internal class InterfaceTypeTest : TypeTestHelper() {
 
     @Suppress("Detekt.UnusedPrivateClass")
     @GraphQLDescription("The truth")
+    @SimpleDirective
     private interface HappyInterface
 
     @Test
@@ -28,4 +30,11 @@ internal class InterfaceTypeTest : TypeTestHelper() {
         val result = builder.interfaceType(HappyInterface::class) as? GraphQLInterfaceType
         assertEquals("The truth", result?.description)
     }
+
+    @Test
+    fun `Interfaces can have directives`() {
+        val result = builder.interfaceType(HappyInterface::class) as? GraphQLInterfaceType
+        assertEquals(1, result?.directives?.size)
+        assertEquals("simpleDirective", result?.directives?.first()?.name)
+    }
 }