Added unit test to reproduce and fix #101

Author: oliemansm

src/main/kotlin/com/coxautodev/graphql/tools/MethodFieldResolver.kt

@@ -3,9 +3,6 @@ package com.coxautodev.graphql.tools
 import com.coxautodev.graphql.tools.SchemaParserOptions.GenericWrapper
 import com.esotericsoftware.reflectasm.MethodAccess
 import com.fasterxml.jackson.core.type.TypeReference
-import com.fasterxml.jackson.databind.ObjectMapper
-import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
-import com.fasterxml.jackson.module.kotlin.registerKotlinModule
 import graphql.execution.batched.Batched
 import graphql.language.FieldDefinition
 import graphql.language.NonNullType
@@ -108,7 +105,14 @@ internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolver
         } + listOf(returnValueMatch)
     }
 
-    private fun getIndexOffset() = if (resolverInfo is NormalResolverInfo || resolverInfo is MultiResolverInfo) 1 else 0
+    private fun getIndexOffset(): Int {
+        return if (resolverInfo is DataClassTypeResolverInfo && !method.declaringClass.isAssignableFrom(resolverInfo.dataClassType)) {
+            1
+        } else {
+            0
+        }
+    }
+
     private fun getJavaMethodParameterIndex(index: Int) = index + getIndexOffset()
 
     private fun getJavaMethodParameterType(index: Int): JavaType? {

src/main/kotlin/com/coxautodev/graphql/tools/ResolverInfo.kt

@@ -10,9 +10,13 @@ internal abstract class ResolverInfo {
             options.proxyHandlers.find { it.canHandle(resolver) }?.getTargetClass(resolver) ?: resolver.javaClass
 }
 
-internal class NormalResolverInfo(val resolver: GraphQLResolver<*>, private val options: SchemaParserOptions) : ResolverInfo() {
+internal interface DataClassTypeResolverInfo {
+    val dataClassType: Class<*>
+}
+
+internal class NormalResolverInfo(val resolver: GraphQLResolver<*>, private val options: SchemaParserOptions) : DataClassTypeResolverInfo, ResolverInfo() {
     val resolverType = getRealResolverClass(resolver, options)
-    val dataClassType = findDataClass()
+    override val dataClassType = findDataClass()
 
     private fun findDataClass(): Class<*> {
         // Grab the parent interface with type GraphQLResolver from our resolver and get its first type argument.
@@ -42,8 +46,8 @@ internal class NormalResolverInfo(val resolver: GraphQLResolver<*>, private val
     }
 }
 
-internal class MultiResolverInfo(val resolverInfoList: List<NormalResolverInfo>) : ResolverInfo() {
-    private val dataClassType = findDataClass()
+internal class MultiResolverInfo(val resolverInfoList: List<NormalResolverInfo>) : DataClassTypeResolverInfo, ResolverInfo() {
+    override val dataClassType = findDataClass()
 
     /**
      * Checks if all `ResolverInfo` instances are related to the same data type

src/test/groovy/com/coxautodev/graphql/tools/ParameterizedGetterSpec.groovy

@@ -0,0 +1,70 @@
+package com.coxautodev.graphql.tools
+
+import graphql.GraphQL
+import graphql.execution.AsyncExecutionStrategy
+import graphql.schema.GraphQLSchema
+import spock.lang.Shared
+import spock.lang.Specification
+
+class ParameterizedGetterSpec extends Specification {
+
+    @Shared
+    GraphQL gql
+
+    def setupSpec() {
+        GraphQLSchema schema = SchemaParser.newParser().schemaString('''\
+                        type Query {
+                            human: Human
+                        }
+                        
+                        type Human {
+                            bestFriends: [Character!]!
+                            allFriends(limit: Int!): [Character!]!
+                        }
+                        
+                        type Character {
+                            name: String!
+                        }
+                    '''.stripIndent())
+                .resolvers(new QueryResolver(), new HumanResolver())
+                .build()
+                .makeExecutableSchema()
+        gql = GraphQL.newGraphQL(schema)
+                .queryExecutionStrategy(new AsyncExecutionStrategy())
+                .build()
+    }
+
+    def "parameterized query is resolved on data type instead of on its resolver"() {
+        when:
+            def data = Utils.assertNoGraphQlErrors(gql, [limit: 10]) {
+                '''
+                query allFriends($limit: Int!) {
+                    human {
+                        allFriends(limit: $limit) {
+                            name
+                        }
+                    }
+                }
+                '''
+            }
+
+        then:
+            data.human
+    }
+
+    class QueryResolver implements GraphQLQueryResolver {
+        Human human() { new Human() }
+    }
+
+    class Human {
+        List<Character> allFriends(int limit) { Collections.emptyList() }
+    }
+
+    class HumanResolver implements GraphQLResolver<Human> {
+        List<Character> bestFriends(Human human) { Collections.emptyList() }
+    }
+
+    class Character {
+        String name
+    }
+}