Merge pull request #904 from graphql-java-kickstart/feature/304-sourceless-resolvers

Allow resolver methods that leave out the source object

Author: oryan-block

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

@@ -4,7 +4,6 @@ import graphql.kickstart.tools.resolver.FieldResolverScanner
 import graphql.kickstart.tools.util.GraphQLRootResolver
 import graphql.kickstart.tools.util.JavaType
 import graphql.kickstart.tools.util.eraseUnboundedWildcards
-import graphql.kickstart.tools.util.unwrap
 import org.apache.commons.lang3.reflect.TypeUtils
 import java.lang.reflect.ParameterizedType
 
@@ -17,17 +16,13 @@ internal abstract class ResolverInfo {
             ?: resolver.javaClass
 }
 
-internal interface DataClassTypeResolverInfo {
-    val dataClassType: Class<out Any>
-}
-
 internal class NormalResolverInfo(
     val resolver: GraphQLResolver<*>,
     options: SchemaParserOptions
-) : DataClassTypeResolverInfo, ResolverInfo() {
+) : ResolverInfo() {
 
     val resolverType = getRealResolverClass(resolver, options)
-    override val dataClassType = findDataClass()
+    val dataClassType = findDataClass()
 
     private fun findDataClass(): Class<out Any> {
         val type = TypeUtils.getTypeArguments(resolverType, GraphQLResolver::class.java)[GraphQLResolver::class.java.typeParameters[0]]
@@ -63,9 +58,7 @@ internal class NormalResolverInfo(
 internal class MultiResolverInfo(
     val resolverInfoList: List<NormalResolverInfo>,
     private val dataClass: JavaType
-) : DataClassTypeResolverInfo, ResolverInfo() {
-
-    override val dataClassType = dataClass.unwrap()
+) : ResolverInfo() {
 
     override fun getFieldSearches(): List<FieldResolverScanner.Search> {
         return resolverInfoList

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

@@ -548,7 +548,7 @@ internal class SchemaClassScanner(
 
         fieldResolver.field.inputValueDefinitions.forEachIndexed { index, argument ->
             val parameter = fieldResolver.getMethodParameterType(index)?.let(fieldResolver.typeResolver::getRawClass) ?: return@forEachIndexed
-            if (!isContextParameter(parameter, argument)) {
+            if (!fieldResolverScanner.isContextParameter(parameter, argument)) {
                 return@forEachIndexed
             }
 
@@ -561,11 +561,6 @@ internal class SchemaClassScanner(
         }
     }
 
-    // the context class can also be an argument's type (e.g. a Map for an input object), so only spec scalars count for it
-    private fun isContextParameter(parameter: Class<*>, argument: InputValueDefinition): Boolean =
-        parameter in fieldResolverScanner.allowedTrailingParameterTypes &&
-            (parameter != options.contextClass || argument.type.unwrap().name in ScalarInfo.GRAPHQL_SPECIFICATION_SCALARS_DEFINITIONS)
-
     private fun handleFoundType(match: TypeClassMatcher.Match) = when (match) {
         is TypeClassMatcher.ScalarMatch -> handleFoundScalarType(match.type)
         is TypeClassMatcher.ValidMatch -> handleFoundType(match.type, match.javaType, match.reference)

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

@@ -7,7 +7,9 @@ import graphql.kickstart.tools.RootResolverInfo
 import graphql.kickstart.tools.SchemaParserOptions
 import graphql.kickstart.tools.util.*
 import graphql.language.FieldDefinition
+import graphql.language.InputValueDefinition
 import graphql.schema.DataFetchingEnvironment
+import graphql.schema.idl.ScalarInfo
 import kotlinx.coroutines.channels.ReceiveChannel
 import org.apache.commons.lang3.ClassUtils
 import org.apache.commons.lang3.reflect.FieldUtils
@@ -25,7 +27,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions, private va
 
     private val log = LoggerFactory.getLogger(javaClass)
 
-    val allowedTrailingParameterTypes = listOfNotNull(DataFetchingEnvironment::class.java, GraphQLContext::class.java, options.contextClass)
+    private val allowedTrailingParameterTypes = listOfNotNull(DataFetchingEnvironment::class.java, GraphQLContext::class.java, options.contextClass)
 
     private val methodsByNameCache = mutableMapOf<Pair<Class<out Any>, Boolean>, Map<String, List<Method>>>()
 
@@ -39,7 +41,10 @@ internal class FieldResolverScanner(val options: SchemaParserOptions, private va
             throw FieldResolverError("Found more than one matching resolver for field '$field': $found")
         }
 
-        return found.firstOrNull() ?: missingFieldResolver(field, searches, scanProperties)
+        return found.firstOrNull()
+            ?: missingFieldResolver(field)
+            ?: findSourcelessFieldResolver(field, searches)
+            ?: throw FieldResolverError(getMissingFieldMessage(field, searches, scanProperties))
     }
 
     private fun findFieldResolver(field: FieldDefinition, search: Search, scanProperties: Boolean): FieldResolver? {
@@ -71,7 +76,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions, private va
         }
     }
 
-    private fun missingFieldResolver(field: FieldDefinition, searches: List<Search>, scanProperties: Boolean): FieldResolver {
+    private fun missingFieldResolver(field: FieldDefinition): FieldResolver? {
         @Suppress("DEPRECATION")
         return if (options.allowUnimplementedResolvers
             || options.missingResolverDataFetcher != null
@@ -82,13 +87,44 @@ internal class FieldResolverScanner(val options: SchemaParserOptions, private va
 
             MissingFieldResolver(field, options)
         } else {
-            throw FieldResolverError(getMissingFieldMessage(field, searches, scanProperties))
+            null
         }
     }
 
+    private fun findSourcelessFieldResolver(field: FieldDefinition, searches: List<Search>): FieldResolver? =
+        searches.firstNotNullOfOrNull { search ->
+            val sourceType = search.requiredFirstParameterType ?: return@firstNotNullOfOrNull null
+            val sourceless = search.withoutSourceParameter()
+            findMethodByName(field, sourceless) { isSourcelessMethod(it, field, sourceless, sourceType) }?.let { method ->
+                MethodFieldResolver(field, sourceless, options, method.apply(trySetAccessible(field, search.type)), scalarNames)
+            }
+        }
+
+    private fun isSourcelessMethod(method: Method, field: FieldDefinition, search: Search, sourceType: Class<*>): Boolean {
+        val arguments = field.inputValueDefinitions
+        val parameterTypes = method.parameterTypes
+
+        return method.parameterCountWithoutContinuation() > arguments.size &&
+            arguments.indices.none { isContextParameter(parameterTypes[it], arguments[it]) } &&
+            (arguments.isEmpty() || !couldTakeSource(parameterTypes[0], sourceType)) &&
+            verifyMethodArguments(method, arguments.size, search)
+    }
+
+    private fun couldTakeSource(parameterType: Class<*>, sourceType: Class<*>) =
+        sourceType.isAssignableFrom(parameterType) || parameterType.isAssignableFrom(sourceType)
+
+    // the context class can also be an argument's type (e.g. a Map for an input object), so only spec scalars count for it
+    fun isContextParameter(parameter: Class<*>, argument: InputValueDefinition): Boolean =
+        parameter in allowedTrailingParameterTypes &&
+            (parameter != options.contextClass || argument.type.unwrap().name in ScalarInfo.GRAPHQL_SPECIFICATION_SCALARS_DEFINITIONS)
+
     private fun findResolverMethod(field: FieldDefinition, search: Search): Method? {
+        val argumentCount = field.inputValueDefinitions.size + search.firstArgumentIndex
+        return findMethodByName(field, search) { verifyMethodArguments(it, argumentCount, search) }
+    }
+
+    private inline fun findMethodByName(field: FieldDefinition, search: Search, matches: (Method) -> Boolean): Method? {
         val methodsByName = getMethodsByName(search)
-        val argumentCount = field.inputValueDefinitions.size + if (search.requiredFirstParameterType != null) 1 else 0
         val name = field.name
         val capitalizedName = name.replaceFirstChar(Char::titlecase)
 
@@ -105,7 +141,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions, private va
             "getField$capitalizedName",
             "get${name.snakeToCamelCase()}"
         ).firstNotNullOfOrNull { methodName ->
-            methodsByName[methodName]?.find { verifyMethodArguments(it, argumentCount, search) }
+            methodsByName[methodName]?.find { matches(it) }
         }
     }
 
@@ -197,6 +233,9 @@ internal class FieldResolverScanner(val options: SchemaParserOptions, private va
             signatures.addAll(getMissingMethodSignatures(field, search, isBoolean, scannedProperties))
             isSubscription = isSubscription || search.isSubscription
         }
+        searches.filter { it.requiredFirstParameterType != null }.forEach { search ->
+            signatures.addAll(getMissingMethodSignatures(field, search.withoutSourceParameter(), isBoolean, false, "<environment or context>"))
+        }
 
         val sourceName = field.sourceLocation?.sourceName ?: "<unknown>"
         val sourceLocation = field.sourceLocation?.let { "$sourceName:${it.line}" } ?: "<unknown>"
@@ -206,7 +245,13 @@ internal class FieldResolverScanner(val options: SchemaParserOptions, private va
             if (isSubscription) "\n\nNote that a Subscription data fetcher must return a Publisher of events" else ""
     }
 
-    private fun getMissingMethodSignatures(field: FieldDefinition, search: Search, isBoolean: Boolean, scannedProperties: Boolean): List<String> {
+    private fun getMissingMethodSignatures(
+        field: FieldDefinition,
+        search: Search,
+        isBoolean: Boolean,
+        scannedProperties: Boolean,
+        trailingParameter: String? = null
+    ): List<String> {
         val baseType = search.type.unwrap()
         val signatures = mutableListOf<String>()
         val args = mutableListOf<String>()
@@ -217,6 +262,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions, private va
         }
 
         args.addAll(field.inputValueDefinitions.map { "~${it.name}" })
+        trailingParameter?.let(args::add)
 
         val argString = args.joinToString(sep)
 
@@ -239,6 +285,10 @@ internal class FieldResolverScanner(val options: SchemaParserOptions, private va
         val requiredFirstParameterType: Class<*>? = null
     ) {
         val isSubscription get() = resolverInfo is RootResolverInfo && resolverInfo.isSubscription
+
+        val firstArgumentIndex get() = if (requiredFirstParameterType != null) 1 else 0
+
+        fun withoutSourceParameter() = copy(requiredFirstParameterType = null)
     }
 }
 

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

@@ -52,7 +52,6 @@ internal class MethodFieldResolver(
         val args = mutableListOf<ArgumentPlaceholder>()
         val mapper = objectMapper
 
-        // Add source argument if this is a resolver (but not a root resolver)
         if (this.search.requiredFirstParameterType != null) {
             val expectedType = this.search.requiredFirstParameterType
 
@@ -103,7 +102,7 @@ internal class MethodFieldResolver(
         }
 
         // Add DataFetchingEnvironment/Context arguments, stopping before the Continuation parameter of a suspend function
-        val firstTrailingParameter = field.inputValueDefinitions.size + getIndexOffset()
+        val firstTrailingParameter = field.inputValueDefinitions.size + search.firstArgumentIndex
         method.parameterTypes.slice(firstTrailingParameter until numberOfParameters).forEach { parameterType ->
             when (parameterType) {
                 options.contextClass -> args.add { environment ->
@@ -188,15 +187,7 @@ internal class MethodFieldResolver(
     private fun getResolvedReturnType(): JavaType =
         typeResolver.resolve(if (search.isSubscription) returnType.asPublisher() else returnType)
 
-    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 getJavaMethodParameterIndex(index: Int) = index + search.firstArgumentIndex
 
     internal fun getMethodParameterType(index: Int): JavaType? {
         val methodIndex = getJavaMethodParameterIndex(index)

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

@@ -364,6 +364,27 @@ class MethodFieldResolverTest {
         fun thumbnail(image: Image, env: DataFetchingEnvironment?) = env.toString()
     }
 
+    @Test
+    fun `should pass the source to a resolver method declared by the data class itself`() {
+        val schema = SchemaParser.newParser()
+            .schemaString("type Query { badge: Badge! } type Badge { size(scale: Int!): Int! }")
+            .resolvers(BadgeQuery(), Badge("resolver"))
+            .build()
+            .makeExecutableSchema()
+
+        val data = assertNoGraphQlErrors(GraphQL.newGraphQL(schema).build()) { "{ badge { size(scale: 3) } }" }
+
+        assertEquals(data, mapOf("badge" to mapOf("size" to 15)))
+    }
+
+    class BadgeQuery : GraphQLQueryResolver {
+        fun badge() = Badge("badge")
+    }
+
+    class Badge(val label: String) : GraphQLResolver<Badge> {
+        fun size(badge: Badge, scale: Int) = badge.label.length * scale
+    }
+
     sealed class Maybe<out T> {
         data class Some<T>(val value: T) : Maybe<T>()
         object None : Maybe<Nothing>()