Add support for custom missing field resolver handler.

Author: timward60

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

@@ -0,0 +1,7 @@
+package graphql.kickstart.tools
+
+import graphql.schema.DataFetchingEnvironment
+
+interface MissingFieldHandler {
+    fun resolve(env: DataFetchingEnvironment?): Any?
+}

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

@@ -19,17 +19,18 @@ import kotlin.coroutines.CoroutineContext
 import kotlin.reflect.KClass
 
 data class SchemaParserOptions internal constructor(
-    val contextClass: Class<*>?,
-    val genericWrappers: List<GenericWrapper>,
-    val allowUnimplementedResolvers: Boolean,
-    val objectMapperProvider: PerFieldObjectMapperProvider,
-    val proxyHandlers: List<ProxyHandler>,
-    val inputArgumentOptionalDetectOmission: Boolean,
-    val preferGraphQLResolver: Boolean,
-    val introspectionEnabled: Boolean,
-    val coroutineContextProvider: CoroutineContextProvider,
-    val typeDefinitionFactories: List<TypeDefinitionFactory>,
-    val fieldVisibility: GraphqlFieldVisibility?
+        val contextClass: Class<*>?,
+        val genericWrappers: List<GenericWrapper>,
+        val missingFieldHandler: MissingFieldHandler?,
+        val allowUnimplementedResolvers: Boolean,
+        val objectMapperProvider: PerFieldObjectMapperProvider,
+        val proxyHandlers: List<ProxyHandler>,
+        val inputArgumentOptionalDetectOmission: Boolean,
+        val preferGraphQLResolver: Boolean,
+        val introspectionEnabled: Boolean,
+        val coroutineContextProvider: CoroutineContextProvider,
+        val typeDefinitionFactories: List<TypeDefinitionFactory>,
+        val fieldVisibility: GraphqlFieldVisibility?
 ) {
     companion object {
         @JvmStatic
@@ -47,6 +48,7 @@ data class SchemaParserOptions internal constructor(
         private var contextClass: Class<*>? = null
         private val genericWrappers: MutableList<GenericWrapper> = mutableListOf()
         private var useDefaultGenericWrappers = true
+        private var missingFieldHandler: MissingFieldHandler? = null
         private var allowUnimplementedResolvers = false
         private var objectMapperProvider: PerFieldObjectMapperProvider = PerFieldConfiguringObjectMapperProvider()
         private val proxyHandlers: MutableList<ProxyHandler> = mutableListOf(Spring4AopProxyHandler(), GuiceAopProxyHandler(), JavassistProxyHandler(), WeldProxyHandler())
@@ -77,6 +79,10 @@ data class SchemaParserOptions internal constructor(
             this.useDefaultGenericWrappers = useDefaultGenericWrappers
         }
 
+        fun missingFieldHandler(missingFieldHandler: MissingFieldHandler?) = this.apply {
+            this.missingFieldHandler = missingFieldHandler
+        }
+
         fun allowUnimplementedResolvers(allowUnimplementedResolvers: Boolean) = this.apply {
             this.allowUnimplementedResolvers = allowUnimplementedResolvers
         }
@@ -154,6 +160,7 @@ data class SchemaParserOptions internal constructor(
             return SchemaParserOptions(
                 contextClass,
                 wrappers,
+                missingFieldHandler,
                 allowUnimplementedResolvers,
                 objectMapperProvider,
                 proxyHandlers,

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

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

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

@@ -1,17 +1,32 @@
 package graphql.kickstart.tools.resolver
 
+import graphql.kickstart.tools.*
 import graphql.kickstart.tools.MissingResolverInfo
-import graphql.kickstart.tools.SchemaParserOptions
 import graphql.kickstart.tools.TypeClassMatcher
 import graphql.language.FieldDefinition
 import graphql.schema.DataFetcher
+import graphql.schema.DataFetchingEnvironment
 
 internal class MissingFieldResolver(
-    field: FieldDefinition,
-    options: SchemaParserOptions
+        field: FieldDefinition,
+        options: SchemaParserOptions
 ) : FieldResolver(field, FieldResolverScanner.Search(Any::class.java, MissingResolverInfo(), null), options, Any::class.java) {
 
     override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> = listOf()
+    override fun createDataFetcher(): DataFetcher<*> {
+        val handler = options.missingFieldHandler ?: return NotImplementedMissingFieldDataFetcher()
+        return MissingFieldDataFetcher(handler)
+    }
 
-    override fun createDataFetcher(): DataFetcher<*> = DataFetcher<Any> { TODO("Schema resolver not implemented") }
+    class MissingFieldDataFetcher(private val handler: MissingFieldHandler): DataFetcher<Any?> {
+        override fun get(p0: DataFetchingEnvironment?): Any? {
+            return handler.resolve(p0)
+        }
+    }
+
+    class NotImplementedMissingFieldDataFetcher: DataFetcher<Any?> {
+        override fun get(p0: DataFetchingEnvironment?): Any? {
+            TODO("Schema resolver not implemented")
+        }
+    }
 }