Read CoroutineScope from GraphQLContext, deprecate context object

- Look up CoroutineScope by its class key in GraphQLContext before falling back
- Log a deprecation warning when the legacy context object supplies the scope
- Deprecate the legacy directive getters on SchemaDirectiveWiringEnvironmentImpl
- Suppress DEPRECATION warnings at the remaining legacy call sites
- Add tests for scopes from GraphQLContext and from the legacy context
- Add @ConsistentCopyVisibility to SchemaParserOptions
- Remove UtilsTest, which had no test methods

Author: oryan-block

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

@@ -20,6 +20,7 @@ import java.util.concurrent.Future
 import kotlin.coroutines.CoroutineContext
 import kotlin.reflect.KClass
 
+@ConsistentCopyVisibility
 data class SchemaParserOptions internal constructor(
     val contextClass: Class<*>?,
     val genericWrappers: List<GenericWrapper>,

src/main/kotlin/graphql/kickstart/tools/directive/DirectiveWiringHelper.kt

@@ -96,6 +96,8 @@ internal class DirectiveWiringHelper(
         return checkNotNull(wrapper.invoker(wiring, env)) { "The SchemaDirectiveWiring MUST return a non null return value for element '${wrapper.graphQlType.name}'" }
     }
 
+    // the legacy directives still back the deprecated getters of SchemaDirectiveWiringEnvironment
+    @Suppress("DEPRECATION")
     private fun <T : GraphQLDirectiveContainer> buildEnvironment(wrapper: WiringWrapper<T>, element: T, appliedDirective: GraphQLAppliedDirective? = null): SchemaDirectiveWiringEnvironmentImpl<T> {
         val type = wrapper.graphQlType
         val directive = appliedDirective?.let { d -> type.directives.find { it.name == d.name } }

src/main/kotlin/graphql/kickstart/tools/directive/SchemaDirectiveWiringEnvironmentImpl.kt

@@ -38,9 +38,12 @@ class SchemaDirectiveWiringEnvironmentImpl<T : GraphQLDirectiveContainer?>(
     }
 
     override fun getElement(): T = element
+    @Deprecated("Use getAppliedDirective() instead", ReplaceWith("appliedDirective"))
     override fun getDirective(): GraphQLDirective? = registeredDirective
     override fun getAppliedDirective(): GraphQLAppliedDirective? = registeredAppliedDirective
+    @Deprecated("Use getAppliedDirectives() instead", ReplaceWith("appliedDirectives"))
     override fun getDirectives(): Map<String, GraphQLDirective> = LinkedHashMap(directives)
+    @Deprecated("Use getAppliedDirective(directiveName) instead", ReplaceWith("getAppliedDirective(directiveName)"))
     override fun getDirective(directiveName: String): GraphQLDirective = directives[directiveName]!!
     override fun getAppliedDirectives(): Map<String, GraphQLAppliedDirective> = appliedDirectives
     override fun getAppliedDirective(directiveName: String): GraphQLAppliedDirective = appliedDirectives[directiveName]!!

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

@@ -73,6 +73,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) {
     }
 
     private fun missingFieldResolver(field: FieldDefinition, searches: List<Search>, scanProperties: Boolean): FieldResolver {
+        @Suppress("DEPRECATION")
         return if (options.allowUnimplementedResolvers
             || options.missingResolverDataFetcher != null
             || options.missingResolverDataFetcherProvider != null) {

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

@@ -119,6 +119,7 @@ internal class MethodFieldResolver(
                                 "please insert it into the GraphQLContext map when building the ExecutionInput. " +
                                 "This warning will become an error in the future."
                         )
+                        @Suppress("DEPRECATION")
                         environment.getContext() // TODO: remove deprecated use in next major release
                     }
                 }

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

@@ -11,6 +11,7 @@ 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") }

src/main/kotlin/graphql/kickstart/tools/util/Utils.kt

@@ -7,6 +7,8 @@ import graphql.schema.DataFetchingEnvironment
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import org.apache.commons.lang3.reflect.TypeUtils
+import org.slf4j.LoggerFactory
+import java.lang.invoke.MethodHandles
 import java.lang.reflect.Method
 import java.lang.reflect.ParameterizedType
 import java.lang.reflect.Proxy
@@ -18,6 +20,8 @@ import kotlin.reflect.jvm.kotlinFunction
  * @author Andrew Potter
  */
 
+private val log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass())
+
 internal typealias GraphQLRootResolver = GraphQLResolver<Void>
 
 internal typealias JavaType = java.lang.reflect.Type
@@ -60,8 +64,23 @@ internal fun JavaType.futureValueType(): JavaType? =
     typeArgument(CompletionStage::class.java) ?: typeArgument(Future::class.java)
 
 internal fun DataFetchingEnvironment.coroutineScope(): CoroutineScope {
+    val scope: Any? = graphQlContext[CoroutineScope::class.java]
+    if (scope is CoroutineScope) {
+        return scope
+    }
+
+    @Suppress("DEPRECATION")
     val context: Any? = this.getContext()
-    return if (context is CoroutineScope) context else CoroutineScope(Dispatchers.Default)
+    if (context is CoroutineScope) {
+        log.warn(
+            "Passing a CoroutineScope as the context object has been deprecated by graphql-java. " +
+                "Please insert it into the GraphQLContext map under the CoroutineScope class key when building the ExecutionInput. " +
+                "Support for the context object will be removed in the next major release."
+        )
+        return context
+    }
+
+    return CoroutineScope(Dispatchers.Default)
 }
 
 internal val Class<*>.declaredNonProxyMethods: List<JavaMethod>

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

@@ -629,6 +629,7 @@ class DirectiveTest {
         private fun recordMessage(environment: SchemaDirectiveWiringEnvironment<*>) {
             val name = environment.element.name
             appliedMessages[name] = environment.appliedDirective.getArgument("message")?.getValue<String>()
+            @Suppress("DEPRECATION")
             legacyMessages[name] = environment.directive.getArgument("message")?.let { GraphQLArgument.getArgumentValue<String>(it) }
         }
     }

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

@@ -13,6 +13,7 @@ import graphql.language.TypeName
 import graphql.schema.DataFetcher
 import graphql.schema.DataFetchingEnvironment
 import graphql.schema.DataFetchingEnvironmentImpl
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.Job
@@ -85,6 +86,43 @@ class MethodFieldResolverDataFetcherTest {
         }
     }
 
+    @Test
+    fun `data fetcher executes suspend function in CoroutineScope from GraphQLContext`() {
+        // setup
+        val scopeClass = ScopeClass()
+        val context = GraphQLContext.of(mapOf(CoroutineScope::class.java to scopeClass.scope))
+
+        val resolver = createFetcher("active", scopeClass)
+
+        // expect
+        @Suppress("UNCHECKED_CAST")
+        val future = resolver.get(createEnvironment(DataClass(), context = context)) as CompletableFuture<Boolean>
+        assert(future.get())
+    }
+
+    @Test
+    fun `data fetcher executes suspend function in CoroutineScope from legacy context`() {
+        // setup
+        val scopeClass = ScopeClass()
+
+        val resolver = createFetcher("active", scopeClass)
+
+        // expect
+        @Suppress("UNCHECKED_CAST")
+        val future = resolver.get(createEnvironment(DataClass(), legacyContext = scopeClass.scope)) as CompletableFuture<Boolean>
+        assert(future.get())
+    }
+
+    class ScopeClass : GraphQLResolver<DataClass> {
+        private val job = Job()
+        val scope = CoroutineScope(job)
+
+        @Suppress("UNUSED_PARAMETER")
+        suspend fun isActive(data: DataClass): Boolean {
+            return coroutineContext[Job] == job.children.first()
+        }
+    }
+
     @ExperimentalCoroutinesApi
     @Test
     fun `canceling subscription Publisher also cancels underlying Kotlin coroutine channel`() {
@@ -375,11 +413,16 @@ class MethodFieldResolverDataFetcherTest {
     private fun createEnvironment(
         source: Any = Object(),
         arguments: Map<String, Any> = emptyMap(),
-        context: GraphQLContext = GraphQLContext.newContext().build()
+        context: GraphQLContext = GraphQLContext.newContext().build(),
+        legacyContext: Any? = null
     ) = DataFetchingEnvironmentImpl.newDataFetchingEnvironment(buildExecutionContext(context))
         .source(source)
         .arguments(arguments)
         .graphQLContext(context)
+        .apply {
+            @Suppress("DEPRECATION")
+            if (legacyContext != null) context(legacyContext)
+        }
         .build()
 
     private fun buildExecutionContext(context: GraphQLContext): ExecutionContext {

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

@@ -32,6 +32,7 @@ class MissingFieldResolverTest {
     }
 
     @Test
+    @Suppress("DEPRECATION")
     fun `should call missing resolver data fetcher if provided`() {
         val schema = SchemaParser.newParser()
             .schemaString(