Merge branch 'master' into environment-coroutine-scope

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,8 @@ 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
 import java.util.Comparator
@@ -115,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
             }
@@ -220,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

@@ -9,6 +9,7 @@ import graphql.language.Type
 import graphql.schema.DataFetchingEnvironment
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.GlobalScope
+import java.lang.reflect.Method
 import java.lang.reflect.ParameterizedType
 
 /**
@@ -37,7 +38,26 @@ internal fun JavaType.unwrap(): Class<out Any> =
             this as Class<*>
         }
 
+
 internal fun DataFetchingEnvironment.coroutineScope(): CoroutineScope {
     val context: Any? = this.getContext()
     return if (context is CoroutineScope) context else GlobalScope
 }
+
+/**
+ * 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")))
+    }
+}