Merge pull request #165 from guy120494/get-wrapped-dataFetcher

Expose Wrapped dataFetcher (fix #164)

Author: oliemansm

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

@@ -17,12 +17,12 @@ import java.util.*
 /**
  * @author Andrew Potter
  */
-internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolverScanner.Search, options: SchemaParserOptions, val method: Method): FieldResolver(field, search, options, method.declaringClass) {
+internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolverScanner.Search, options: SchemaParserOptions, val method: Method) : FieldResolver(field, search, options, method.declaringClass) {
 
     companion object {
         fun isBatched(method: Method, search: FieldResolverScanner.Search): Boolean {
-            if(method.getAnnotation(Batched::class.java) != null) {
-                if(!search.allowBatched) {
+            if (method.getAnnotation(Batched::class.java) != null) {
+                if (!search.allowBatched) {
                     throw ResolverError("The @Batched annotation is only allowed on non-root resolver methods, but it was found on ${search.type.name}#${method.name}!")
                 }
 
@@ -41,8 +41,8 @@ internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolver
         val mapper = options.objectMapperProvider.provide(field)
 
         // Add source argument if this is a resolver (but not a root resolver)
-        if(this.search.requiredFirstParameterType != null) {
-            val expectedType = if(batched) Iterable::class.java else this.search.requiredFirstParameterType
+        if (this.search.requiredFirstParameterType != null) {
+            val expectedType = if (batched) Iterable::class.java else this.search.requiredFirstParameterType
 
             args.add { environment ->
                 val source = environment.getSource<Any>()
@@ -57,23 +57,24 @@ internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolver
         // Add an argument for each argument defined in the GraphQL schema
         this.field.inputValueDefinitions.forEachIndexed { index, definition ->
 
-            val genericParameterType = this.getJavaMethodParameterType(index) ?: throw ResolverError("Missing method type at position ${this.getJavaMethodParameterIndex(index)}, this is most likely a bug with graphql-java-tools")
+            val genericParameterType = this.getJavaMethodParameterType(index)
+                    ?: throw ResolverError("Missing method type at position ${this.getJavaMethodParameterIndex(index)}, this is most likely a bug with graphql-java-tools")
 
             val isNonNull = definition.type is NonNullType
             val isOptional = this.genericType.getRawClass(genericParameterType) == Optional::class.java
 
-            val typeReference = object: TypeReference<Any>() {
+            val typeReference = object : TypeReference<Any>() {
                 override fun getType() = genericParameterType
             }
 
             args.add { environment ->
-                val value = environment.arguments[definition.name] ?: if(isNonNull) {
+                val value = environment.arguments[definition.name] ?: if (isNonNull) {
                     throw ResolverError("Missing required argument with name '${definition.name}', this is most likely a bug with graphql-java-tools")
                 } else {
                     null
                 }
 
-                if(value == null && isOptional) {
+                if (value == null && isOptional) {
                     return@add Optional.empty<Any>()
                 }
 
@@ -82,16 +83,16 @@ internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolver
         }
 
         // Add DataFetchingEnvironment/Context argument
-        if(this.additionalLastArgument) {
+        if (this.additionalLastArgument) {
             val lastArgumentType = this.method.parameterTypes.last()
-            when(lastArgumentType) {
+            when (lastArgumentType) {
                 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 -> environment.getContext() }
                 else -> args.add { environment -> environment }
             }
         }
 
-        return if(batched) {
+        return if (batched) {
             BatchedMethodFieldResolverDataFetcher(getSourceResolver(), this.method, args, options)
         } else {
             MethodFieldResolverDataFetcher(getSourceResolver(), this.method, args, options)
@@ -107,14 +108,14 @@ internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolver
         } + listOf(returnValueMatch)
     }
 
-    private fun getIndexOffset() = if(resolverInfo is NormalResolverInfo) 1 else 0
+    private fun getIndexOffset() = if (resolverInfo is NormalResolverInfo) 1 else 0
     private fun getJavaMethodParameterIndex(index: Int) = index + getIndexOffset()
 
     private fun getJavaMethodParameterType(index: Int): JavaType? {
         val methodIndex = getJavaMethodParameterIndex(index)
         val parameters = method.parameterTypes
 
-        return if(parameters.size > methodIndex) {
+        return if (parameters.size > methodIndex) {
             method.genericParameterTypes[getJavaMethodParameterIndex(index)]
         } else {
             null
@@ -124,14 +125,14 @@ internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolver
     override fun toString() = "MethodFieldResolver{method=$method}"
 }
 
-open class MethodFieldResolverDataFetcher(private val sourceResolver: SourceResolver, method: Method, private val args: List<ArgumentPlaceholder>, private val options: SchemaParserOptions): DataFetcher<Any> {
+open class MethodFieldResolverDataFetcher(private val sourceResolver: SourceResolver, method: Method, private val args: List<ArgumentPlaceholder>, private val options: SchemaParserOptions) : DataFetcher<Any> {
 
     // Convert to reflactasm reflection
     private val methodAccess = MethodAccess.get(method.declaringClass)!!
     private val methodIndex = methodAccess.getIndex(method.name, *method.parameterTypes)
 
     private class CompareGenericWrappers {
-        companion object: Comparator<GenericWrapper> {
+        companion object : Comparator<GenericWrapper> {
             override fun compare(w1: GenericWrapper, w2: GenericWrapper): Int = when {
                 w1.type.isAssignableFrom(w2.type) -> 1
                 else -> -1
@@ -147,21 +148,31 @@ open class MethodFieldResolverDataFetcher(private val sourceResolver: SourceReso
             result
         } else {
             val wrapper = options
-                .genericWrappers
-                .filter { it.type.isInstance(result) }
-                .sortedWith(CompareGenericWrappers)
-                .firstOrNull()
+                    .genericWrappers
+                    .filter { it.type.isInstance(result) }
+                    .sortedWith(CompareGenericWrappers)
+                    .firstOrNull()
             if (wrapper == null) {
                 result
             } else {
                 wrapper.transformer.invoke(result, environment)
             }
         }
     }
+
+    /**
+     * Function that return the object used to fetch the data
+     * It can be a DataFetcher or an entity
+     */
+    @Suppress("unused")
+    open fun getWrappedFetchingObject(environment: DataFetchingEnvironment): Any {
+        return sourceResolver(environment)
+    }
 }
 
-class BatchedMethodFieldResolverDataFetcher(sourceResolver: SourceResolver, method: Method, args: List<ArgumentPlaceholder>, options: SchemaParserOptions): MethodFieldResolverDataFetcher(sourceResolver, method, args, options) {
-    @Batched override fun get(environment: DataFetchingEnvironment) = super.get(environment)
+class BatchedMethodFieldResolverDataFetcher(sourceResolver: SourceResolver, method: Method, args: List<ArgumentPlaceholder>, options: SchemaParserOptions) : MethodFieldResolverDataFetcher(sourceResolver, method, args, options) {
+    @Batched
+    override fun get(environment: DataFetchingEnvironment) = super.get(environment)
 }
 
 internal typealias ArgumentPlaceholder = (DataFetchingEnvironment) -> Any?