Reference schema types from the fields of wired types so wirings can change self-referencing field types

Also drop the input objects parameter of determineType, which can no longer match.

Author: oryan-block

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

@@ -373,7 +373,7 @@ class SchemaParser internal constructor(
             .description(getDocumentation(fieldDefinition, options))
             .definition(fieldDefinition)
             .apply { getDeprecated(fieldDefinition.directives)?.let { deprecate(it) } }
-            .type(determineOutputType(fieldDefinition.type, inputObjects))
+            .type(determineOutputType(fieldDefinition.type))
             .withAppliedDirectives(*buildAppliedDirectives(fieldDefinition.directives, FIELD_DEFINITION))
             .withDirectives(*buildDirectives(fieldDefinition.directives, FIELD_DEFINITION))
             .apply {
@@ -431,8 +431,8 @@ class SchemaParser internal constructor(
             .name(definition.name)
             .definition(definition)
             .description(getDocumentation(definition, options))
-            // input objects are type references here, since they need the directives to be built first
-            .type(determineType(GraphQLInputType::class, definition.type, permittedTypesForInputObject, listOf()) as GraphQLInputType)
+            // type references, so that an input object used by a directive applied to it doesn't contain itself
+            .type(determineType(GraphQLInputType::class, definition.type, permittedTypesForInputObject) as GraphQLInputType)
             .apply { getDeprecated(definition.directives)?.let { deprecate(it) } }
             .apply { definition.defaultValue?.let { defaultValueLiteral(it) } }
             .build()
@@ -591,22 +591,18 @@ class SchemaParser internal constructor(
     private fun missingArgumentsWithDefault(directive: Directive, graphQLDirective: GraphQLDirective): List<GraphQLArgument> =
         graphQLDirective.arguments.filter { it.hasSetDefaultValue() && directive.getArgument(it.name) == null }
 
-    private fun determineOutputType(typeDefinition: Type<*>, inputObjects: List<GraphQLInputObjectType>) =
-        determineType(GraphQLOutputType::class, typeDefinition, permittedTypesForObject, inputObjects) as GraphQLOutputType
+    private fun determineOutputType(typeDefinition: Type<*>) =
+        determineType(GraphQLOutputType::class, typeDefinition, permittedTypesForObject) as GraphQLOutputType
 
+    // named types other than scalars are type references
     private fun <T : Any> determineType(
         expectedType: KClass<T>,
         typeDefinition: Type<*>,
-        allowedTypeReferences: Set<String>,
-        inputObjects: List<GraphQLInputObjectType>
+        allowedTypeReferences: Set<String>
     ): GraphQLType =
         when (typeDefinition) {
-            is ListType -> GraphQLList(determineType(expectedType, typeDefinition.type, allowedTypeReferences, inputObjects))
-            is NonNullType -> GraphQLNonNull(determineType(expectedType, typeDefinition.type, allowedTypeReferences, inputObjects))
-            is InputObjectTypeDefinition -> {
-                log.info("Create input object")
-                createInputObject(typeDefinition, inputObjects, mutableSetOf())
-            }
+            is ListType -> GraphQLList(determineType(expectedType, typeDefinition.type, allowedTypeReferences))
+            is NonNullType -> GraphQLNonNull(determineType(expectedType, typeDefinition.type, allowedTypeReferences))
             is TypeName -> {
                 val scalarType = customScalars[typeDefinition.name]
                     ?: GRAPHQL_SCALARS[typeDefinition.name]
@@ -616,7 +612,7 @@ class SchemaParser internal constructor(
                     if (!allowedTypeReferences.contains(typeDefinition.name)) {
                         throw unexpectedTypeError(typeDefinition, expectedType)
                     }
-                    inputObjects.find { it.name == typeDefinition.name } ?: GraphQLTypeReference(typeDefinition.name)
+                    GraphQLTypeReference(typeDefinition.name)
                 }
             }
             else -> throw SchemaError("Unknown type: $typeDefinition")

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

@@ -22,6 +22,8 @@ internal class DirectiveWiringHelper(
     val isWiringRequired = runtimeWiring.registeredDirectiveWiring.isNotEmpty() || runtimeWiring.directiveWiring.isNotEmpty()
 
     fun wireSchema(schema: GraphQLSchema): GraphQLSchema = SchemaTransformer.transformSchema(schema, object : GraphQLTypeVisitorStub() {
+        private val references = TypeReferences(schema)
+
         override fun visitGraphQLObjectType(node: GraphQLObjectType, context: TraverserContext<GraphQLSchemaElement>) =
             wire(node, node.definition, context, ::wireObject)
 
@@ -41,12 +43,46 @@ internal class DirectiveWiringHelper(
         private fun <T : GraphQLNamedType> wire(node: T, definition: Node<*>?, context: TraverserContext<GraphQLSchemaElement>, wireType: (T) -> T): TraversalControl {
             if (definition != null) {
                 val wired = wireType(node)
-                if (wired !== node) changeNode(context, wired)
+                if (wired !== node) changeNode(context, references.inFields(wired))
             }
             return TraversalControl.CONTINUE
         }
     })
 
+    /**
+     * Swaps the schema's own types in the fields of a wired type for type references, like they were before the schema was built.
+     * Otherwise a type whose fields refer to itself contains itself, which the schema transformer can't rebuild.
+     */
+    private class TypeReferences(private val schema: GraphQLSchema) {
+        // the types wirings build in code, rebuilt once each
+        private val built = IdentityHashMap<GraphQLType, GraphQLType>()
+
+        @Suppress("UNCHECKED_CAST")
+        fun <T : GraphQLNamedType> inFields(type: T): T = when (type) {
+            is GraphQLObjectType -> type.transform { it.clearFields().fields(type.fields.map(::inField)) }
+            is GraphQLInterfaceType -> type.transform { it.clearFields().fields(type.fields.map(::inField)) }
+            is GraphQLInputObjectType -> type.transform { it.clearFields().fields(type.fields.map(::inInputField)) }
+            else -> type
+        } as T
+
+        private fun inField(field: GraphQLFieldDefinition) = field.transform {
+            it.type(of(field.type) as GraphQLOutputType)
+                .clearArguments()
+                .arguments(field.arguments.map { argument -> argument.transform { a -> a.type(of(argument.type) as GraphQLInputType) } })
+        }
+
+        private fun inInputField(field: GraphQLInputObjectField) = field.transform { it.type(of(field.type) as GraphQLInputType) }
+
+        private fun of(type: GraphQLType): GraphQLType = when (type) {
+            is GraphQLNonNull -> GraphQLNonNull.nonNull(of(type.wrappedType))
+            is GraphQLList -> GraphQLList.list(of(type.wrappedType))
+            // only these can lead back to the wired type. Scalars stay, since a reference only finds a scalar another field uses
+            is GraphQLFieldsContainer, is GraphQLInputObjectType ->
+                if (schema.typeMap[type.name] === type) GraphQLTypeReference.typeRef(type.name) else built.getOrPut(type) { inFields(type) }
+            else -> type
+        }
+    }
+
     private fun wireObject(objectType: GraphQLObjectType): GraphQLObjectType {
         return wireFields(objectType)
             .let { fields -> if (objectType.fields != fields) objectType.transform { it.clearFields().fields(fields) } else objectType }

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

@@ -256,18 +256,40 @@ class DirectiveTest {
     }
 
     @Test
-    fun `should keep types a directive wiring builds in code`() {
+    fun `should let directive wirings change the types of self-referencing fields`() {
         val schema = SchemaParser.newParser()
             .schemaString(
                 """
+                directive @required on FIELD_DEFINITION
+                directive @many on INPUT_FIELD_DEFINITION
                 directive @wrap on FIELD_DEFINITION
 
                 type Query {
-                    name: String @wrap
+                    person(filter: PersonFilter): Person
+                }
+
+                type Person {
+                    name: String
+                    age: Int
+                    friend: Person @required
+                    best: Person @wrap
+                }
+
+                input PersonFilter {
+                    name: String
+                    parent: PersonFilter @many
                 }
                 """)
             .resolvers(object : GraphQLQueryResolver {
-                fun name(): String? = null
+                fun person(filter: PersonFilter?): Person = Person("a")
+            })
+            .directive("required", object : SchemaDirectiveWiring {
+                override fun onField(environment: SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition>): GraphQLFieldDefinition =
+                    environment.element.transform { it.type(GraphQLNonNull.nonNull(environment.element.type)) }
+            })
+            .directive("many", object : SchemaDirectiveWiring {
+                override fun onInputObjectField(environment: SchemaDirectiveWiringEnvironment<GraphQLInputObjectField>): GraphQLInputObjectField =
+                    environment.element.transform { it.type(GraphQLList.list(environment.element.type)) }
             })
             .directive("wrap", object : SchemaDirectiveWiring {
                 override fun onField(environment: SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition>): GraphQLFieldDefinition {
@@ -280,9 +302,15 @@ class DirectiveTest {
             })
             .build()
             .makeExecutableSchema()
-            .assertEveryFieldResolves()
 
-        assertEquals(GraphQLTypeUtil.simplePrint(schema.queryType.getField("name").type), "Wrapper")
+        val person = schema.getObjectType("Person")!!
+        val filter = schema.getTypeAs<GraphQLInputObjectType>("PersonFilter")!!
+        val wrapper = schema.getObjectType("Wrapper")!!
+        assertEquals(GraphQLTypeUtil.simplePrint(person.getField("friend").type), "Person!")
+        assertEquals(GraphQLTypeUtil.simplePrint(person.getField("best").type), "Wrapper")
+        assertEquals(GraphQLTypeUtil.simplePrint(filter.getField("parent").type), "[PersonFilter]")
+        assert(GraphQLTypeUtil.unwrapAll(person.getField("friend").type) === person)
+        assert(wrapper.getField("value").type === person)
     }
 
     @Test
@@ -849,6 +877,16 @@ class DirectiveTest {
         val label: String?
     )
 
+    class Person(val name: String, val age: Int = 1) {
+        val friend: Person get() = this
+        val best: Person get() = this
+    }
+
+    data class PersonFilter(
+        val name: String?,
+        val parent: PersonFilter?
+    )
+
     private data class BoundInput(
         val max: Int?
     )