Remove the deprecated missingResolverDataFetcher option

Author: oryan-block

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

@@ -6,7 +6,6 @@ import graphql.kickstart.tools.relay.RelayConnectionFactory
 import graphql.kickstart.tools.resolver.MissingResolverDataFetcherProvider
 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
@@ -24,8 +23,6 @@ data class SchemaParserOptions internal constructor(
     val contextClass: Class<*>?,
     val genericWrappers: List<GenericWrapper>,
     val allowUnimplementedResolvers: Boolean,
-    @Deprecated("Use missingResolverDataFetcherProvider instead.")
-    val missingResolverDataFetcher: DataFetcher<Any?>?,
     val missingResolverDataFetcherProvider: MissingResolverDataFetcherProvider?,
     val objectMapperProvider: PerFieldObjectMapperProvider,
     val proxyHandlers: List<ProxyHandler>,
@@ -56,7 +53,6 @@ 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 missingResolverDataFetcherProvider: MissingResolverDataFetcherProvider? = null
         private var objectMapperProvider: PerFieldObjectMapperProvider = PerFieldConfiguringObjectMapperProvider()
         private val proxyHandlers: MutableList<ProxyHandler> = mutableListOf(Spring4AopProxyHandler(), GuiceAopProxyHandler(), JavassistProxyHandler(), WeldProxyHandler())
@@ -95,11 +91,6 @@ data class SchemaParserOptions internal constructor(
             this.allowUnimplementedResolvers = allowUnimplementedResolvers
         }
 
-        @Deprecated("Use missingResolverDataFetcherProvider instead.")
-        fun missingResolverDataFetcher(missingResolverDataFetcher: DataFetcher<Any?>?) = this.apply {
-            this.missingResolverDataFetcher = missingResolverDataFetcher
-        }
-
         fun missingResolverDataFetcherProvider(missingResolverDataFetcherProvider: MissingResolverDataFetcherProvider?) = this.apply {
             this.missingResolverDataFetcherProvider = missingResolverDataFetcherProvider
         }
@@ -211,7 +202,6 @@ data class SchemaParserOptions internal constructor(
                 contextClass,
                 wrappers,
                 allowUnimplementedResolvers,
-                missingResolverDataFetcher,
                 missingResolverDataFetcherProvider,
                 objectMapperProvider,
                 proxyHandlers,

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

@@ -77,10 +77,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions, private va
     }
 
     private fun missingFieldResolver(field: FieldDefinition): FieldResolver? {
-        @Suppress("DEPRECATION")
-        return if (options.allowUnimplementedResolvers
-            || options.missingResolverDataFetcher != null
-            || options.missingResolverDataFetcherProvider != null) {
+        return if (options.allowUnimplementedResolvers || options.missingResolverDataFetcherProvider != null) {
             if (options.allowUnimplementedResolvers) {
                 log.warn("Missing resolver for field: $field")
             }

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

@@ -11,11 +11,8 @@ internal class MissingFieldResolver(
     options: SchemaParserOptions
 ) : FieldResolver(field, FieldResolverScanner.Search(Any::class.java, MissingResolverInfo(), null), options) {
 
-    @Suppress("DEPRECATION")
     private val missingResolverDataFetcherProvider: MissingResolverDataFetcherProvider = options.missingResolverDataFetcherProvider
-            ?: MissingResolverDataFetcherProvider {
-                _, options -> options.missingResolverDataFetcher ?: DataFetcher<Any> { TODO("Schema resolver not implemented") }
-            }
+            ?: MissingResolverDataFetcherProvider { _, _ -> DataFetcher<Any> { TODO("Schema resolver not implemented") } }
     override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> = listOf()
     override fun createDataFetcher(): DataFetcher<*> = missingResolverDataFetcherProvider.createDataFetcher(field, options)
 }

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

@@ -58,46 +58,6 @@ class MissingFieldResolverTest {
         ))
     }
 
-    @Test
-    @Suppress("DEPRECATION")
-    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()
-            .assertEveryFieldResolves()
-
-        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)
-    }
-
     @Test
     fun `should call missing resolver data fetcher provider if provided`() {
         val missingResolverDataFetcherProvider = TestMissingResolverDataFetcherProvider();