Process repeated directives

Author: oryan-block

src/main/kotlin/graphql/kickstart/tools/SchemaParser.kt

@@ -56,7 +56,7 @@ class SchemaParser internal constructor(
         (inputObjectDefinitions.map { it.name } + enumDefinitions.map { it.name }).toSet()
 
     private val codeRegistryBuilder = GraphQLCodeRegistry.newCodeRegistry()
-    private val directiveWiringHelper = DirectiveWiringHelper(options, runtimeWiring, codeRegistryBuilder)
+    private val directiveWiringHelper = DirectiveWiringHelper(options, runtimeWiring, codeRegistryBuilder, directiveDefinitions)
 
     /**
      * Parses the given schema with respect to the given dictionary and returns GraphQL objects.
@@ -316,32 +316,22 @@ class SchemaParser internal constructor(
     }
 
     private fun buildAppliedDirectives(directives: List<Directive>): Array<GraphQLAppliedDirective> {
-        val names = mutableSetOf<String>()
-
-        val output = mutableListOf<GraphQLAppliedDirective>()
-        for (directive in directives) {
-            if (!names.contains(directive.name)) {
-                names.add(directive.name)
-                val graphQLDirective = GraphQLAppliedDirective.newDirective()
-                    .name(directive.name)
-                    .description(getDocumentation(directive, options))
-                    .comparatorRegistry(runtimeWiring.comparatorRegistry)
-                    .apply {
-                        directive.arguments.forEach { arg ->
-                            argument(GraphQLAppliedDirectiveArgument.newArgument()
-                                .name(arg.name)
-                                .type(directiveWiringHelper.buildDirectiveInputType(arg.value))
-                                .valueLiteral(arg.value)
-                                .build())
-                        }
+        return directives.map {
+            GraphQLAppliedDirective.newDirective()
+                .name(it.name)
+                .description(getDocumentation(it, options))
+                .comparatorRegistry(runtimeWiring.comparatorRegistry)
+                .apply {
+                    it.arguments.forEach { arg ->
+                        argument(GraphQLAppliedDirectiveArgument.newArgument()
+                            .name(arg.name)
+                            .type(directiveWiringHelper.buildDirectiveInputType(arg.value))
+                            .valueLiteral(arg.value)
+                            .build())
                     }
-                    .build()
-
-                output.add(graphQLDirective)
-            }
-        }
-
-        return output.toTypedArray()
+                }
+                .build()
+        }.toTypedArray()
     }
 
     private fun determineOutputType(typeDefinition: Type<*>, inputObjects: List<GraphQLInputObjectType>) =

src/main/kotlin/graphql/kickstart/tools/directive/DirectiveWiringHelper.kt

@@ -16,7 +16,8 @@ import java.util.*
 class DirectiveWiringHelper(
     private val options: SchemaParserOptions,
     private val runtimeWiring: RuntimeWiring,
-    codeRegistryBuilder: GraphQLCodeRegistry.Builder
+    codeRegistryBuilder: GraphQLCodeRegistry.Builder,
+    private val directiveDefinitions: List<DirectiveDefinition>
 ) {
     private val schemaDirectiveParameters = Parameters(runtimeWiring, codeRegistryBuilder)
 
@@ -76,39 +77,42 @@ class DirectiveWiringHelper(
     private fun <T : GraphQLDirectiveContainer> wireDirectives(wrapper: WiringWrapper<T>): T {
         val directivesContainer = wrapper.graphQlType.definition as DirectivesContainer<*>
         val directives = buildDirectives(directivesContainer.directives, wrapper.directiveLocation)
+        var output = wrapper.graphQlType
         // first the specific named directives
         directives.forEach { directive ->
             val env = buildEnvironment(wrapper, directives, directive)
             val wiring = runtimeWiring.registeredDirectiveWiring[directive.name]
-            wiring?.let { return wrapper.invoker(it, env) }
+            wiring?.let { output = wrapper.invoker(it, env) }
         }
         // now call any statically added to the runtime
         runtimeWiring.directiveWiring.forEach { staticWiring ->
             val env = buildEnvironment(wrapper, directives, null)
-            return wrapper.invoker(staticWiring, env)
+            output = wrapper.invoker(staticWiring, env)
         }
         // wiring factory is last (if present)
         val env = buildEnvironment(wrapper, directives, null)
         if (runtimeWiring.wiringFactory.providesSchemaDirectiveWiring(env)) {
             val factoryWiring = runtimeWiring.wiringFactory.getSchemaDirectiveWiring(env)
-            return wrapper.invoker(factoryWiring, env)
+            output = wrapper.invoker(factoryWiring, env)
         }
 
-        return wrapper.graphQlType
+        return output
     }
 
     private fun buildDirectives(directives: List<Directive>, directiveLocation: Introspection.DirectiveLocation): List<GraphQLDirective> {
         val names = mutableSetOf<String>()
         val output = mutableListOf<GraphQLDirective>()
 
         for (directive in directives) {
-            if (!names.contains(directive.name)) {
+            val repeatable = directiveDefinitions.find { it.name.equals(directive.name) }?.isRepeatable ?: false
+            if (repeatable || !names.contains(directive.name)) {
                 names.add(directive.name)
                 output.add(GraphQLDirective.newDirective()
                     .name(directive.name)
                     .description(getDocumentation(directive, options))
                     .comparatorRegistry(runtimeWiring.comparatorRegistry)
                     .validLocation(directiveLocation)
+                    .repeatable(repeatable)
                     .apply {
                         directive.arguments.forEach { arg ->
                             argument(GraphQLArgument.newArgument()

src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt

@@ -116,6 +116,91 @@ class DirectiveTest {
         assertEquals(result.getData(), expected)
     }
 
+    @Test
+    fun `should apply multiple directives`() {
+        val schema = SchemaParser.newParser()
+            .schemaString(
+                """
+                directive @double repeatable on FIELD_DEFINITION
+                
+                type Query {
+                    user: User
+                }
+                
+                type User {
+                    id: ID!
+                    name: String @uppercase @double
+                }
+                """)
+            .resolvers(UsersQueryResolver())
+            .directive("double", DoubleDirective())
+            .directive("uppercase", UppercaseDirective())
+            .build()
+            .makeExecutableSchema()
+
+        val gql = GraphQL.newGraphQL(schema)
+            .queryExecutionStrategy(AsyncExecutionStrategy())
+            .build()
+
+        val result = gql.execute(
+            """
+            query {
+                user {
+                    id
+                    name
+                }
+            }
+            """)
+
+        val expected = mapOf(
+            "user" to mapOf("id" to "1", "name" to "LUKELUKE")
+        )
+
+        assertEquals(result.getData(), expected)
+    }
+
+    @Test
+    fun `should apply repeated directive`() {
+        val schema = SchemaParser.newParser()
+            .schemaString(
+                """
+                directive @double repeatable on FIELD_DEFINITION
+                
+                type Query {
+                    user: User
+                }
+                
+                type User {
+                    id: ID!
+                    name: String @double @double
+                }
+                """)
+            .resolvers(UsersQueryResolver())
+            .directive("double", DoubleDirective())
+            .build()
+            .makeExecutableSchema()
+
+        val gql = GraphQL.newGraphQL(schema)
+            .queryExecutionStrategy(AsyncExecutionStrategy())
+            .build()
+
+        val result = gql.execute(
+            """
+            query {
+                user {
+                    id
+                    name
+                }
+            }
+            """)
+
+        val expected = mapOf(
+            "user" to mapOf("id" to "1", "name" to "LukeLukeLukeLuke")
+        )
+
+        assertEquals(result.getData(), expected)
+    }
+
     @Test
     @Ignore("Ignore until enums work in directives")
     fun `should compile schema with directive that has enum parameter`() {
@@ -208,6 +293,24 @@ class DirectiveTest {
         }
     }
 
+    private class DoubleDirective : SchemaDirectiveWiring {
+
+        override fun onField(environment: SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition>): GraphQLFieldDefinition {
+            val field = environment.element
+            val parentType = environment.fieldsContainer
+
+            val originalDataFetcher = environment.codeRegistry.getDataFetcher(parentType, field)
+            val wrappedDataFetcher = DataFetcherFactories.wrapDataFetcher(originalDataFetcher) { _, value ->
+                val string = value as? String
+                string + string
+            }
+
+            environment.codeRegistry.dataFetcher(parentType, field, wrappedDataFetcher)
+
+            return field
+        }
+    }
+
     private class UsersQueryResolver : GraphQLQueryResolver {
         fun users(env: DataFetchingEnvironment): Connection<User> {
             return SimpleListConnection(listOf(User(1L, "Luke"))).get(env)