Add option to allow applying undeclared directives

- New SchemaParserOptions.allowUndeclaredDirectives, off by default
- Undeclared directives are kept as applied directives only, with argument types guessed from their values
- Fails with a SchemaError when an argument type can't be guessed

Author: oryan-block

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

@@ -1,6 +1,7 @@
 package graphql.kickstart.tools
 
 import graphql.Directives
+import graphql.Scalars
 import graphql.introspection.Introspection
 import graphql.introspection.Introspection.DirectiveLocation.INPUT_FIELD_DEFINITION
 import graphql.kickstart.tools.directive.DirectiveWiringHelper
@@ -355,7 +356,8 @@ class SchemaParser internal constructor(
         return directives.map { directive ->
             val graphQLDirective = schemaDirectives.find { d -> d.name == directive.name }
                 ?: BUILT_IN_DIRECTIVES[directive.name]
-                ?: throw SchemaError("Found applied directive ${directive.name} without corresponding directive definition.")
+                ?: if (options.allowUndeclaredDirectives) return@map buildUndeclaredAppliedDirective(directive)
+                else throw SchemaError("Found applied directive ${directive.name} without corresponding directive definition.")
             val graphQLArguments = graphQLDirective.arguments.associateBy { it.name }
 
             GraphQLAppliedDirective.newDirective()
@@ -397,6 +399,36 @@ class SchemaParser internal constructor(
         }.toTypedArray()
     }
 
+    private fun buildUndeclaredAppliedDirective(directive: Directive): GraphQLAppliedDirective {
+        return GraphQLAppliedDirective.newDirective()
+            .name(directive.name)
+            .definition(directive)
+            .comparatorRegistry(runtimeWiring.comparatorRegistry)
+            .apply {
+                directive.arguments.forEach { arg ->
+                    argument(GraphQLAppliedDirectiveArgument.newArgument()
+                        .name(arg.name)
+                        .type(guessDirectiveArgumentType(directive, arg.name, arg.value))
+                        .valueLiteral(arg.value)
+                        .build()
+                    )
+                }
+            }
+            .build()
+    }
+
+    // there's no directive definition to look the type up in, so it's guessed from the value
+    private fun guessDirectiveArgumentType(directive: Directive, argumentName: String, value: Value<*>): GraphQLInputType {
+        return when (value) {
+            is StringValue, is NullValue -> Scalars.GraphQLString
+            is IntValue -> Scalars.GraphQLInt
+            is FloatValue -> Scalars.GraphQLFloat
+            is BooleanValue -> Scalars.GraphQLBoolean
+            is ArrayValue -> GraphQLList(value.values.firstOrNull()?.let { guessDirectiveArgumentType(directive, argumentName, it) } ?: Scalars.GraphQLString)
+            else -> throw SchemaError("Can't guess the type of argument ${directive.name}#$argumentName of undeclared directive ${directive.name}, please declare the directive.")
+        }
+    }
+
     // TODO remove this once directives are fully replaced with applied directives
     private fun buildDirectives(
         directives: List<Directive>,
@@ -411,7 +443,9 @@ class SchemaParser internal constructor(
                 names.add(directive.name)
                 val graphQLDirective = this.schemaDirectives.find { d -> d.name == directive.name }
                     ?: BUILT_IN_DIRECTIVES[directive.name]
-                    ?: throw SchemaError("Found applied directive ${directive.name} without corresponding directive definition.")
+                    // graphql-java rejects legacy directives without a definition, so undeclared ones are only kept as applied directives
+                    ?: if (options.allowUndeclaredDirectives) continue
+                    else throw SchemaError("Found applied directive ${directive.name} without corresponding directive definition.")
                 val graphQLArguments = graphQLDirective.arguments.associateBy { it.name }
                 output.add(
                     GraphQLDirective.newDirective()

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

@@ -36,7 +36,8 @@ data class SchemaParserOptions internal constructor(
     val typeDefinitionFactories: List<TypeDefinitionFactory>,
     val fieldVisibility: GraphqlFieldVisibility?,
     val includeUnusedTypes: Boolean,
-    val useCommentsForDescriptions: Boolean
+    val useCommentsForDescriptions: Boolean,
+    val allowUndeclaredDirectives: Boolean
 ) {
     companion object {
         @JvmStatic
@@ -67,6 +68,7 @@ data class SchemaParserOptions internal constructor(
         private var fieldVisibility: GraphqlFieldVisibility? = null
         private var includeUnusedTypes = false
         private var useCommentsForDescriptions = true
+        private var allowUndeclaredDirectives = false
 
         fun contextClass(contextClass: Class<*>) = this.apply {
             this.contextClass = contextClass
@@ -153,6 +155,14 @@ data class SchemaParserOptions internal constructor(
             this.useCommentsForDescriptions = useCommentsForDescriptions
         }
 
+        /**
+         * Allows applying directives that have no definition in the schema, e.g. the Apollo Federation directives imported through `@link`.
+         * They're only added as applied directives, with argument types guessed from their values.
+         */
+        fun allowUndeclaredDirectives(allowUndeclaredDirectives: Boolean) = this.apply {
+            this.allowUndeclaredDirectives = allowUndeclaredDirectives
+        }
+
         @ExperimentalCoroutinesApi
         fun build(): SchemaParserOptions {
             val coroutineContextProvider = coroutineContextProvider
@@ -194,7 +204,8 @@ data class SchemaParserOptions internal constructor(
                 typeDefinitionFactories,
                 fieldVisibility,
                 includeUnusedTypes,
-                useCommentsForDescriptions
+                useCommentsForDescriptions,
+                allowUndeclaredDirectives
             )
         }
     }

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

@@ -383,6 +383,72 @@ class DirectiveTest {
         assertEquals(error.message, "Found applied directive link without corresponding directive definition.")
     }
 
+    @Test
+    fun `should allow undeclared directives when enabled`() {
+        val schema = SchemaParser.newParser()
+            .schemaString(
+                """
+                extend schema @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key", "@shareable"])
+
+                type Query {
+                    books: [Book!] @shareable
+                }
+
+                type Book @key(fields: "id", resolvable: true) @custom(weight: 1.5, limit: 3, tag: null) {
+                    id: Int!
+                    name: String!
+                }
+                """)
+            .resolvers(QueryResolver())
+            .options(SchemaParserOptions.newOptions().allowUndeclaredDirectives(true).build())
+            .build()
+            .makeExecutableSchema()
+
+        val link = schema.getSchemaAppliedDirective("link")
+        assertEquals(link.getArgument("import")?.getValue<List<String>>(), listOf("@key", "@shareable"))
+        assertNotNull(schema.queryType.getField("books").getAppliedDirective("shareable"))
+
+        val book = schema.getObjectType("Book")!!
+        val key = book.getAppliedDirective("key")
+        assertEquals(key.getArgument("fields")?.getValue<String>(), "id")
+        assertEquals(key.getArgument("resolvable")?.getValue<Boolean>(), true)
+        val custom = book.getAppliedDirective("custom")
+        assertEquals(custom.getArgument("weight")?.getValue<Double>(), 1.5)
+        assertEquals(custom.getArgument("limit")?.getValue<Int>(), 3)
+        assertNull(custom.getArgument("tag")?.getValue<String>())
+        // graphql-java rejects legacy directives without a definition
+        assert(book.directives.isEmpty())
+
+        val printed = SchemaPrinter(SchemaPrinter.Options.defaultOptions().includeSchemaDefinition(true)).print(schema)
+        assert(printed.contains("""type Book @custom(limit : 3, tag : null, weight : 1.5) @key(fields : "id", resolvable : true) {""")) {
+            printed
+        }
+    }
+
+    @Test
+    fun `should fail on undeclared directive with an argument whose type can't be guessed`() {
+        val error = assertThrows(SchemaError::class.java) {
+            SchemaParser.newParser()
+                .schemaString(
+                    """
+                    type Query {
+                        books: [Book!] @policy(purpose: SECURITY)
+                    }
+
+                    type Book {
+                        id: Int!
+                        name: String!
+                    }
+                    """)
+                .resolvers(QueryResolver())
+                .options(SchemaParserOptions.newOptions().allowUndeclaredDirectives(true).build())
+                .build()
+                .makeExecutableSchema()
+        }
+
+        assertEquals(error.message, "Can't guess the type of argument policy#purpose of undeclared directive policy, please declare the directive.")
+    }
+
     private class BookQueryResolver : GraphQLQueryResolver {
         fun book(filter: BookFilter): Book? = null
     }