Fix suspend resolver context and Kotlin extension resolvers

A suspend resolver taking GraphQLContext or the custom context class as
its last argument failed at runtime with "argument type mismatch".
MethodFieldResolver picked the type of the last JVM parameter to decide
what to pass, but for a suspend function that is the Continuation, so it
fell through to passing the DataFetchingEnvironment. It now looks at the
last counted parameter instead.

Kotlin extension functions in a GraphQLResolver could not be used as
resolver methods because parameters were counted with
kotlinFunction.valueParameters, which leaves out the extension receiver.
They were either skipped or matched with the wrong arity and failed at
runtime. FieldResolverScanner and MethodFieldResolver now count every
parameter except the instance, which matches the JVM parameters minus
the Continuation, so the receiver takes the source object.

An extension receiver is only accepted in that source position.
Extension helpers on root resolvers and data classes used to be matched
when their arity happened to fit, and then either collided with the
real resolver method at build time or failed with the wrong number of
arguments at query time. They are now skipped during matching.

Fixes #318
Fixes #272

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

Author: oryan-block

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

@@ -16,7 +16,8 @@ import org.apache.commons.lang3.reflect.TypeUtils
 import org.reactivestreams.Publisher
 import org.slf4j.LoggerFactory
 import java.lang.reflect.*
-import kotlin.reflect.full.valueParameters
+import kotlin.reflect.KParameter
+import kotlin.reflect.full.extensionReceiverParameter
 import kotlin.reflect.jvm.javaType
 import kotlin.reflect.jvm.kotlinFunction
 
@@ -160,7 +161,8 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) {
                 it == search.requiredFirstParameterType || method.declaringClass.typeParameters.contains(it)
             } ?: false
         } else {
-            true
+            // an extension receiver can only take the source object
+            !isExtensionFunction(method)
         }
 
         val methodParameterCount = getMethodParameterCount(method)
@@ -173,21 +175,29 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) {
 
     private fun getMethodParameterCount(method: Method): Int {
         return try {
-            method.kotlinFunction?.valueParameters?.size ?: method.parameterCount
+            method.kotlinFunction?.parameters?.count { it.kind != KParameter.Kind.INSTANCE } ?: method.parameterCount
         } catch (e: InternalError) {
             method.parameterCount
         }
     }
 
     private fun getMethodLastParameter(method: Method): Type? {
         return try {
-            method.kotlinFunction?.valueParameters?.lastOrNull()?.type?.javaType
+            method.kotlinFunction?.parameters?.lastOrNull { it.kind != KParameter.Kind.INSTANCE }?.type?.javaType
                 ?: method.parameterTypes.lastOrNull()
         } catch (e: InternalError) {
             method.parameterTypes.lastOrNull()
         }
     }
 
+    private fun isExtensionFunction(method: Method): Boolean {
+        return try {
+            method.kotlinFunction?.extensionReceiverParameter != null
+        } catch (e: InternalError) {
+            false
+        }
+    }
+
     private fun findResolverProperty(field: FieldDefinition, search: Search) =
         FieldUtils.getAllFields(search.type.unwrap()).find { it.name == field.name }
 

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

@@ -24,7 +24,7 @@ import java.lang.reflect.Method
 import java.util.*
 import java.util.function.Supplier
 import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
-import kotlin.reflect.full.valueParameters
+import kotlin.reflect.KParameter
 import kotlin.reflect.jvm.javaType
 import kotlin.reflect.jvm.kotlinFunction
 
@@ -41,7 +41,7 @@ internal class MethodFieldResolver(
     private val log = LoggerFactory.getLogger(javaClass)
 
     private val isSuspendFunction = method.isSuspendFunction()
-    private val numberOfParameters = method.kotlinFunction?.valueParameters?.size ?: method.parameterCount
+    private val numberOfParameters = method.kotlinFunction?.parameters?.count { it.kind != KParameter.Kind.INSTANCE } ?: method.parameterCount
     private val hasAdditionalParameter = numberOfParameters == (field.inputValueDefinitions.size + getIndexOffset() + 1)
 
     override fun createDataFetcher(): DataFetcher<*> {
@@ -100,7 +100,8 @@ internal class MethodFieldResolver(
 
         // Add DataFetchingEnvironment/Context argument
         if (this.hasAdditionalParameter) {
-            when (this.method.parameterTypes.last()) {
+            // suspend functions have a trailing Continuation parameter
+            when (this.method.parameterTypes[numberOfParameters - 1]) {
                 null -> throw ResolverError("Expected at least one argument but got none, this is most likely a bug with graphql-java-tools")
                 options.contextClass -> args.add { environment ->
                     val context: Any? = environment.graphQlContext[options.contextClass]

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

@@ -6,10 +6,12 @@ import graphql.kickstart.tools.resolver.FieldResolverScanner
 import graphql.kickstart.tools.resolver.MethodFieldResolver
 import graphql.kickstart.tools.resolver.PropertyFieldResolver
 import graphql.language.FieldDefinition
+import graphql.language.InputValueDefinition
 import graphql.language.TypeName
 import graphql.relay.Connection
 import graphql.relay.DefaultConnection
 import graphql.relay.DefaultPageInfo
+import graphql.schema.DataFetchingEnvironment
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import org.junit.Test
 import java.util.*
@@ -98,6 +100,21 @@ class FieldResolverScannerTest {
         Locale.setDefault(default)
     }
 
+    @Test
+    fun `scanner ignores extension functions on root resolvers`() {
+        val resolver = RootResolverInfo(listOf(UserQuery(), ExtensionQuery()), options)
+        val field = FieldDefinition.newFieldDefinition()
+            .name("user")
+            .type(TypeName("String"))
+            .inputValueDefinition(InputValueDefinition("id", TypeName("ID")))
+            .build()
+
+        val user = scanner.findFieldResolver(field, resolver)
+
+        assert(user is MethodFieldResolver)
+        assertEquals((user as MethodFieldResolver).method.declaringClass, UserQuery::class.java)
+    }
+
     class RootQuery1 : GraphQLQueryResolver {
         fun field1() {}
     }
@@ -110,6 +127,14 @@ class FieldResolverScannerTest {
         fun field1() {}
     }
 
+    class UserQuery : GraphQLQueryResolver {
+        fun user(id: String): String = id
+    }
+
+    class ExtensionQuery : GraphQLQueryResolver {
+        fun DataFetchingEnvironment.user(): String = field.name
+    }
+
     class CamelCaseQuery1 : GraphQLQueryResolver {
         fun getHullType(): HullType = HullType()
     }

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

@@ -212,6 +212,54 @@ class MethodFieldResolverDataFetcherTest {
         assertEquals(resolver.get(createEnvironment(DataClass(), context = context)), true)
     }
 
+    @Test
+    fun `data fetcher passes context to suspend function if method has extra argument and context is specified`() {
+        val context = GraphQLContext.newContext().build()
+        val resolver = createFetcher("active", resolver = object : GraphQLResolver<DataClass> {
+            suspend fun isActive(dataClass: DataClass, ctx: GraphQLContext): Boolean {
+                return ctx == context
+            }
+        })
+
+        @Suppress("UNCHECKED_CAST")
+        val future = resolver.get(createEnvironment(DataClass(), context = context)) as CompletableFuture<Boolean>
+        assert(future.get())
+    }
+
+    @Test
+    fun `data fetcher passes custom context to suspend function if method has extra argument and custom context is specified`() {
+        val customContext = ContextClass()
+        val context = GraphQLContext.of(mapOf(ContextClass::class.java to customContext))
+        val options = SchemaParserOptions.newOptions().contextClass(ContextClass::class).build()
+        val resolver = createFetcher("active", options = options, resolver = object : GraphQLResolver<DataClass> {
+            suspend fun isActive(dataClass: DataClass, ctx: ContextClass): Boolean {
+                return ctx == customContext
+            }
+        })
+
+        @Suppress("UNCHECKED_CAST")
+        val future = resolver.get(createEnvironment(DataClass(), context = context)) as CompletableFuture<Boolean>
+        assert(future.get())
+    }
+
+    @Test
+    fun `data fetcher uses extension function on the data class`() {
+        val resolver = createFetcher("name", object : GraphQLResolver<DataClass> {
+            fun DataClass.name(): String = "extension $name"
+        })
+
+        assertEquals(resolver.get(createEnvironment(DataClass())), "extension TestName")
+    }
+
+    @Test
+    fun `data fetcher passes environment to extension function if method has extra argument`() {
+        val resolver = createFetcher("active", object : GraphQLResolver<DataClass> {
+            fun DataClass.isActive(env: DataFetchingEnvironment): Boolean = env is DataFetchingEnvironment
+        })
+
+        assertEquals(resolver.get(createEnvironment(DataClass())), true)
+    }
+
     @Test
     fun `data fetcher marshalls input object if required`() {
         val name = "correct name"