Honor null generic wrapper results

A generic wrapper transformer that returned null was ignored, because
transformWithGenericWrapper fell back to the original object with an
elvis operator. Option-like wrappers could therefore never map their
empty case to null: a scalar field serialized the wrapper's toString
and an object or list field failed at runtime. The transformer result
is now returned as is, including null, and the original object is only
kept when no wrapper matches.

Fixes #371

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

Author: oryan-block

src/main/kotlin/graphql/kickstart/tools/resolver/MethodFieldResolver.kt

@@ -266,13 +266,16 @@ internal class LightMethodFieldResolverDataFetcher(
 private fun Any.transformWithGenericWrapper(
     genericWrappers: List<GenericWrapper>,
     environmentSupplier: Supplier<DataFetchingEnvironment>
-): Any {
-    return genericWrappers
+): Any? {
+    val genericWrapper = genericWrappers
         .asSequence()
         .filter { it.type.isInstance(this) }
         .sortedWith(CompareGenericWrappers)
         .firstOrNull()
-        ?.transformer?.invoke(this, environmentSupplier.get()) ?: this
+        ?: return this
+
+    // a transformer may map a value to null, e.g. the empty case of an Option-like wrapper
+    return genericWrapper.transformer(this, environmentSupplier.get())
 }
 
 private class CompareGenericWrappers {

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

@@ -239,6 +239,51 @@ class MethodFieldResolverTest {
         assertEquals(exceptionWhileDataFetching.exception.message, "Whoops")
     }
 
+    @Test
+    fun `should return null when generic wrapper transformer returns null`() {
+        val schema = SchemaParser.newParser()
+            .schemaString(
+                """
+                type Query {
+                    name: String
+                    names: [String!]
+                    nameWithArgument(input: String): String
+                }
+                """)
+            .resolvers(object : GraphQLQueryResolver {
+                fun name(): Maybe<String> = Maybe.None
+                fun names(): Maybe<List<String>> = Maybe.None
+                fun nameWithArgument(input: String?): Maybe<String> = Maybe.None
+            })
+            .options(SchemaParserOptions.newOptions()
+                .genericWrappers(SchemaParserOptions.GenericWrapper.withTransformer(Maybe::class, 0, { maybe -> (maybe as? Maybe.Some)?.value }))
+                .build())
+            .build()
+            .makeExecutableSchema()
+
+        val gql = GraphQL.newGraphQL(schema).build()
+        val result = gql.execute(ExecutionInput.newExecutionInput().query(
+            """
+            query {
+                name
+                names
+                nameWithArgument(input: "test")
+            }
+            """))
+
+        assertEquals(result.errors, listOf())
+        assertEquals(result.getData(), mapOf(
+            "name" to null,
+            "names" to null,
+            "nameWithArgument" to null
+        ))
+    }
+
+    sealed class Maybe<out T> {
+        data class Some<T>(val value: T) : Maybe<T>()
+        object None : Maybe<Nothing>()
+    }
+
     /**
      * Custom Scalar Class type that doesn't work with Jackson serialization/deserialization
      */