Merge master into bugfix/864

Wirings run on the assembled schema since #895, so custom scalars are built once, put in the dictionary and referenced by
name like the other types, and they're wired with the other types. That replaces building them on first use and the
directive cycle handling.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: oryan-block

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

@@ -73,8 +73,8 @@ class SchemaParser internal constructor(
     private val codeRegistryBuilder = GraphQLCodeRegistry.newCodeRegistry()
     private val directiveWiringHelper = DirectiveWiringHelper(runtimeWiring, codeRegistryBuilder)
 
-    private lateinit var schemaDirectives: SchemaDirectives
-    private lateinit var scalars: MutableMap<String, GraphQLScalarType>
+    // by name, in the order they're declared
+    private lateinit var schemaDirectives: MutableMap<String, GraphQLDirective>
 
     /**
      * Parses the given schema with respect to the given dictionary and returns GraphQL objects.
@@ -91,22 +91,15 @@ class SchemaParser internal constructor(
 
         // Create GraphQL objects
         val inputObjects: MutableList<GraphQLInputObjectType> = mutableListOf()
-        scalars = mutableMapOf()
-        createDirectives(inputObjects)
+        createDirectives()
+        val scalars = scalarDefinitions.values.map { createScalar(it) }
         inputObjectDefinitions.forEach {
             if (inputObjects.none { io -> io.name == it.name }) {
                 inputObjects.add(createInputObject(it, inputObjects, mutableSetOf()))
             }
         }
         val interfaces = interfaceDefinitions.map { createInterfaceObject(it, inputObjects) }
         val objects = objectDefinitions.map { createObject(it, interfaces, inputObjects) }
-        if (options.unmappedInputFields != UnmappedInputFields.IGNORE) {
-            val checker = UnmappedInputFieldChecker(inputObjects.associateBy { it.name }, options.unmappedInputFields)
-            objectDefinitions.forEach { type ->
-                fieldResolversByType[type].orEmpty().values.filterIsInstance<MethodFieldResolver>().forEach { checker.check(type.name, it) }
-            }
-            checker.report()
-        }
         val unions = unionDefinitions.map { createUnionObject(it, objects) }
         val enums = enumDefinitions.map { createEnumObject(it) }
 
@@ -128,11 +121,37 @@ class SchemaParser internal constructor(
 
         val additionalObjects = objects.filter { o -> o != query && o != subscription && o != mutation }
 
-        val types = (additionalObjects.toSet() as Set<GraphQLType>) + inputObjects + enums + interfaces + unions
+        val types = (additionalObjects.toSet() as Set<GraphQLType>) + inputObjects + enums + interfaces + unions + scalars
         // Directives applied to the schema itself, e.g. `extend schema @link(...)`. Only GraphQLAppliedDirectives are built here, not
         // the deprecated GraphQLDirective ones: graphql-java doesn't resolve type references in those, so enum arguments would fail.
         val schemaAppliedDirectives = buildAppliedDirectives(rootInfo.getDirectives(), SCHEMA).toList()
-        return SchemaObjects(query, mutation, subscription, types, schemaDirectives.all, codeRegistryBuilder, rootInfo.getDescription(), schemaAppliedDirectives)
+        val schemaObjects = SchemaObjects(query, mutation, subscription, types, schemaDirectives.values.toSet(), codeRegistryBuilder, rootInfo.getDescription(), schemaAppliedDirectives)
+        // in the order the types were created
+        val wiredObjects = if (directiveWiringHelper.isWiringRequired) wire(schemaObjects, scalars + inputObjects + interfaces + objects + unions + enums) else schemaObjects
+        if (options.unmappedInputFields != UnmappedInputFields.IGNORE) {
+            val wiredInputObjects = wiredObjects.dictionary.filterIsInstance<GraphQLInputObjectType>().associateBy { it.name }
+            val checker = UnmappedInputFieldChecker(wiredInputObjects, options.unmappedInputFields)
+            objectDefinitions.forEach { type ->
+                fieldResolversByType[type].orEmpty().values.filterIsInstance<MethodFieldResolver>().forEach { checker.check(type.name, it) }
+            }
+            checker.report()
+        }
+        return wiredObjects
+    }
+
+    /**
+     * Runs the directive wirings on the types once the schema is assembled, so they see resolved types, and swaps in the types they change.
+     */
+    private fun wire(schemaObjects: SchemaObjects, types: List<GraphQLNamedType>): SchemaObjects {
+        // building the schema resolves the type references in these types
+        val wired = directiveWiringHelper.wireTypes(schemaObjects.toSchema(), types)
+        if (wired.isEmpty()) return schemaObjects
+        return schemaObjects.copy(
+            query = wired[schemaObjects.query.name] as GraphQLObjectType? ?: schemaObjects.query,
+            mutation = schemaObjects.mutation?.let { wired[it.name] as GraphQLObjectType? ?: it },
+            subscription = schemaObjects.subscription?.let { wired[it.name] as GraphQLObjectType? ?: it },
+            dictionary = schemaObjects.dictionary.mapTo(linkedSetOf()) { wired[(it as GraphQLNamedType).name] ?: it }
+        )
     }
 
     /**
@@ -182,7 +201,7 @@ class SchemaParser internal constructor(
                 }
             }
 
-        return directiveWiringHelper.wireObject(builder.build())
+        return builder.build()
     }
 
     private fun createInputObject(definition: InputObjectTypeDefinition, inputObjects: List<GraphQLInputObjectType>,
@@ -218,7 +237,7 @@ class SchemaParser internal constructor(
                 }
             }
 
-        return directiveWiringHelper.wireInputObject(builder.build())
+        return builder.build()
     }
 
     private fun createEnumObject(definition: EnumTypeDefinition): GraphQLEnumType {
@@ -263,20 +282,7 @@ class SchemaParser internal constructor(
                 }
             }
 
-        return directiveWiringHelper.wireEnum(builder.build())
-    }
-
-    /**
-     * The scalar with this name, or null if there's none. A custom scalar is built the first time it's used, so that everything
-     * using it holds the same instance. The directives it applies are built first, so their definitions don't keep a type
-     * reference to it. The directives applied to scalars can still hold one to a scalar that's being built, which graphql-java
-     * replaces when it builds the schema.
-     */
-    private fun scalarType(name: String?): GraphQLScalarType? {
-        val definition = scalarDefinitions[name] ?: return GRAPHQL_SCALARS[name]
-        scalars[definition.name]?.let { return it }
-        definition.withExtensions(typeExtensions).flatMap { it.directives }.forEach { schemaDirectives.find(it.name) }
-        return scalars.getOrPut(definition.name) { createScalar(definition) }
+        return builder.build()
     }
 
     private fun createScalar(definition: ScalarTypeDefinition): GraphQLScalarType {
@@ -301,7 +307,7 @@ class SchemaParser internal constructor(
             .withAppliedDirectives(*appliedDirectives)
             .withDirectives(*legacyDirectives)
 
-        return directiveWiringHelper.wireScalar(builder.build())
+        return builder.build()
     }
 
     private fun createInterfaceObject(interfaceDefinition: InterfaceTypeDefinition, inputObjects: List<GraphQLInputObjectType>): GraphQLInterfaceType {
@@ -328,7 +334,7 @@ class SchemaParser internal constructor(
                 }
             }
 
-        return directiveWiringHelper.wireInterFace(builder.build())
+        return builder.build()
     }
 
     private fun createUnionObject(definition: UnionTypeDefinition, types: List<GraphQLObjectType>): GraphQLUnionType {
@@ -346,7 +352,7 @@ class SchemaParser internal constructor(
                 getLeafUnionObjects(definition, types).forEach { possibleType(it) }
             }
 
-        return directiveWiringHelper.wireUnion(builder.build())
+        return builder.build()
     }
 
     private fun getLeafUnionObjects(definition: UnionTypeDefinition, types: List<GraphQLObjectType>): List<GraphQLObjectType> {
@@ -395,7 +401,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 {
@@ -418,11 +424,10 @@ class SchemaParser internal constructor(
             .build()
     }
 
-    private fun createDirectives(inputObjects: MutableList<GraphQLInputObjectType>) {
-        schemaDirectives = SchemaDirectives(inputObjects)
-        directiveDefinitions.forEach { schemaDirectives.find(it.name) }
+    private fun createDirectives() {
+        schemaDirectives = directiveDefinitions.associateTo(linkedMapOf()) { it.name to createDirective(it) }
         // because the arguments can have directives too, we attach them only after the directives themselves are created
-        schemaDirectives.update { d ->
+        schemaDirectives.replaceAll { _, d ->
             val arguments = d.arguments.map { a -> a.transform {
                 it.withAppliedDirectives(*buildAppliedDirectives(a.definition!!.directives, ARGUMENT_DEFINITION))
                     .withDirectives(*buildDirectives(a.definition!!.directives, ARGUMENT_DEFINITION))
@@ -431,33 +436,7 @@ class SchemaParser internal constructor(
         }
     }
 
-    /**
-     * The directive definitions. The input objects used by their arguments need the directives applied to them, so each directive
-     * is first built with type references to the types it can't build yet, then rebuilt with the built types the first time it's
-     * looked up. Only a directive applied within its own argument types gets its first build there.
-     */
-    private inner class SchemaDirectives(private val inputObjects: MutableList<GraphQLInputObjectType>) {
-        // by name, in the order they're declared
-        private val byName = directiveDefinitions.associateTo(linkedMapOf()) { definition ->
-            definition.name to createDirective(definition, ::typeReferenceOf)
-        }
-        private val unfinished = directiveDefinitions.associateByTo(mutableMapOf()) { it.name }
-        // shared, so that an input object that's still being built isn't built again for another directive
-        private val referencingInputObjects = mutableSetOf<String>()
-
-        val all: Set<GraphQLDirective> get() = byName.values.toSet()
-
-        fun find(name: String): GraphQLDirective? {
-            unfinished.remove(name)?.let { definition ->
-                byName[name] = createDirective(definition) { determineInputType(it, inputObjects, referencingInputObjects) }
-            }
-            return byName[name]
-        }
-
-        fun update(transform: (GraphQLDirective) -> GraphQLDirective) = byName.replaceAll { _, directive -> transform(directive) }
-    }
-
-    private fun createDirective(definition: DirectiveDefinition, determineArgumentType: (Type<*>) -> GraphQLInputType): GraphQLDirective {
+    private fun createDirective(definition: DirectiveDefinition): GraphQLDirective {
         val locations = definition.directiveLocations.map { Introspection.DirectiveLocation.valueOf(it.name) }.toTypedArray()
 
         return GraphQLDirective.newDirective()
@@ -469,18 +448,19 @@ class SchemaParser internal constructor(
             .repeatable(definition.isRepeatable)
             .apply {
                 definition.inputValueDefinitions.forEach { argumentDefinition ->
-                    argument(createDirectiveArgument(argumentDefinition, determineArgumentType))
+                    argument(createDirectiveArgument(argumentDefinition))
                 }
             }
             .build()
     }
 
-    private fun createDirectiveArgument(definition: InputValueDefinition, determineArgumentType: (Type<*>) -> GraphQLInputType): GraphQLArgument {
+    private fun createDirectiveArgument(definition: InputValueDefinition): GraphQLArgument {
         return GraphQLArgument.newArgument()
             .name(definition.name)
             .definition(definition)
             .description(getDocumentation(definition, options))
-            .type(determineArgumentType(definition.type))
+            // 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()
@@ -550,7 +530,7 @@ class SchemaParser internal constructor(
             }
         }
 
-    private fun findDirective(name: String): GraphQLDirective? = schemaDirectives.find(name) ?: BUILT_IN_DIRECTIVES[name]
+    private fun findDirective(name: String): GraphQLDirective? = schemaDirectives[name] ?: BUILT_IN_DIRECTIVES[name]
 
     private fun buildUndeclaredAppliedDirective(directive: Directive): GraphQLAppliedDirective {
         return GraphQLAppliedDirective.newDirective()
@@ -642,33 +622,22 @@ class SchemaParser internal constructor(
     private fun getSpecifiedByUrl(directives: List<Directive>): String? =
         (directives.find { it.name == Directives.SpecifiedByDirective.name }?.getArgument("url")?.value as? StringValue)?.value
 
-    // a directive's first build, see SchemaDirectives: no directive exists yet, so only scalars that apply none can be built
-    private fun typeReferenceOf(type: Type<*>): GraphQLInputType = when (type) {
-        is ListType -> GraphQLList(typeReferenceOf(type.type))
-        is NonNullType -> GraphQLNonNull(typeReferenceOf(type.type))
-        is TypeName -> {
-            val appliesDirectives = scalarDefinitions[type.name]?.withExtensions(typeExtensions)?.any { it.directives.isNotEmpty() } == true
-            (if (appliesDirectives) null else scalarType(type.name)) ?: GraphQLTypeReference(type.name)
-        }
-        else -> throw SchemaError("Unknown type: $type")
-    }
+    // custom scalars are in the dictionary, so they're referenced by name like the other types
+    private fun scalarType(name: String?): GraphQLInputType? =
+        scalarDefinitions[name]?.let { GraphQLTypeReference(it.name) } ?: GRAPHQL_SCALARS[name]
 
-    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 spec 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 = scalarType(typeDefinition.name)
                 if (scalarType != null) {
@@ -677,7 +646,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")