Include unused types one at a time and don't require classes for interfaces and unions

Handling all unused types at once required a dictionary class for types
that would have been discovered by scanning another unused type. Unused
interfaces and unions are now included without a class, and unused enums
missing from the dictionary are only reported as unused instead of failing.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: oryan-block

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

@@ -86,29 +86,40 @@ internal class SchemaClassScanner(
             handleDictionaryTypes(getAllObjectTypeMembersOfDiscoveredUnions()) { "Object type '${it.name}' is a member of a known union, but no class could be found for that type name.  Please pass a class for type '${it.name}' in the parser's dictionary." }
         } while (scanQueue())
 
+        handleDirectives()
+
         // Find unused types and include them if required
         if (options.includeUnusedTypes) {
-            do {
-                val unusedDefinitions = (definitionsByName.values - (dictionary.keys.toSet() + unvalidatedTypes))
+            // One type at a time, since scanning it can discover other unused types along with their classes
+            while (true) {
+                val unusedDefinition = (definitionsByName.values - (dictionary.keys.toSet() + unvalidatedTypes))
                     .filter { definition -> definition.name != "PageInfo" }
-                    .filter { isCompositeOrEnumType(it) }
-                    .distinct()
+                    .firstOrNull { canIncludeUnusedType(it) }
+                    ?: break
 
-                if (unusedDefinitions.isEmpty()) {
-                    break
-                }
-
-                handleDictionaryTypes(unusedDefinitions) { "Type '${it.name}' is unused and includeUnusedTypes is true. Please pass a class for type '${it.name}' in the parser's dictionary." }
-            } while (scanQueue())
+                handleUnusedType(unusedDefinition)
+                scanQueue()
+            }
         }
 
-        handleDirectives()
-
         return validateAndCreateResult(rootTypeHolder)
     }
 
-    private fun isCompositeOrEnumType(definition: TypeDefinition<*>): Boolean {
-        return definition is ObjectTypeDefinition || definition is InterfaceTypeDefinition || definition is UnionTypeDefinition || definition is EnumTypeDefinition
+    private fun canIncludeUnusedType(definition: TypeDefinition<*>): Boolean = when (definition) {
+        is ObjectTypeDefinition, is InterfaceTypeDefinition, is UnionTypeDefinition -> true
+        // Enums can't be built without a class, so the ones missing from the dictionary are only reported as unused
+        is EnumTypeDefinition -> initialDictionary.containsKey(definition.name)
+        else -> false
+    }
+
+    private fun handleUnusedType(type: TypeDefinition<*>) {
+        val initialEntry = initialDictionary[type.name]
+        when {
+            initialEntry != null -> handleFoundType(type, initialEntry.get(), DictionaryReference())
+            // Interfaces and unions are resolved through the classes of their implementations, so they don't need one
+            type is InterfaceTypeDefinition || type is UnionTypeDefinition -> handleFoundType(type, null, UnusedTypeReference())
+            else -> throw SchemaClassScannerError("Object type '${type.name}' is unused and includeUnusedTypes is true. Please pass a class for type '${type.name}' in the parser's dictionary.")
+        }
     }
 
     private fun scanQueue(): Boolean {
@@ -466,6 +477,10 @@ internal class SchemaClassScanner(
         override fun getDescription() = "provided dictionary"
     }
 
+    private class UnusedTypeReference : Reference() {
+        override fun getDescription() = "unused type"
+    }
+
     private class InterfaceReference(private val type: ObjectTypeDefinition) : Reference() {
         override fun getDescription() = "interface declarations of ${type.name}"
     }

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

@@ -503,7 +503,7 @@ class SchemaClassScannerTest {
     }
 
     @Test
-    fun `scanner should handle unused types with interfaces when option is true`() {
+    fun `scanner should handle unused types with interfaces, unions and enums when option is true`() {
         val schema = SchemaParser.newParser()
             .schemaString(
                 """
@@ -526,19 +526,28 @@ class SchemaClassScannerTest {
                 type Implementation implements SomeInterface {
                     value: String
                 }
-                
+
+                interface OtherInterface {
+                    value: String
+                }
+
                 union SomeUnion = Unused | Implementation
-                
+
                 enum SomeEnum {
-                   A
-                   B
+                    A
+                    B
+                }
+
+                enum OtherEnum {
+                    A
+                    B
                 }
                 """)
             .resolvers(object : GraphQLQueryResolver {
                 fun whatever(): Whatever? = null
             })
             .options(SchemaParserOptions.newOptions().includeUnusedTypes(true).build())
-            .dictionary(Unused::class, Implementation::class, SomeInterface::class, SomeUnion::class, SomeEnum::class)
+            .dictionary(Unused::class, Implementation::class, SomeEnum::class)
             .build()
             .makeExecutableSchema()
 
@@ -547,12 +556,51 @@ class SchemaClassScannerTest {
         assert(objectTypes.any { it.name == "Unused" })
         assert(objectTypes.any { it.name == "Implementation" })
         assert(interfaceTypes.any { it.name == "SomeInterface" })
+        assert(schema.getType("OtherInterface") is GraphQLInterfaceType)
+        assert(schema.getType("SomeUnion") is GraphQLUnionType)
+        assert(schema.getType("SomeEnum") is GraphQLEnumType)
+        assert(schema.getType("OtherEnum") == null)
+    }
+
+    @Test
+    fun `scanner should handle unused enum used as an argument of a missing resolver when option is true`() {
+        val schema = SchemaParser.newParser()
+            .schemaString(
+                """
+                type Query {
+                    whatever: Whatever
+                    preview(value: SomeEnum): String
+                }
+
+                type Whatever {
+                    value: String
+                }
+
+                enum SomeEnum {
+                    A
+                    B
+                }
+                """)
+            .resolvers(object : GraphQLQueryResolver {
+                fun whatever(): Whatever? = null
+            })
+            .options(SchemaParserOptions.newOptions()
+                .includeUnusedTypes(true)
+                .missingResolverDataFetcherProvider { _, _ -> DataFetcher<Any?> { null } }
+                .build())
+            .dictionary(SomeEnum::class)
+            .build()
+            .makeExecutableSchema()
+
+        assert(schema.queryType.getFieldDefinition("preview").getArgument("value").type is GraphQLEnumType)
     }
 
     class Whatever {
         var value: String? = null
     }
 
+    enum class SomeEnum { A, B }
+
     class Unused {
         var someInterface: SomeInterface? = null
     }

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

@@ -14,10 +14,3 @@ interface SomeInterface {
     fun getValue(): String?
 }
 
-interface SomeUnion
-
-enum class SomeEnum {
-    A,
-    B
-}
-