oryan-block · Oct 18, 2026 · Oct 18, 2026 · Oct 18, 2026 · Oct 18, 2026 · Oct 18, 2026
diff --git a/pom.xml b/pom.xml
@@ -276,8 +276,9 @@
                         </goals>
                     </execution>
                     <execution>
+                        <!-- before javac, so the Java tests can use the Kotlin test helpers -->
                         <id>test-compile</id>
-                        <phase>test-compile</phase>
+                        <phase>process-test-sources</phase>
                         <goals>
                             <goal>test-compile</goal>
                         </goals>

diff --git a/src/test/java17/graphql/kickstart/tools/SchemaClassScannerSealedJavaTypesTest.java b/src/test/java17/graphql/kickstart/tools/SchemaClassScannerSealedJavaTypesTest.java
@@ -50,6 +50,7 @@ interface Animal {
             .resolvers(new PetQuery(), new AnimalQuery())
             .build()
             .makeExecutableSchema();
+        EveryFieldResolvesKt.assertEveryFieldResolves(schema);
 
         ExecutionResult result = GraphQL.newGraphQL(schema).build().execute(ExecutionInput.newExecutionInput().query("""
             query {

diff --git a/src/test/kotlin/graphql/kickstart/tools/BuiltInIdTest.kt b/src/test/kotlin/graphql/kickstart/tools/BuiltInIdTest.kt
@@ -33,6 +33,12 @@ class BuiltInIdTest {
         .queryExecutionStrategy(AsyncExecutionStrategy())
         .build()
 
+    @Test
+    fun `every field resolves`() {
+        // the made-up ID "1" isn't a UUID
+        schema.assertEveryFieldResolves(except = setOf("Query.itemByUuidId(id:)", "Query.itemsByUuidIds(ids:)"))
+    }
+
     @Test
     fun `supports Long as ID as input`() {
         val data = assertNoGraphQlErrors(gql) {

diff --git a/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt b/src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt
@@ -191,6 +191,7 @@ class CustomScalarInputTest {
             .options(options)
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
         return GraphQL.newGraphQL(graphQLSchema).build()
     }
 
@@ -265,7 +266,7 @@ class CustomScalarInputTest {
         fun optionalEvent(input: Optional<EventInput>): String = input.map { event(it) }.orElse("empty")
         fun message(input: MessageInput): String = "${input.name}: ${(listOfNotNull(input.file) + input.files).joinToString(" ") { it.content() }}"
         fun label(input: LabelInput): String = "${input.date} ${input.opaque}"
-        fun dateNode(input: ObjectNode): String = (input["date"] as POJONode).pojo.let { "${it.javaClass.simpleName} $it" }
+        fun dateNode(input: ObjectNode): String = (input["date"] as POJONode?)?.pojo?.let { "${it.javaClass.simpleName} $it" }.orEmpty()
         fun priceNode(input: ObjectNode): String = input.toString()
         fun payment(input: PaymentInput): String = listOfNotNull(input.price, input.reference, input.date, input.box).joinToString(" ")
         fun price(price: MoneyDto): String = price.toString()

diff --git a/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt b/src/test/kotlin/graphql/kickstart/tools/DeepGenericsHierarchyTest.kt
@@ -12,6 +12,7 @@ class PlaceTest {
             .file("Place.graphqls")
             .resolvers(PlaceQuery())
             .build().makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val graphql = GraphQL.newGraphQL(schema).build()
         val query = "query { places1 { id } places2 { id } }"

diff --git a/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/DeprecatedDirectiveTest.kt
@@ -35,6 +35,7 @@ class DeprecatedDirectiveTest {
             .resolvers(UsersQueryResolver())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val userType = schema.getType("User") as GraphQLObjectType
         val nameDefinition = userType.getField("name")
@@ -68,6 +69,7 @@ class DeprecatedDirectiveTest {
             .resolvers(UsersQueryResolver())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val userType = schema.getType("User") as GraphQLObjectType
         val nameDefinition = userType.getField("name")
@@ -108,6 +110,7 @@ class DeprecatedDirectiveTest {
             .resolvers(UsersQueryResolver())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val userTypeEnum = schema.getType("UserType") as GraphQLEnumType
         val droidValue = userTypeEnum.getValue("DROID")
@@ -148,6 +151,7 @@ class DeprecatedDirectiveTest {
             .resolvers(UsersQueryResolver())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val userTypeEnum = schema.getType("UserType") as GraphQLEnumType
         val droidValue = userTypeEnum.getValue("DROID")
@@ -178,9 +182,10 @@ class DeprecatedDirectiveTest {
                     name: String
                 }
                 """)
-            .resolvers(UsersQueryResolver())
+            .resolvers(UsersWithFirstQueryResolver())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val usersQuery = schema.queryType.getField("users")
         val firstArgument = usersQuery.getArgument("first")
@@ -211,9 +216,10 @@ class DeprecatedDirectiveTest {
                     name: String
                 }
                 """)
-            .resolvers(UsersQueryResolver())
+            .resolvers(UsersWithFirstQueryResolver())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val usersQuery = schema.queryType.getField("users")
         val firstArgument = usersQuery.getArgument("first")
@@ -249,6 +255,7 @@ class DeprecatedDirectiveTest {
             .resolvers(UsersQueryResolver())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val directive = schema.getDirective("uppercase")
         val argument = directive!!.getArgument("firstCharacterOnly")
@@ -284,6 +291,7 @@ class DeprecatedDirectiveTest {
             .resolvers(UsersQueryResolver())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val directive = schema.getDirective("uppercase")
         val argument = directive!!.getArgument("firstCharacterOnly")
@@ -318,9 +326,10 @@ class DeprecatedDirectiveTest {
                     name: String
                 }
                 """)
-            .resolvers(UsersQueryResolver())
+            .resolvers(UsersWithConnectionInputQueryResolver())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val connectionInputType = schema.getType("ConnectionInput") as GraphQLInputObjectType
         val firstField = connectionInputType.getField("first")
@@ -355,9 +364,10 @@ class DeprecatedDirectiveTest {
                     name: String
                 }
                 """)
-            .resolvers(UsersQueryResolver())
+            .resolvers(UsersWithConnectionInputQueryResolver())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val connectionInputType = schema.getType("ConnectionInput") as GraphQLInputObjectType
         val firstField = connectionInputType.getField("first")
@@ -395,9 +405,10 @@ class DeprecatedDirectiveTest {
                     type: UserType @deprecated(reason: "custom")
                 }
                 """)
-            .resolvers(UsersQueryResolver())
+            .resolvers(UsersWithFirstQueryResolver())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val name = (schema.getType("User") as GraphQLObjectType).getField("name")
         assertEquals("No longer supported", name.getAppliedDirective("deprecated").getArgument("reason")!!.getValue<String>())
@@ -415,16 +426,30 @@ class DeprecatedDirectiveTest {
     }
 
     private class UsersQueryResolver : GraphQLQueryResolver {
-        fun users(env: DataFetchingEnvironment): Connection<User> {
-            return SimpleListConnection(listOf(User(1L, "Luke Skywalker", "Luke", "Skywalker", UserType.JEDI))).get(env)
-        }
-
-        private data class User(
-            val id: Long,
-            val name: String,
-            val firstName: String,
-            val lastName: String,
-            val type: UserType
-        )
+        fun users(env: DataFetchingEnvironment): Connection<User> = SimpleListConnection(users).get(env)
+    }
+
+    private class UsersWithFirstQueryResolver : GraphQLQueryResolver {
+        fun users(first: Int?, env: DataFetchingEnvironment): Connection<User> = SimpleListConnection(users).get(env)
+    }
+
+    private class UsersWithConnectionInputQueryResolver : GraphQLQueryResolver {
+        fun users(connectionInput: ConnectionInput?, env: DataFetchingEnvironment): Connection<User> = SimpleListConnection(users).get(env)
+    }
+
+    data class ConnectionInput(
+        val first: Int?
+    )
+
+    private data class User(
+        val id: Long,
+        val name: String,
+        val firstName: String,
+        val lastName: String,
+        val type: UserType
+    )
+
+    companion object {
+        private val users = listOf(User(1L, "Luke Skywalker", "Luke", "Skywalker", UserType.JEDI))
     }
 }
diff --git a/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt
@@ -41,6 +41,7 @@ class DirectiveTest {
             .directive("uppercase", UppercaseDirective())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val gql = GraphQL.newGraphQL(schema)
             .queryExecutionStrategy(AsyncExecutionStrategy())
@@ -93,6 +94,7 @@ class DirectiveTest {
             .directive("uppercase", UppercaseDirective())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val gql = GraphQL.newGraphQL(schema)
             .queryExecutionStrategy(AsyncExecutionStrategy())
@@ -137,6 +139,7 @@ class DirectiveTest {
             .directive("uppercase", UppercaseDirective())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val gql = GraphQL.newGraphQL(schema)
             .queryExecutionStrategy(AsyncExecutionStrategy())
@@ -179,6 +182,7 @@ class DirectiveTest {
             .directive("double", DoubleDirective())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val gql = GraphQL.newGraphQL(schema)
             .queryExecutionStrategy(AsyncExecutionStrategy())
@@ -215,11 +219,14 @@ class DirectiveTest {
                     name: String @auth @log
                 }
                 """)
-            .resolvers(NameResolver())
+            .resolvers(object : GraphQLQueryResolver {
+                fun name(): String? = null
+            })
             .directive("auth", DescriptionDirective("auth"))
             .directive("log", DescriptionDirective("log"))
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         assertEquals(schema.queryType.getField("name").description, "Name +auth +log")
     }
@@ -236,11 +243,14 @@ class DirectiveTest {
                     name: String @auth
                 }
                 """)
-            .resolvers(NameResolver())
+            .resolvers(object : GraphQLQueryResolver {
+                fun name(): String? = null
+            })
             .directive("auth", DescriptionDirective("auth"))
             .directiveWiring(DescriptionDirective("static"))
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         assertEquals(schema.queryType.getField("name").description, "Name +auth +static")
     }
@@ -285,6 +295,7 @@ class DirectiveTest {
             .directive("uppercase", UppercaseDirective())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val gql = GraphQL.newGraphQL(schema)
             .queryExecutionStrategy(AsyncExecutionStrategy())
@@ -337,6 +348,7 @@ class DirectiveTest {
             .dictionary(AllowedState::class)
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         GraphQL.newGraphQL(schema)
             .queryExecutionStrategy(AsyncExecutionStrategy())
@@ -365,6 +377,7 @@ class DirectiveTest {
             .resolvers(BookQueryResolver())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val filter = schema.getType("BookFilter") as GraphQLInputObjectType
         assert(filter.isOneOf)
@@ -404,6 +417,7 @@ class DirectiveTest {
             .directive("email", emailDirective)
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val expectedMessages = mapOf(
             "contactEmail" to "{path} must be a valid email",
@@ -452,6 +466,7 @@ class DirectiveTest {
                 .directive("option", recorder)
                 .build()
                 .makeExecutableSchema()
+                .assertEveryFieldResolves()
 
             val inputObject = listOf("GraphQLInputObjectType")
             val expectedTypes = mapOf("name" to inputObject, "ConfigInput" to inputObject, "level" to inputObject)
@@ -490,6 +505,7 @@ class DirectiveTest {
                 })
                 .build()
                 .makeExecutableSchema()
+                .assertEveryFieldResolves()
 
             assert(wiredFields == listOf("max")) { "$wiredFields with directives declared as $directives" }
             val limit = (schema.getType("BoundInput") as GraphQLInputObjectType).getField("max").getAppliedDirective("limit")
@@ -531,6 +547,7 @@ class DirectiveTest {
             .dictionary(LinkPurpose::class)
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         assertEquals(schema.schemaAppliedDirectives.map { it.name }, listOf("contact", "link", "link"))
         assertEquals(
@@ -594,6 +611,7 @@ class DirectiveTest {
             .options(SchemaParserOptions.newOptions().allowUndeclaredDirectives(true).build())
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val link = schema.getSchemaAppliedDirective("link")
         assertEquals(link.getArgument("import")?.getValue<List<String>>(), listOf("@key", "@shareable"))
@@ -644,7 +662,7 @@ class DirectiveTest {
         fun book(filter: BookFilter): Book? = null
     }
 
-    private data class BookFilter(
+    data class BookFilter(
         val id: Int?,
         val name: String?
     )
@@ -655,7 +673,7 @@ class DirectiveTest {
         fun updatePerson(person: PersonInput?, state: AllowedState?): String? = null
     }
 
-    private data class PersonInput(
+    data class PersonInput(
         val email: String?
     )
 

diff --git a/src/test/kotlin/graphql/kickstart/tools/EndToEndSpecHelper.kt b/src/test/kotlin/graphql/kickstart/tools/EndToEndSpecHelper.kt
@@ -292,7 +292,7 @@ class Query : GraphQLQueryResolver, ListListResolver<String>() {
     fun itemsWithOptionalInput(input: ItemSearchInput?) = if (input == null) items else items(input)
     fun itemsWithOptionalInputExplicit(input: Optional<ItemSearchInput>?) = if (input?.isPresent == true) items(input.get()) else items
     fun enumInputType(type: Type) = type
-    fun customScalarMapInputType(customScalarMap: Map<String, Any>) = customScalarMap
+    fun customScalarMapInputType(customScalarMap: Map<String, Any>?) = customScalarMap
     fun itemWithGenericProperties() = ItemWithGenericProperties(listOf("A", "B"))
 
     fun defaultArgument(arg: Boolean) = arg

diff --git a/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt b/src/test/kotlin/graphql/kickstart/tools/EndToEndTest.kt
@@ -21,6 +21,15 @@ class EndToEndTest {
         .queryExecutionStrategy(AsyncExecutionStrategy())
         .build()
 
+    @Test
+    fun `every field resolves`() {
+        val newItem = Item(1, "item", Type.TYPE_1, UUID.randomUUID(), listOf())
+        // throws on purpose to test that the original exception is passed on
+        schema.assertEveryFieldResolves(except = setOf("Query.throwsIllegalArgumentException")) {
+            graphQLContext(mapOf("newItem" to newItem))
+        }
+    }
+
     @Test
     fun `schema comments are used as descriptions`() {
         val type = schema.allTypesAsList.find { it.name == "Type" } as GraphQLEnumType

diff --git a/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt b/src/test/kotlin/graphql/kickstart/tools/EnumDefaultValueTest.kt
@@ -29,6 +29,7 @@ class EnumDefaultValueTest {
             })
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val ggl = GraphQL.newGraphQL(schema)
             .queryExecutionStrategy(AsyncExecutionStrategy())
@@ -64,6 +65,7 @@ class EnumDefaultValueTest {
             })
             .build()
             .makeExecutableSchema()
+            .assertEveryFieldResolves()
 
         val ggl = GraphQL.newGraphQL(schema).build()