Merge branch 'master' into hotfix-java-proxy

Author: oliemansm

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

@@ -3,6 +3,7 @@ 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 graphql.TrivialDataFetcher
 import graphql.execution.batched.Batched
 import graphql.language.FieldDefinition
 import graphql.language.ListType
@@ -11,7 +12,7 @@ import graphql.language.Type
 import graphql.language.TypeName
 import graphql.schema.DataFetcher
 import graphql.schema.DataFetchingEnvironment
-import graphql.schema.GraphQLTypeUtil.isScalar
+import graphql.schema.GraphQLTypeUtil.*
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.future.future
 import java.lang.reflect.Method
@@ -116,17 +117,24 @@ internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolver
         return if (batched) {
             BatchedMethodFieldResolverDataFetcher(getSourceResolver(), this.method, args, options)
         } else {
-            MethodFieldResolverDataFetcher(getSourceResolver(), this.method, args, options)
+            if (args.isEmpty() && isTrivialDataFetcher(this.method)) {
+                TrivialMethodFieldResolverDataFetcher(getSourceResolver(), this.method, args, options)
+            } else {
+                MethodFieldResolverDataFetcher(getSourceResolver(), this.method, args, options)
+            }
+
         }
     }
 
     private fun isScalarType(environment: DataFetchingEnvironment, type: Type<*>, genericParameterType: JavaType): Boolean =
-            when (type) {
-                is ListType ->
+            when {
+                type is ListType ->
                     List::class.java.isAssignableFrom(this.genericType.getRawClass(genericParameterType))
                         && isScalarType(environment, type.type, this.genericType.unwrapGenericType(genericParameterType))
-                is TypeName ->
+                type is TypeName ->
                     environment.graphQLSchema?.getType(type.name)?.let { isScalar(it) } ?: false
+                type is NonNullType && type.type is TypeName ->
+                    environment.graphQLSchema?.getType((type.type as TypeName).name)?.let { isScalar(unwrapNonNull(it)) } ?: false
                 else ->
                     false
             }
@@ -221,6 +229,10 @@ open class MethodFieldResolverDataFetcher(private val sourceResolver: SourceReso
     }
 }
 
+open class TrivialMethodFieldResolverDataFetcher(private val sourceResolver: SourceResolver, method: Method, private val args: List<ArgumentPlaceholder>, private val options: SchemaParserOptions) : MethodFieldResolverDataFetcher(sourceResolver, method, args, options), TrivialDataFetcher<Any> {
+
+}
+
 private suspend inline fun MethodAccess.invokeSuspend(target: Any, methodIndex: Int, args: Array<Any?>): Any? {
     return suspendCoroutineUninterceptedOrReturn { continuation ->
         invoke(target, methodIndex, *args + continuation)

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

@@ -6,6 +6,7 @@ import graphql.language.NonNullType
 import graphql.language.ObjectTypeDefinition
 import graphql.language.ObjectTypeExtensionDefinition
 import graphql.language.Type
+import java.lang.reflect.Method
 import java.lang.reflect.ParameterizedType
 import java.lang.reflect.Proxy
 
@@ -36,10 +37,30 @@ internal fun JavaType.unwrap(): Class<out Any> =
             this as Class<*>
         }
 
+
 internal val Class<*>.declaredNonProxyMethods: List<JavaMethod>
     get() {
         return when {
             Proxy.isProxyClass(this) -> emptyList()
             else -> this.declaredMethods.toList()
         }
     }
+
+/**
+ * Simple heuristic to check is a method is a trivial data fetcher.
+ *
+ * Requirements are:
+ * prefixed with get
+ * must have zero parameters
+ */
+internal fun isTrivialDataFetcher(method: Method): Boolean {
+    return (method.parameterCount == 0
+            && (
+            method.name.startsWith("get")
+                    || isBooleanGetter(method)))
+}
+
+private fun isBooleanGetter(method: Method) = (method.name.startsWith("is")
+        && (method.returnType == java.lang.Boolean::class.java)
+        || method.returnType == Boolean::class.java)
+

src/test/java/com/coxautodev/graphql/tools/UtilsTestTrivialDataFetcherBean.java

@@ -0,0 +1,8 @@
+package com.coxautodev.graphql.tools;
+
+public class UtilsTestTrivialDataFetcherBean {
+
+    public boolean isBooleanPrimitive() {
+        return false;
+    }
+}

src/test/kotlin/com/coxautodev/graphql/tools/UtilsTest.kt

@@ -0,0 +1,40 @@
+package com.coxautodev.graphql.tools
+
+import org.junit.Assert
+import org.junit.Test
+
+class UtilsTest {
+
+    @Suppress("unused")
+    class Bean {
+        fun getterValid(): String = ""
+
+        fun getterWithArgument(@Suppress("UNUSED_PARAMETER") arg1: String): String = ""
+
+        internal fun getterInternal(): String = ""
+
+        fun notAGetter(): String = ""
+
+        fun isString(): String = ""
+
+        @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
+        fun isJavaBoolean(): java.lang.Boolean = java.lang.Boolean(false)
+
+        fun isKotlinBoolean(): Boolean = false
+    }
+
+    @Test
+    fun `isTrivialDataFetcher`() {
+        val clazz = Bean::class.java
+
+        Assert.assertTrue(isTrivialDataFetcher(clazz.getMethod("getterValid")))
+        Assert.assertFalse(isTrivialDataFetcher(clazz.getMethod("getterWithArgument", String::class.java)))
+        Assert.assertFalse(isTrivialDataFetcher(clazz.getMethod("notAGetter")))
+
+        Assert.assertFalse(isTrivialDataFetcher(clazz.getMethod("isString")))
+        Assert.assertTrue(isTrivialDataFetcher(clazz.getMethod("isJavaBoolean")))
+        Assert.assertTrue(isTrivialDataFetcher(clazz.getMethod("isKotlinBoolean")))
+
+        Assert.assertTrue(isTrivialDataFetcher(UtilsTestTrivialDataFetcherBean::class.java.getMethod("isBooleanPrimitive")))
+    }
+}