Remove intermediate interface, and instead allow consumer to pass in data fetcher directly.

Author: timward60

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

@@ -5,6 +5,7 @@ import graphql.kickstart.tools.proxy.*
 import graphql.kickstart.tools.relay.RelayConnectionFactory
 import graphql.kickstart.tools.util.JavaType
 import graphql.kickstart.tools.util.ParameterizedTypeImpl
+import graphql.schema.DataFetcher
 import graphql.schema.DataFetchingEnvironment
 import graphql.schema.visibility.GraphqlFieldVisibility
 import kotlinx.coroutines.Dispatchers
@@ -21,7 +22,7 @@ import kotlin.reflect.KClass
 data class SchemaParserOptions internal constructor(
     val contextClass: Class<*>?,
     val genericWrappers: List<GenericWrapper>,
-    val missingFieldResolverHandler: MissingFieldResolverHandler?,
+    val missingResolverDataFetcher: DataFetcher<Any?>?,
     val allowUnimplementedResolvers: Boolean,
     val objectMapperProvider: PerFieldObjectMapperProvider,
     val proxyHandlers: List<ProxyHandler>,
@@ -48,7 +49,7 @@ data class SchemaParserOptions internal constructor(
         private var contextClass: Class<*>? = null
         private val genericWrappers: MutableList<GenericWrapper> = mutableListOf()
         private var useDefaultGenericWrappers = true
-        private var missingFieldResolverHandler: MissingFieldResolverHandler? = null
+        private var missingResolverDataFetcher: DataFetcher<Any?>? = null
         private var allowUnimplementedResolvers = false
         private var objectMapperProvider: PerFieldObjectMapperProvider = PerFieldConfiguringObjectMapperProvider()
         private val proxyHandlers: MutableList<ProxyHandler> = mutableListOf(Spring4AopProxyHandler(), GuiceAopProxyHandler(), JavassistProxyHandler(), WeldProxyHandler())
@@ -79,8 +80,8 @@ data class SchemaParserOptions internal constructor(
             this.useDefaultGenericWrappers = useDefaultGenericWrappers
         }
 
-        fun missingFieldResolverHandler(missingFieldResolverHandler: MissingFieldResolverHandler?) = this.apply {
-            this.missingFieldResolverHandler = missingFieldResolverHandler
+        fun missingResolverDataFetcher(missingResolverDataFetcher: DataFetcher<Any?>?) = this.apply {
+            this.missingResolverDataFetcher = missingResolverDataFetcher
         }
 
         fun allowUnimplementedResolvers(allowUnimplementedResolvers: Boolean) = this.apply {
@@ -160,7 +161,7 @@ data class SchemaParserOptions internal constructor(
             return SchemaParserOptions(
                 contextClass,
                 wrappers,
-                missingFieldResolverHandler,
+                missingResolverDataFetcher,
                 allowUnimplementedResolvers,
                 objectMapperProvider,
                 proxyHandlers,

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

@@ -64,7 +64,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) {
     }
 
     private fun missingFieldResolver(field: FieldDefinition, searches: List<Search>, scanProperties: Boolean): FieldResolver {
-        return if (options.allowUnimplementedResolvers || options.missingFieldResolverHandler != null) {
+        return if (options.allowUnimplementedResolvers || options.missingResolverDataFetcher != null) {
             if (options.allowUnimplementedResolvers) {
                 log.warn("Missing resolver for field: $field")
             }

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

@@ -1,6 +1,5 @@
 package graphql.kickstart.tools.resolver
 
-import graphql.kickstart.tools.MissingFieldResolverHandler
 import graphql.kickstart.tools.MissingResolverInfo
 import graphql.kickstart.tools.SchemaParserOptions
 import graphql.kickstart.tools.TypeClassMatcher
@@ -15,14 +14,7 @@ internal class MissingFieldResolver(
 
     override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> = listOf()
     override fun createDataFetcher(): DataFetcher<*> {
-        val handler = options.missingFieldResolverHandler ?: return NotImplementedMissingFieldDataFetcher()
-        return MissingFieldDataFetcher(handler)
-    }
-
-    class MissingFieldDataFetcher(private val handler: MissingFieldResolverHandler) : DataFetcher<Any?> {
-        override fun get(env: DataFetchingEnvironment?): Any? {
-            return handler.resolve(env)
-        }
+        return options.missingResolverDataFetcher ?: return NotImplementedMissingFieldDataFetcher()
     }
 
     class NotImplementedMissingFieldDataFetcher : DataFetcher<Any?> {

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

@@ -3,6 +3,7 @@ package graphql.kickstart.tools
 import graphql.ExecutionInput
 import graphql.GraphQL
 import graphql.kickstart.tools.resolver.FieldResolverError
+import graphql.schema.DataFetcher
 import graphql.schema.DataFetchingEnvironment
 import org.junit.Assert
 import org.junit.Test
@@ -28,7 +29,7 @@ class MissingFieldResolverTest {
     }
 
     @Test
-    fun `should call missing field resolver handler if provided`() {
+    fun `should call missing resolver data fetcher if provided`() {
         val schema = SchemaParser.newParser()
             .schemaString("""
                     type Query {
@@ -41,7 +42,7 @@ class MissingFieldResolverTest {
                 fun implementedField(input: Optional<String>) = input.toString()
             })
             .options(SchemaParserOptions.newOptions()
-                .missingFieldResolverHandler(TestMissingFieldResolverHandler())
+                .missingResolverDataFetcher(TestMissingResolverDataFetcher())
                 .build())
             .build()
             .makeExecutableSchema()
@@ -67,9 +68,9 @@ class MissingFieldResolverTest {
         Assert.assertEquals(expected, result.getData())
     }
 
-    class TestMissingFieldResolverHandler : MissingFieldResolverHandler {
-        override fun resolve(env: DataFetchingEnvironment?): Any? {
-            return env?.getArgument("input");
+    class TestMissingResolverDataFetcher : DataFetcher<Any?> {
+        override fun get(env: DataFetchingEnvironment?): Any? {
+            return env?.getArgument("input")
         }
     }
 }