[generator] add willGenerateDirective hook (#1461)

Add new `willGenerateDirective` hook that allows for special handling of directive to be build (including returning a prebuild definition). Needed to support Federation v2.

Author: dariuszkuc

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

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

generator/graphql-kotlin-schema-generator/src/main/kotlin/com/expediagroup/graphql/generator/directives/DirectiveMetaInformation.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2022 Expedia, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.expediagroup.graphql.generator.directives
+
+import com.expediagroup.graphql.generator.annotations.GraphQLDirective
+import com.expediagroup.graphql.generator.internal.extensions.getSimpleName
+
+data class DirectiveMetaInformation(val directive: Annotation, val directiveAnnotation: GraphQLDirective, val repeatable: Boolean = false) {
+    val effectiveName: String = when {
+        directiveAnnotation.name.isNotEmpty() -> directiveAnnotation.name
+        else -> directive.annotationClass.getSimpleName().normalizeDirectiveName()
+    }
+}
+
+private fun String.normalizeDirectiveName() = this.replaceFirstChar { it.lowercase() }

generator/graphql-kotlin-schema-generator/src/main/kotlin/com/expediagroup/graphql/generator/hooks/SchemaGeneratorHooks.kt

@@ -16,6 +16,7 @@
 
 package com.expediagroup.graphql.generator.hooks
 
+import com.expediagroup.graphql.generator.directives.DirectiveMetaInformation
 import com.expediagroup.graphql.generator.directives.KotlinDirectiveWiringFactory
 import com.expediagroup.graphql.generator.exceptions.EmptyInputObjectTypeException
 import com.expediagroup.graphql.generator.exceptions.EmptyInterfaceTypeException
@@ -27,6 +28,7 @@ import com.expediagroup.graphql.generator.internal.extensions.isSubclassOf
 import com.expediagroup.graphql.generator.internal.extensions.isValidAdditionalType
 import graphql.schema.FieldCoordinates
 import graphql.schema.GraphQLCodeRegistry
+import graphql.schema.GraphQLDirective
 import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.GraphQLInputObjectType
 import graphql.schema.GraphQLInterfaceType
@@ -61,6 +63,12 @@ interface SchemaGeneratorHooks {
     @Suppress("Detekt.FunctionOnlyReturningConstant")
     fun willGenerateGraphQLType(type: KType): GraphQLType? = null
 
+    /**
+     * Called before generating a directive annotation information to the GraphQL directive.
+     * This allows for special handling of the directive annotations.
+     */
+    fun willGenerateDirective(directiveInfo: DirectiveMetaInformation): GraphQLDirective? = null
+
     /**
      * Called after using reflection to generate the graphql object type but before returning it to the schema builder.
      * This allows for modifying the type info, like description or directives

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

@@ -17,9 +17,9 @@
 package com.expediagroup.graphql.generator.internal.types
 
 import com.expediagroup.graphql.generator.SchemaGenerator
+import com.expediagroup.graphql.generator.directives.DirectiveMetaInformation
 import com.expediagroup.graphql.generator.exceptions.InvalidDirectiveLocationException
 import com.expediagroup.graphql.generator.internal.extensions.getPropertyAnnotations
-import com.expediagroup.graphql.generator.internal.extensions.getSimpleName
 import com.expediagroup.graphql.generator.internal.extensions.getValidProperties
 import com.expediagroup.graphql.generator.internal.extensions.safeCast
 import graphql.introspection.Introspection.DirectiveLocation
@@ -64,9 +64,12 @@ internal fun generateEnumValueDirectives(generator: SchemaGenerator, field: Fiel
             getDirective(generator, it)
         }
 
-private fun getDirective(generator: SchemaGenerator, directiveInfo: DirectiveInfo): GraphQLAppliedDirective {
+private fun getDirective(generator: SchemaGenerator, directiveInfo: DirectiveMetaInformation): GraphQLAppliedDirective {
     val directiveName = directiveInfo.effectiveName
-    val directive = generator.directives.computeIfAbsent(directiveName) {
+    val directiveFromHook = generator.config.hooks.willGenerateDirective(directiveInfo)
+        ?.let { generator.directives.putIfAbsent(directiveName, it) }
+
+    val directive = directiveFromHook ?: generator.directives.computeIfAbsent(directiveName) {
         val builder = GraphQLDirective.newDirective()
             .name(directiveInfo.effectiveName)
             .description(directiveInfo.directiveAnnotation.description)
@@ -91,14 +94,15 @@ private fun getDirective(generator: SchemaGenerator, directiveInfo: DirectiveInf
     return if (directive.arguments.isNotEmpty()) {
         appliedDirective.transform { builder ->
             directiveInfo.directive.annotationClass.getValidProperties(generator.config.hooks).forEach { prop ->
-                val value = prop.call(directiveInfo.directive)
-                val directiveArgument = directive.getArgument(prop.name)
-                    .toAppliedArgument()
-                    .transform { argumentBuilder ->
+                directive.getArgument(prop.name)
+                    ?.toAppliedArgument()
+                    ?.transform { argumentBuilder ->
+                        val value = prop.call(directiveInfo.directive)
                         argumentBuilder.valueProgrammatic(value)
                     }
-
-                builder.argument(directiveArgument)
+                    ?.let { appliedDirectiveArgument ->
+                        builder.argument(appliedDirectiveArgument)
+                    }
             }
         }
     } else {
@@ -118,19 +122,10 @@ private fun generateDirectiveArgument(prop: KProperty<*>, generator: SchemaGener
         .build()
 }
 
-private fun String.normalizeDirectiveName() = this.replaceFirstChar { it.lowercase() }
-
-private fun Annotation.getDirectiveInfo(): DirectiveInfo? = this.annotationClass.annotations
+private fun Annotation.getDirectiveInfo(): DirectiveMetaInformation? = this.annotationClass.annotations
     .filterIsInstance(GraphQLDirectiveAnnotation::class.java)
     .map { graphqlDirective ->
         val isRepeatable = this.annotationClass.hasAnnotation<Repeatable>()
-        DirectiveInfo(this, graphqlDirective, isRepeatable)
+        DirectiveMetaInformation(this, graphqlDirective, isRepeatable)
     }
     .firstOrNull()
-
-private data class DirectiveInfo(val directive: Annotation, val directiveAnnotation: GraphQLDirectiveAnnotation, val repeatable: Boolean = false) {
-    val effectiveName: String = when {
-        directiveAnnotation.name.isNotEmpty() -> directiveAnnotation.name
-        else -> directive.annotationClass.getSimpleName().normalizeDirectiveName()
-    }
-}

generator/graphql-kotlin-schema-generator/src/test/kotlin/com/expediagroup/graphql/generator/hooks/SchemaGeneratorHooksTest.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 Expedia, Inc
+ * Copyright 2022 Expedia, Inc
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,8 +19,10 @@ package com.expediagroup.graphql.generator.hooks
 import com.expediagroup.graphql.generator.SchemaGenerator
 import com.expediagroup.graphql.generator.SchemaGeneratorConfig
 import com.expediagroup.graphql.generator.TopLevelObject
+import com.expediagroup.graphql.generator.annotations.GraphQLDirective
 import com.expediagroup.graphql.generator.annotations.GraphQLIgnore
 import com.expediagroup.graphql.generator.annotations.GraphQLUnion
+import com.expediagroup.graphql.generator.directives.DirectiveMetaInformation
 import com.expediagroup.graphql.generator.exceptions.EmptyInputObjectTypeException
 import com.expediagroup.graphql.generator.exceptions.EmptyInterfaceTypeException
 import com.expediagroup.graphql.generator.exceptions.EmptyObjectTypeException
@@ -361,6 +363,27 @@ class SchemaGeneratorHooksTest {
         assertTrue(graphQLType is GraphQLScalarType)
     }
 
+    @Test
+    fun `calls hook before generating directive`() {
+        class MockSchemaGeneratorHooks : SchemaGeneratorHooks {
+            var hookCalled: Boolean = false
+
+            override fun willGenerateDirective(directiveInfo: DirectiveMetaInformation): graphql.schema.GraphQLDirective? {
+                hookCalled = true
+                return super.willGenerateDirective(directiveInfo)
+            }
+        }
+
+        val hooks = MockSchemaGeneratorHooks()
+        val schema = toSchema(
+            queries = listOf(TopLevelObject(TestDirectiveQuery())),
+            config = getTestSchemaConfigWithHooks(hooks)
+        )
+
+        assertTrue(hooks.hookCalled)
+        assertNotNull(schema.getDirective("custom"))
+    }
+
     class TestQuery {
         fun query(): SomeData = SomeData("someData", 0)
         @MyMetaUnion
@@ -423,4 +446,13 @@ class SchemaGeneratorHooksTest {
     }
 
     class EmptyImplementation(override val id: String) : EmptyInterface
+
+    @GraphQLDirective(name = "custom")
+    annotation class MyCustomDirective
+
+    class TestDirectiveQuery {
+
+        @MyCustomDirective
+        fun directiveQuery(): String = TODO()
+    }
 }

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

@@ -56,6 +56,11 @@ class GenerateDirectiveTest {
         TWO
     }
 
+    enum class InvalidEnumValueDirective {
+        @DirectiveOnObjectOnly
+        INVALID
+    }
+
     @DirectiveOnInputObjectOnly
     @DirectiveOnObjectOnly
     data class MyExampleObject(val value: String)
@@ -196,14 +201,22 @@ class GenerateDirectiveTest {
     }
 
     @Test
-    fun `directives are empty on an enum with no valid annotations`() {
+    fun `directives are empty on an enum value with no valid annotations`() {
         val field = Type::class.java.getField("TWO")
 
         val directives = generateEnumValueDirectives(basicGenerator, field, "Type")
 
         assertEquals(0, directives.size)
     }
 
+    @Test
+    fun `applying directives on enum values with invalid locations will throw exception`() {
+        val field = InvalidEnumValueDirective::class.java.getField("INVALID")
+        assertThrows<InvalidDirectiveLocationException> {
+            generateEnumValueDirectives(basicGenerator, field, "InvalidEnumValueDirective")
+        }
+    }
+
     @Test
     fun `directives are created per each declaration`() {
         val initialCount = basicGenerator.directives.size