Simplify the input field scan and the type error messages

- Fix the two compiler warnings for the java.util.Map and Object class
  literals in isPropertyMap
- Flatten handleInputObjectFields with early returns
- Give the three enum-without-class messages the same fix hint, so only
  the reason differs
- Pick the type kind in unexpectedTypeError without a triple negation
- Write the source name as "in <file>", like the syntax errors from #838
- Drop "javax." from the library class prefixes, nothing there is an
  input class
- Shorten the missing property warning
- Fold the ObjectNode method name test and the Map subclass enum error
  test into their neighbours

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

Author: oryan-block

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

@@ -220,10 +220,9 @@ internal class SchemaClassScanner(
     }
 
     private fun validateAndCreateResult(rootTypeHolder: RootTypesHolder): ScannedSchemaObjects {
-        enumsWithoutClass
-            .filter { dictionary[it.key]?.javaType == null }
-            .values.firstOrNull()
-            ?.let { throw SchemaClassScannerError(it) }
+        enumsWithoutClass.entries
+            .find { dictionary[it.key]?.javaType == null }
+            ?.let { throw SchemaClassScannerError(it.value) }
 
         initialDictionary
             .filter { !it.value.accessed }
@@ -471,27 +470,30 @@ internal class SchemaClassScanner(
      * has no known class, e.g. because it's only reachable through a Map.
      */
     private fun handleInputObjectFields(graphQLType: InputObjectTypeDefinition, javaType: JavaType?) {
+        val clazz = javaType?.unwrap()
         val inputObjectTypes = listOf(graphQLType) + inputExtensionDefinitions.filter { it.name == graphQLType.name }
         inputObjectTypes
             .flatMap { it.inputValueDefinitions }
             .forEach { inputValueDefinition ->
                 val inputGraphQLType = inputValueDefinition.type.unwrap()
-                if (inputGraphQLType is TypeName && !ScalarInfo.GRAPHQL_SPECIFICATION_SCALARS_DEFINITIONS.containsKey(inputGraphQLType.name)) {
-                    val propertyType = javaType?.unwrap()?.let { findInputValueTypeInType(inputValueDefinition.name, it) }
-                    val inputValueJavaType = propertyType ?: initialDictionary[inputGraphQLType.name]?.get()
-                    if (inputValueJavaType != null) {
-                        val genericContext = javaType ?: inputValueJavaType
-                        handleFoundType(typeClassMatcher.match(TypeClassMatcher.PotentialMatch.parameterType(
-                            // a class from the dictionary is for the unwrapped type, not for its list or non-null wrapper
-                            if (propertyType != null) inputValueDefinition.type else inputGraphQLType,
-                            inputValueJavaType,
-                            GenericTypeResolver(genericContext, options),
-                            InputObjectReference(inputValueDefinition)
-                        )))
-                    } else {
-                        handleInputValueWithoutJavaType(graphQLType, inputValueDefinition, inputGraphQLType, javaType?.unwrap())
-                    }
+                if (inputGraphQLType !is TypeName || ScalarInfo.GRAPHQL_SPECIFICATION_SCALARS_DEFINITIONS.containsKey(inputGraphQLType.name)) {
+                    return@forEach
+                }
+
+                val propertyType = clazz?.let { findInputValueTypeInType(inputValueDefinition.name, it) }
+                val inputValueJavaType = propertyType ?: initialDictionary[inputGraphQLType.name]?.get()
+                if (inputValueJavaType == null) {
+                    handleInputValueWithoutJavaType(graphQLType, inputValueDefinition, inputGraphQLType, clazz)
+                    return@forEach
                 }
+
+                handleFoundType(typeClassMatcher.match(TypeClassMatcher.PotentialMatch.parameterType(
+                    // a class from the dictionary is for the unwrapped type, not for its list or non-null wrapper
+                    if (propertyType != null) inputValueDefinition.type else inputGraphQLType,
+                    inputValueJavaType,
+                    GenericTypeResolver(javaType ?: inputValueJavaType, options),
+                    InputObjectReference(inputValueDefinition)
+                )))
             }
     }
 
@@ -502,8 +504,7 @@ internal class SchemaClassScanner(
     private fun handleInputValueWithoutJavaType(graphQLType: InputObjectTypeDefinition, inputValueDefinition: InputValueDefinition, inputGraphQLType: TypeName, clazz: Class<*>?) {
         if (clazz != null && !isPropertyMap(clazz)) {
             log.warn("Cannot find a public getter or field for field '${inputValueDefinition.name}: ${inputGraphQLType.name}' of input type '${graphQLType.name}' on ${clazz.name}. " +
-                "Unless Jackson maps it some other way, e.g. through @JsonProperty, check that the property name matches the schema, " +
-                "otherwise the field's value is rejected or dropped when the input is deserialized.")
+                "If Jackson doesn't map it some other way, e.g. through @JsonProperty, the field's value is rejected or dropped when the input is deserialized.")
         }
 
         when (val definition = definitionsByName[inputGraphQLType.name]) {
@@ -523,23 +524,22 @@ internal class SchemaClassScanner(
         }
     }
 
+    // an input bound to Any gets a Map at runtime too
     private fun isPropertyMap(clazz: Class<*>) =
-        java.util.Map::class.java.isAssignableFrom(clazz) || JsonNode::class.java.isAssignableFrom(clazz) || clazz == Object::class.java
+        Map::class.java.isAssignableFrom(clazz) || JsonNode::class.java.isAssignableFrom(clazz) || clazz == Any::class.java
 
     private fun isLibraryClass(clazz: Class<*>) =
-        listOf("java.", "javax.", "kotlin.", "com.fasterxml.jackson.").any { clazz.name.startsWith(it) }
+        listOf("java.", "kotlin.", "com.fasterxml.jackson.").any { clazz.name.startsWith(it) }
 
-    private fun enumWithoutClassMessage(enum: EnumTypeDefinition, graphQLType: InputObjectTypeDefinition, inputValueDefinition: InputValueDefinition, clazz: Class<*>?): String {
+    private fun enumWithoutClassMessage(enumType: EnumTypeDefinition, graphQLType: InputObjectTypeDefinition, inputValueDefinition: InputValueDefinition, clazz: Class<*>?): String {
         val field = inputValueDefinition.name
-        val problem = "Enum type '${enum.name}' is used by field '$field' of input type '${graphQLType.name}', but its Java enum can't be determined"
-        return when {
-            clazz == null -> "$problem because no class was found for input type '${graphQLType.name}'. " +
-                "Pass the enum class for type '${enum.name}' in the parser's dictionary, or a class for '${graphQLType.name}' with a public getter or field '$field'."
-            isPropertyMap(clazz) && isLibraryClass(clazz) -> "$problem because '${graphQLType.name}' is bound to ${clazz.name}, which has no type information for its fields. " +
-                "Pass the enum class for type '${enum.name}' in the parser's dictionary, or use a class for '${graphQLType.name}' with a public getter or field '$field'."
-            else -> "$problem because ${clazz.name} has no public getter or field named '$field'. " +
-                "Add a public getter or field '$field' to the class used for '${graphQLType.name}', or pass the enum class for type '${enum.name}' in the parser's dictionary."
+        val reason = when {
+            clazz == null -> "no class was found for input type '${graphQLType.name}'"
+            isPropertyMap(clazz) && isLibraryClass(clazz) -> "'${graphQLType.name}' is bound to ${clazz.name}, which has no type information for its fields"
+            else -> "${clazz.name} has no public getter or field named '$field'"
         }
+        return "Enum type '${enumType.name}' is used by field '$field' of input type '${graphQLType.name}', but its Java enum can't be determined because $reason. " +
+            "Pass the enum class for type '${enumType.name}' in the parser's dictionary, or use a class for '${graphQLType.name}' with a public getter or field '$field'."
     }
 
     private fun scanInterfacesOfType(graphQLType: ObjectTypeDefinition) {

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

@@ -574,32 +574,33 @@ class SchemaParser internal constructor(
         }
 
     private fun unexpectedTypeError(typeName: TypeName, expectedType: KClass<*>): SchemaError {
-        val name = typeName.name
-        val subject = "Type '$name'" +
-            (findUsage(typeName)?.let { " used by $it" } ?: "") +
-            (typeName.sourceLocation?.let { " at line ${it.line}, column ${it.column}" + (it.sourceName?.let { source -> " of $source" } ?: "") } ?: "")
-        // unused ones first, since the extensions of an unused type are still among the definitions
-        val definition = unusedDefinitions.find { it.name == name }
-            ?: definitions.filterIsInstance<TypeDefinition<*>>().find { it.name == name }
         val isInput = expectedType == GraphQLInputType::class
-        val kind = when (definition) {
-            is InputObjectTypeDefinition -> "an input object type"
+        // unused ones first, since the extensions of an unused type are still among the definitions
+        val definition = unusedDefinitions.find { it.name == typeName.name }
+            ?: definitions.filterIsInstance<TypeDefinition<*>>().find { it.name == typeName.name }
+        val outputOnlyKind = when (definition) {
+            is ObjectTypeDefinition -> "an object type"
             is InterfaceTypeDefinition -> "an interface"
             is UnionTypeDefinition -> "a union"
-            else -> "an object type"
+            else -> null
         }
 
-        return SchemaError(when {
-            definition == null -> "$subject is not defined in the schema."
-            isInput && definition !is InputObjectTypeDefinition && definition !is EnumTypeDefinition && definition !is ScalarTypeDefinition ->
-                "$subject is $kind, which can't be used as an input type. Input types are input objects, enums and scalars."
+        val problem = when {
+            definition == null -> "is not defined in the schema."
+            isInput && outputOnlyKind != null ->
+                "is $outputOnlyKind, which can't be used as an input type. Input types are input objects, enums and scalars."
             !isInput && definition is InputObjectTypeDefinition ->
-                "$subject is $kind, which can't be used as an output type. Output types are object types, interfaces, unions, enums and scalars."
+                "is an input object type, which can't be used as an output type. Output types are object types, interfaces, unions, enums and scalars."
             definition in unusedDefinitions ->
-                "$subject is defined in the schema, but was not reached while scanning the resolvers and the classes they use, so it wasn't built. " +
+                "is defined in the schema, but was not reached while scanning the resolvers and the classes they use, so it wasn't built. " +
                     unreachedTypeHint(definition)
-            else -> "$subject can't be used as ${if (isInput) "an input" else "an output"} type."
-        })
+            else -> "can't be used as ${if (isInput) "an input" else "an output"} type."
+        }
+        val usage = findUsage(typeName)?.let { " used by $it" }.orEmpty()
+        val location = typeName.sourceLocation
+            ?.let { " at line ${it.line}, column ${it.column}" + it.sourceName?.let { name -> " in $name" }.orEmpty() }
+            .orEmpty()
+        return SchemaError("Type '${typeName.name}'$usage$location $problem")
     }
 
     // what makes the scanner reach the type depends on its kind, see SchemaClassScanner.canIncludeUnusedType

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

@@ -172,7 +172,10 @@ class NestedInputTypesTest {
 
                 input EntityUpdateInput {
                     id: ID!
-                    nested: Nested
+                    # named like methods of ObjectNode
+                    values: [Nested]
+                    elements: [Nested]
+                    fields: [Nested]
                 }
 
                 input Nested {
@@ -193,13 +196,13 @@ class NestedInputTypesTest {
             """
             mutation {
                 create(input: { name: "n", nested: { x: 1 } })
-                update(input: { id: "2", nested: { x: 3 } })
+                update(input: { id: "2", values: [{ x: 3 }], elements: [{ x: 4 }], fields: [{ x: 5 }] })
             }
             """
         }
 
         assertEquals(data["create"], """{"name":"n","nested":{"x":1}}""")
-        assertEquals(data["update"], """{"id":"2","nested":{"x":3}}""")
+        assertEquals(data["update"], """{"id":"2","values":[{"x":3}],"elements":[{"x":4}],"fields":[{"x":5}]}""")
     }
 
     @Test
@@ -337,43 +340,6 @@ class NestedInputTypesTest {
         assertEquals(data["byClass"], "b, c")
     }
 
-    @Test
-    fun `input fields bound to ObjectNode are not matched against its own methods`() {
-        val schema = SchemaParser.newParser()
-            .schemaString(
-                """
-                type Query {
-                    create(input: EntityInput!): String
-                }
-
-                input EntityInput {
-                    values: [Nested]
-                    elements: [Nested]
-                    fields: [Nested]
-                }
-
-                input Nested {
-                    x: Int
-                }
-                """)
-            .resolvers(object : GraphQLQueryResolver {
-                fun create(input: ObjectNode): String = input.toString()
-            })
-            .build()
-            .makeExecutableSchema()
-        val gql = GraphQL.newGraphQL(schema).build()
-
-        val data = assertNoGraphQlErrors(gql) {
-            """
-            query {
-                create(input: { values: [{ x: 1 }], elements: [{ x: 2 }], fields: [{ x: 3 }] })
-            }
-            """
-        }
-
-        assertEquals(data["create"], """{"values":[{"x":1}],"elements":[{"x":2}],"fields":[{"x":3}]}""")
-    }
-
     @Test
     fun `input field types are found through the getters of a Map subclass`() {
         val schema = SchemaParser.newParser()

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

@@ -283,7 +283,7 @@ class SchemaParserTest {
                 .makeExecutableSchema()
         }
 
-        assertEquals(error.message, "Type 'Cat' used by field 'Pet.friend' at line 6, column 11 of UnreachedType.graphqls is defined in the schema, " +
+        assertEquals(error.message, "Type 'Cat' used by field 'Pet.friend' at line 6, column 11 in UnreachedType.graphqls is defined in the schema, " +
             "but was not reached while scanning the resolvers and the classes they use, so it wasn't built. " +
             "Return it from a resolver method or one of those classes, or set SchemaParserOptions.includeUnusedTypes and pass a class for it in the parser's dictionary.")
     }
@@ -572,60 +572,42 @@ class SchemaParserTest {
 
     @Test
     fun `parser should throw descriptive exception when enum is only used in input Map without a class`() {
-        val error = assertThrows(SchemaClassScannerError::class.java) {
-            SchemaParser.newParser()
-                .schemaString(
-                    """
-                    type Query {
-                        save(input: SaveInput!): Boolean
-                    }
+        val schema = """
+            type Query {
+                save(input: SaveInput!): Boolean
+            }
 
-                    input SaveInput {
-                        type: EnumType!
-                    }
+            input SaveInput {
+                type: EnumType!
+            }
 
-                    enum EnumType {
-                        TEST
-                    }
-                    """)
+            enum EnumType {
+                TEST
+            }
+            """
+        val mapError = assertThrows(SchemaClassScannerError::class.java) {
+            SchemaParser.newParser()
+                .schemaString(schema)
                 .resolvers(object : GraphQLQueryResolver {
                     fun save(input: Map<*, *>): Boolean = false
                 })
                 .build()
         }
-
-        assertEquals(error.message, "Enum type 'EnumType' is used by field 'type' of input type 'SaveInput', but its Java enum can't be determined " +
-            "because 'SaveInput' is bound to java.util.Map, which has no type information for its fields. Pass the enum class for type " +
-            "'EnumType' in the parser's dictionary, or use a class for 'SaveInput' with a public getter or field 'type'.")
-    }
-
-    @Test
-    fun `parser should throw descriptive exception when enum is only used in input Map subclass without a getter for it`() {
-        val error = assertThrows(SchemaClassScannerError::class.java) {
+        val subclassError = assertThrows(SchemaClassScannerError::class.java) {
             SchemaParser.newParser()
-                .schemaString(
-                    """
-                    type Query {
-                        save(input: SaveInput!): Boolean
-                    }
-
-                    input SaveInput {
-                        type: EnumType!
-                    }
-
-                    enum EnumType {
-                        TEST
-                    }
-                    """)
+                .schemaString(schema)
                 .resolvers(object : GraphQLQueryResolver {
                     fun save(input: SaveInputMap): Boolean = false
                 })
                 .build()
         }
 
-        assertEquals(error.message, "Enum type 'EnumType' is used by field 'type' of input type 'SaveInput', but its Java enum can't be determined " +
-            "because ${SaveInputMap::class.java.name} has no public getter or field named 'type'. Add a public getter or field 'type' to the class " +
-            "used for 'SaveInput', or pass the enum class for type 'EnumType' in the parser's dictionary.")
+        assertEquals(mapError.message, "Enum type 'EnumType' is used by field 'type' of input type 'SaveInput', but its Java enum can't be determined " +
+            "because 'SaveInput' is bound to java.util.Map, which has no type information for its fields. Pass the enum class for type " +
+            "'EnumType' in the parser's dictionary, or use a class for 'SaveInput' with a public getter or field 'type'.")
+        assertEquals(subclassError.message, "Enum type 'EnumType' is used by field 'type' of input type 'SaveInput', but its Java enum can't be determined " +
+            "because ${SaveInputMap::class.java.name} has no public getter or field named 'type'. Pass the enum class for type " +
+            "'EnumType' in the parser's dictionary, or use a class for 'SaveInput' with a public getter or field 'type'.")
     }
 
     @Test
@@ -658,7 +640,7 @@ class SchemaParserTest {
 
         assertEquals(error.message, "Enum type 'EnumType' is used by field 'type' of input type 'NestedInput', but its Java enum can't be determined " +
             "because no class was found for input type 'NestedInput'. Pass the enum class for type 'EnumType' in the parser's dictionary, " +
-            "or a class for 'NestedInput' with a public getter or field 'type'.")
+            "or use a class for 'NestedInput' with a public getter or field 'type'.")
     }
 
     @Test