Merge pull request #455 from timward60/timward/custom-handler-resolver-new

Add support for customized missing field resolver handling

Author: vojtapol

src/main/kotlin/graphql/kickstart/tools/SchemaParserOptions.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
@@ -22,6 +23,7 @@ data class SchemaParserOptions internal constructor(
     val contextClass: Class<*>?,
     val genericWrappers: List<GenericWrapper>,
     val allowUnimplementedResolvers: Boolean,
+    val missingResolverDataFetcher: DataFetcher<Any?>?,
     val objectMapperProvider: PerFieldObjectMapperProvider,
     val proxyHandlers: List<ProxyHandler>,
     val inputArgumentOptionalDetectOmission: Boolean,
@@ -49,6 +51,7 @@ data class SchemaParserOptions internal constructor(
         private val genericWrappers: MutableList<GenericWrapper> = mutableListOf()
         private var useDefaultGenericWrappers = true
         private var allowUnimplementedResolvers = false
+        private var missingResolverDataFetcher: DataFetcher<Any?>? = null
         private var objectMapperProvider: PerFieldObjectMapperProvider = PerFieldConfiguringObjectMapperProvider()
         private val proxyHandlers: MutableList<ProxyHandler> = mutableListOf(Spring4AopProxyHandler(), GuiceAopProxyHandler(), JavassistProxyHandler(), WeldProxyHandler())
         private var inputArgumentOptionalDetectOmission = false
@@ -83,6 +86,10 @@ data class SchemaParserOptions internal constructor(
             this.allowUnimplementedResolvers = allowUnimplementedResolvers
         }
 
+        fun missingResolverDataFetcher(missingResolverDataFetcher: DataFetcher<Any?>?) = this.apply {
+            this.missingResolverDataFetcher = missingResolverDataFetcher
+        }
+
         fun inputArgumentOptionalDetectOmission(inputArgumentOptionalDetectOmission: Boolean) = this.apply {
             this.inputArgumentOptionalDetectOmission = inputArgumentOptionalDetectOmission
         }
@@ -161,6 +168,7 @@ data class SchemaParserOptions internal constructor(
                 contextClass,
                 wrappers,
                 allowUnimplementedResolvers,
+                missingResolverDataFetcher,
                 objectMapperProvider,
                 proxyHandlers,
                 inputArgumentOptionalDetectOmission,

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

@@ -61,8 +61,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.missingResolverDataFetcher != null) {
+            if (options.allowUnimplementedResolvers) {
+                log.warn("Missing resolver for field: $field")
+            }
 
             MissingFieldResolver(field, options)
         } else {

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

@@ -12,6 +12,6 @@ internal class MissingFieldResolver(
 ) : FieldResolver(field, FieldResolverScanner.Search(Any::class.java, MissingResolverInfo(), null), options, Any::class.java) {
 
     override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> = listOf()
-
-    override fun createDataFetcher(): DataFetcher<*> = DataFetcher<Any> { TODO("Schema resolver not implemented") }
+    override fun createDataFetcher(): DataFetcher<*> =
+        options.missingResolverDataFetcher ?: DataFetcher<Any> { TODO("Schema resolver not implemented") }
 }

src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt

@@ -0,0 +1,73 @@
+package graphql.kickstart.tools
+
+import graphql.GraphQL
+import graphql.kickstart.tools.resolver.FieldResolverError
+import graphql.schema.DataFetcher
+import graphql.schema.DataFetchingEnvironment
+import org.junit.Test
+import java.util.*
+
+class MissingFieldResolverTest {
+
+    @Test(expected = FieldResolverError::class)
+    fun `should throw error when a field is missing`() {
+        SchemaParser.newParser()
+            .schemaString(
+                """
+                type Query {
+                    implementedField(input: String): String
+                    missingField(input: Int): Int
+                }
+                """
+            )
+            .resolvers(object : GraphQLQueryResolver {
+                fun implementedField(input: Optional<String>) = input.toString()
+            })
+            .build()
+            .makeExecutableSchema()
+    }
+
+    @Test
+    fun `should call missing resolver data fetcher if provided`() {
+        val schema = SchemaParser.newParser()
+            .schemaString(
+                """
+                type Query {
+                    implementedField(input: String): String
+                    missingField(input: Int): Int
+                }
+                """
+            )
+            .resolvers(object : GraphQLQueryResolver {
+                fun implementedField(input: Optional<String>) = input.toString()
+            })
+            .options(SchemaParserOptions.newOptions()
+                .missingResolverDataFetcher(TestMissingResolverDataFetcher())
+                .build())
+            .build()
+            .makeExecutableSchema()
+
+        val gql = GraphQL.newGraphQL(schema).build()
+
+        val result = gql.execute(
+            """
+            query {
+                implementedField(input: "test-value")
+                missingField(input: 1)
+            }
+            """)
+
+        val expected = mapOf(
+            "implementedField" to "Optional[test-value]",
+            "missingField" to 1
+        )
+
+        assertEquals(result.getData(), expected)
+    }
+
+    class TestMissingResolverDataFetcher : DataFetcher<Any?> {
+        override fun get(env: DataFetchingEnvironment?): Any? {
+            return env?.getArgument("input")
+        }
+    }
+}