Force manual wirings to take precedence over wiring factory (#96)

dariuszkuc · brennantaylor · commit f674fd4ec244 · 2018-12-18T07:31:53.000-08:00
* Force manual wirings to take precedence over wiring factory

* Update directive wiring helper unit tests
diff --git a/example/src/main/kotlin/com.expedia.graphql.sample/Application.kt b/example/src/main/kotlin/com.expedia.graphql.sample/Application.kt
@@ -4,11 +4,13 @@ import com.expedia.graphql.TopLevelObjectDef
 import com.expedia.graphql.sample.context.MyGraphQLContextBuilder
 import com.expedia.graphql.sample.dataFetchers.SpringDataFetcherFactory
 import com.expedia.graphql.sample.directives.DirectiveWiringFactory
+import com.expedia.graphql.sample.directives.LowercaseDirectiveWiring
 import com.expedia.graphql.sample.exceptions.CustomDataFetcherExceptionHandler
 import com.expedia.graphql.sample.extension.CustomSchemaGeneratorHooks
 import com.expedia.graphql.sample.mutation.Mutation
 import com.expedia.graphql.sample.query.Query
 import com.expedia.graphql.schema.SchemaGeneratorConfig
+import com.expedia.graphql.schema.generator.directive.DirectiveWiringHelper
 import com.expedia.graphql.toSchema
 import com.fasterxml.jackson.module.kotlin.KotlinModule
 import graphql.execution.AsyncExecutionStrategy
@@ -42,7 +44,7 @@ class Application {
     @Bean
     fun schemaConfig(dataFetcherFactory: SpringDataFetcherFactory, validator: Validator, wiringFactory: DirectiveWiringFactory): SchemaGeneratorConfig = SchemaGeneratorConfig(
             supportedPackages = listOf("com.expedia"),
-            hooks = CustomSchemaGeneratorHooks(validator, wiringFactory),
+            hooks = CustomSchemaGeneratorHooks(validator, DirectiveWiringHelper(wiringFactory, mapOf("lowercase" to LowercaseDirectiveWiring()))),
             dataFetcherFactory = dataFetcherFactory
     )
 
@@ -61,7 +63,14 @@ class Application {
                 mutations = mutations.toTopLevelObjectDefs(),
                 config = schemaConfig
         )
-        logger.info(SchemaPrinter().print(schema))
+        logger.info(SchemaPrinter(
+                SchemaPrinter.Options.defaultOptions()
+                        .includeScalarTypes(true)
+                        .includeExtendedScalarTypes(true)
+                        .includeIntrospectionTypes(true)
+                        .includeSchemaDefintion(true)
+            ).print(schema)
+        )
         return schema
     }
 
diff --git a/example/src/main/kotlin/com.expedia.graphql.sample/directives/CakeOnly.kt b/example/src/main/kotlin/com.expedia.graphql.sample/directives/CakeOnly.kt
@@ -2,5 +2,5 @@ package com.expedia.graphql.sample.directives
 
 import com.expedia.graphql.annotations.GraphQLDirective
 
-@GraphQLDirective(description = "This validates string input")
+@GraphQLDirective(description = "This validates inputted string is equal to cake")
 annotation class CakeOnly
diff --git a/example/src/main/kotlin/com.expedia.graphql.sample/directives/CakeOnlyDirectiveWiring.kt b/example/src/main/kotlin/com.expedia.graphql.sample/directives/CakeOnlyDirectiveWiring.kt
@@ -9,13 +9,12 @@ class CakeOnlyDirectiveWiring : DirectiveWiring {
     override fun isApplicable(environment: SchemaDirectiveWiringEnvironment<*>): Boolean =
             environment.directive.name == getDirectiveName(CakeOnly::class)
 
-
     override fun onField(wiringEnv: SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition>): GraphQLFieldDefinition {
         val field = wiringEnv.element
         val originalDataFetcher: DataFetcher<Any> = field.dataFetcher
         val cakeOnlyFetcher = DataFetcher<Any> { dataEnv ->
             val strArg: String? = dataEnv.getArgument(wiringEnv.element.arguments[0].name) as String?
-            if (strArg != "Cake") {
+            if (!"cake".equals(other = strArg, ignoreCase = true)) {
                 throw RuntimeException("The cake is a lie!")
             }
             originalDataFetcher.get(dataEnv)
diff --git a/example/src/main/kotlin/com.expedia.graphql.sample/directives/DirectiveWiringFactory.kt b/example/src/main/kotlin/com.expedia.graphql.sample/directives/DirectiveWiringFactory.kt
@@ -13,8 +13,7 @@ class DirectiveWiringFactory : WiringFactory {
     override fun providesSchemaDirectiveWiring(environment: SchemaDirectiveWiringEnvironment<*>): Boolean = true
 
     override fun getSchemaDirectiveWiring(environment: SchemaDirectiveWiringEnvironment<*>): SchemaDirectiveWiring? =
-            wiring.asSequence()
-                    .filter { it.isApplicable(environment) }
-                    .singleOrNull()
-
+        wiring.firstOrNull {
+            it.isApplicable(environment)
+        }
 }
diff --git a/example/src/main/kotlin/com.expedia.graphql.sample/directives/LowercaseDirective.kt b/example/src/main/kotlin/com.expedia.graphql.sample/directives/LowercaseDirective.kt
@@ -0,0 +1,6 @@
+package com.expedia.graphql.sample.directives
+
+import com.expedia.graphql.annotations.GraphQLDirective
+
+@GraphQLDirective(name = "lowercase", description = "Modifies the string field to lowercase")
+annotation class LowercaseDirective
diff --git a/example/src/main/kotlin/com.expedia.graphql.sample/directives/LowercaseDirectiveWiring.kt b/example/src/main/kotlin/com.expedia.graphql.sample/directives/LowercaseDirectiveWiring.kt
@@ -0,0 +1,19 @@
+package com.expedia.graphql.sample.directives
+
+import graphql.schema.DataFetcher
+import graphql.schema.GraphQLFieldDefinition
+import graphql.schema.idl.SchemaDirectiveWiring
+import graphql.schema.idl.SchemaDirectiveWiringEnvironment
+
+class LowercaseDirectiveWiring : SchemaDirectiveWiring {
+
+    override fun onField(environment: SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition>): GraphQLFieldDefinition {
+        val field = environment.element
+        val originalDataFetcher: DataFetcher<Any> = field.dataFetcher
+
+        val lowerCaseFetcher = DataFetcher<String> { dataEnv ->
+            originalDataFetcher.get(dataEnv).toString().toLowerCase()
+        }
+        return field.transform { it.dataFetcher(lowerCaseFetcher) }
+    }
+}
diff --git a/example/src/main/kotlin/com.expedia.graphql.sample/directives/StringEval.kt b/example/src/main/kotlin/com.expedia.graphql.sample/directives/StringEval.kt
@@ -1,8 +1,11 @@
 package com.expedia.graphql.sample.directives
 
 import com.expedia.graphql.annotations.GraphQLDirective
+import graphql.introspection.Introspection.DirectiveLocation
 
-@GraphQLDirective(description = "This validates string input")
+@GraphQLDirective(
+        description = "This validates string input",
+        locations = [DirectiveLocation.FIELD, DirectiveLocation.FIELD_DEFINITION, DirectiveLocation.ARGUMENT_DEFINITION])
 annotation class StringEval(
         val default: String = "",
         val lowerCase: Boolean = false
diff --git a/example/src/main/kotlin/com.expedia.graphql.sample/directives/StringEvalDirectiveWiring.kt b/example/src/main/kotlin/com.expedia.graphql.sample/directives/StringEvalDirectiveWiring.kt
@@ -2,40 +2,55 @@ package com.expedia.graphql.sample.directives
 
 import graphql.schema.DataFetcher
 import graphql.schema.DataFetchingEnvironmentBuilder
+import graphql.schema.GraphQLArgument
 import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.idl.SchemaDirectiveWiringEnvironment
 
 class StringEvalDirectiveWiring : DirectiveWiring {
-    private val dirName = getDirectiveName(StringEval::class)
+    private val directiveName = getDirectiveName(StringEval::class)
 
-    override fun isApplicable(environment: SchemaDirectiveWiringEnvironment<*>): Boolean =
-            (environment.element as? GraphQLFieldDefinition)?.arguments?.any { it.getDirective(dirName) != null }
-                    ?: false
+    override fun isApplicable(environment: SchemaDirectiveWiringEnvironment<*>): Boolean {
+        val element = environment.element
+        return when (element) {
+            is GraphQLFieldDefinition -> element.getDirective(directiveName) != null || element.arguments.any { it.getDirective(directiveName) != null }
+            is GraphQLArgument -> element.getDirective(directiveName) != null
+            else -> false
+        }
+    }
 
     override fun onField(wiringEnv: SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition>): GraphQLFieldDefinition {
         val field = wiringEnv.element
         val originalDataFetcher: DataFetcher<Any> = field.dataFetcher
 
         val defaultValueFetcher = DataFetcher<Any> { dataEnv ->
             val newArguments = HashMap(dataEnv.arguments)
-            wiringEnv.element.arguments.asSequence()
-                    .map { gqlArg ->
-                        val strArg: String? = dataEnv.getArgument(gqlArg.name) as String?
-                        Pair(gqlArg, strArg)
-                    }
-                    .forEach { (gqlArg, value) ->
-                        if (gqlArg.getDirective(dirName).getArgument(StringEval::lowerCase.name).value as Boolean) {
-                            newArguments[gqlArg.name] = value?.toLowerCase()
-                        }
-                        if (value.isNullOrEmpty()) {
-                            newArguments[gqlArg.name] = gqlArg.getDirective(dirName).getArgument(StringEval::default.name).value as String
-                        }
-                    }
+            wiringEnv.element.arguments.associate {
+                Pair(it, dataEnv.getArgument(it.name) as String?)
+            }.forEach { (graphQLArgumentType, value) ->
+                if (graphQLArgumentType.getDirective(directiveName).getArgument(StringEval::lowerCase.name).value as Boolean) {
+                    newArguments[graphQLArgumentType.name] = value?.toLowerCase()
+                }
+                if (value.isNullOrEmpty()) {
+                    newArguments[graphQLArgumentType.name] = graphQLArgumentType.defaultValue
+                }
+            }
             val newEnv = DataFetchingEnvironmentBuilder.newDataFetchingEnvironment(dataEnv)
                     .arguments(newArguments)
                     .build()
             originalDataFetcher.get(newEnv)
         }
         return field.transform { it.dataFetcher(defaultValueFetcher) }
     }
+
+    override fun onArgument(wiringEnv: SchemaDirectiveWiringEnvironment<GraphQLArgument>): GraphQLArgument {
+        val argument = wiringEnv.element
+        val directive = wiringEnv.directive
+
+        val default = directive.getArgument(StringEval::default.name).value as String
+        return if (default.isNotEmpty()) {
+            argument.transform { it.defaultValue(default) }
+        } else {
+            argument
+        }
+    }
 }
diff --git a/example/src/main/kotlin/com.expedia.graphql.sample/extension/CustomSchemaGeneratorHooks.kt b/example/src/main/kotlin/com.expedia.graphql.sample/extension/CustomSchemaGeneratorHooks.kt
@@ -1,6 +1,5 @@
 package com.expedia.graphql.sample.extension
 
-import com.expedia.graphql.sample.directives.DirectiveWiringFactory
 import com.expedia.graphql.sample.validation.DataFetcherExecutionValidator
 import com.expedia.graphql.schema.generator.directive.DirectiveWiringHelper
 import com.expedia.graphql.schema.hooks.DataFetcherExecutionPredicate
@@ -9,16 +8,16 @@ import graphql.language.StringValue
 import graphql.schema.Coercing
 import graphql.schema.GraphQLScalarType
 import graphql.schema.GraphQLType
-import java.util.*
+import java.util.UUID
 import javax.validation.Validator
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
 
 /**
  * Schema generator hook that adds additional scalar types.
  */
-class CustomSchemaGeneratorHooks(validator: Validator, wiringFactory: DirectiveWiringFactory) : SchemaGeneratorHooks {
-    private val directiveWiringHelper = DirectiveWiringHelper(wiringFactory)
+class CustomSchemaGeneratorHooks(validator: Validator, private val directiveWiringHelper: DirectiveWiringHelper) : SchemaGeneratorHooks {
+
     /**
      * Register additional GraphQL scalar types.
      */
diff --git a/example/src/main/kotlin/com.expedia.graphql.sample/query/CustomDirectiveQuery.kt b/example/src/main/kotlin/com.expedia.graphql.sample/query/CustomDirectiveQuery.kt
@@ -2,16 +2,21 @@ package com.expedia.graphql.sample.query
 
 import com.expedia.graphql.annotations.GraphQLDescription
 import com.expedia.graphql.sample.directives.CakeOnly
+import com.expedia.graphql.sample.directives.LowercaseDirective
 import com.expedia.graphql.sample.directives.StringEval
 import org.springframework.stereotype.Component
 
 @Component
 class CustomDirectiveQuery : Query {
 
     @GraphQLDescription("Returns a message modified by directives, lower case and non-empty")
-    fun justWhisper(@StringEval(default = "Default String", lowerCase = true) msg: String): String = msg
+    fun justWhisper(@StringEval(default = "default string", lowerCase = true) msg: String?): String? = msg
 
     @GraphQLDescription("This will only accept 'Cake' as input")
     @CakeOnly
     fun onlyCake(msg: String): String = "<3"
+
+    @GraphQLDescription("Returns message modified by the manually wired directive to force lowercase")
+    @LowercaseDirective
+    fun forceLowercaseEcho(msg: String) = msg
 }
diff --git a/example/src/main/kotlin/com.expedia.graphql.sample/query/SimpleQuery.kt b/example/src/main/kotlin/com.expedia.graphql.sample/query/SimpleQuery.kt
@@ -19,9 +19,6 @@ class SimpleQuery: Query {
     @GraphQLDescription("new query that always returns true")
     fun shinyNewQuery(): Boolean = true
 
-    @GraphQLDescription("echoes back the msg")
-    fun experimentalEcho(msg: String): String = msg
-
     @GraphQLIgnore
     fun notPartOfSchema() = "ignore me!"
 
diff --git a/src/main/kotlin/com/expedia/graphql/schema/generator/directive/DirectiveWiringHelper.kt b/src/main/kotlin/com/expedia/graphql/schema/generator/directive/DirectiveWiringHelper.kt
@@ -20,38 +20,41 @@ import graphql.schema.idl.SchemaDirectiveWiringEnvironmentImpl
 import graphql.schema.idl.WiringFactory
 
 /**
- * Based on
- * https://github.com/graphql-java/graphql-java/blob/master/src/main/java/graphql/schema/idl/SchemaGeneratorDirectiveHelper.java
+ * Based on [SchemaGeneratorDirectiveHelper](https://github.com/graphql-java/graphql-java/blob/master/src/main/java/graphql/schema/idl/SchemaGeneratorDirectiveHelper.java) from graphql-java.
+ *
+ * Relies on [WiringFactory] for providing applicable [SchemaDirectiveWiring] but if manual directive wiring map is provided it will take precedence over the wiring factory.
  */
-class DirectiveWiringHelper(private val wiringFactory: WiringFactory, private val manualWiring: Map<String, SchemaDirectiveWiring> = mutableMapOf()) {
+class DirectiveWiringHelper(private val wiringFactory: WiringFactory? = null, private val manualWiring: Map<String, SchemaDirectiveWiring> = mapOf()) {
 
     /**
      * Wire up the directive based on the GraphQL type
      */
-    fun onWire(generatedType: GraphQLType): GraphQLType {
-        if (generatedType !is GraphQLDirectiveContainer) return generatedType
+    fun onWire(graphQLType: GraphQLType): GraphQLType {
+        if (graphQLType !is GraphQLDirectiveContainer) return graphQLType
 
         return wireDirectives(
-            generatedType,
-            getDirectives(generatedType),
+            graphQLType,
+            getDirectives(graphQLType),
             ::createWiringEnvironment,
-            getInvoker(generatedType)
+            getInvoker(graphQLType)
         )
     }
 
-    private fun getInvoker(generatedType: GraphQLDirectiveContainer) =
-        { wiring: SchemaDirectiveWiring, environment: SchemaDirectiveWiringEnvironment<GraphQLDirectiveContainer> -> wireOnEnvironment(environment, wiring, generatedType) }
-
-    private fun getDirectives(generatedType: GraphQLDirectiveContainer): MutableList<GraphQLDirective> {
+    private fun getDirectives(graphQLType: GraphQLDirectiveContainer): MutableList<GraphQLDirective> {
         // A function without directives may still be rewired if the arguments have directives
-        val directives = generatedType.directives
-        if (generatedType is GraphQLFieldDefinition) {
-            generatedType.arguments.forEach { directives.addAll(it.directives) }
+        // see https://github.com/ExpediaDotCom/graphql-kotlin/wiki/Schema-Directives for details
+        val directives = graphQLType.directives
+        if (graphQLType is GraphQLFieldDefinition) {
+            graphQLType.arguments.forEach { directives.addAll(it.directives) }
         }
         return directives
     }
 
+    private fun getInvoker(graphQLType: GraphQLDirectiveContainer) =
+        { wiring: SchemaDirectiveWiring, environment: SchemaDirectiveWiringEnvironment<GraphQLDirectiveContainer> -> wireOnEnvironment(environment, wiring, graphQLType) }
+
     private fun <T : GraphQLDirectiveContainer> createWiringEnvironment(element: T, directive: GraphQLDirective): SchemaDirectiveWiringEnvironment<T> =
+        // we are only specifying element and directive, other fields are not used by graphql-kotlin
         SchemaDirectiveWiringEnvironmentImpl(element, directive, null, null, null)
 
     private fun <T : GraphQLDirectiveContainer> wireDirectives(
@@ -73,13 +76,12 @@ class DirectiveWiringHelper(private val wiringFactory: WiringFactory, private va
         return outputObject
     }
 
-    private fun <T : GraphQLDirectiveContainer> discoverWiringProvider(directiveName: String, env: SchemaDirectiveWiringEnvironment<T>): SchemaDirectiveWiring? {
-        return if (wiringFactory.providesSchemaDirectiveWiring(env)) {
-            wiringFactory.getSchemaDirectiveWiring(env)
-        } else {
-            manualWiring[directiveName]
+    private fun <T : GraphQLDirectiveContainer> discoverWiringProvider(directiveName: String, env: SchemaDirectiveWiringEnvironment<T>): SchemaDirectiveWiring? =
+        when {
+            directiveName in manualWiring -> manualWiring[directiveName]
+            true == wiringFactory?.providesSchemaDirectiveWiring(env) -> wiringFactory.getSchemaDirectiveWiring(env)
+            else -> null
         }
-    }
 
     @Suppress("UNCHECKED_CAST", "Detekt.ComplexMethod")
     private fun wireOnEnvironment(environment: SchemaDirectiveWiringEnvironment<GraphQLDirectiveContainer>, wiring: SchemaDirectiveWiring, generatedType: GraphQLDirectiveContainer) =
diff --git a/src/test/kotlin/com/expedia/graphql/schema/generator/directive/DirectiveWiringHelperTest.kt b/src/test/kotlin/com/expedia/graphql/schema/generator/directive/DirectiveWiringHelperTest.kt
