Remove deprecations and upgrade to java 11

oryan-block · oryan-block · commit 413d25996895 · 2023-07-25T12:19:31.000-04:00
diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml
@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        java: [ '8', '11', '15' ]
+        java: [ '11', '15', '17' ]
     steps:
       - name: Checkout
         uses: actions/checkout@v3
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -23,7 +23,7 @@ jobs:
       - name: Setup Maven Central
         uses: actions/setup-java@v3
         with:
-          java-version: '8'
+          java-version: '11'
           distribution: 'adopt'
           server-id: ossrh
           server-username: MAVEN_USERNAME
diff --git a/.github/workflows/snapshot.yml b/.github/workflows/snapshot.yml
@@ -12,7 +12,7 @@ jobs:
       - name: Setup java
         uses: actions/setup-java@v3
         with:
-          java-version: '8'
+          java-version: '11'
           distribution: 'adopt'
       - name: Build with Maven
         run: mvn --batch-mode --update-snapshots verify
@@ -26,7 +26,7 @@ jobs:
       - name: Setup Maven Central
         uses: actions/setup-java@v3
         with:
-          java-version: '8'
+          java-version: '11'
           distribution: 'adopt'
           server-id: ossrh
           server-username: MAVEN_USERNAME
diff --git a/pom.xml b/pom.xml
@@ -13,7 +13,7 @@
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <java.version>1.8</java.version>
+        <java.version>11</java.version>
         <kotlin.version>1.8.21</kotlin.version>
         <kotlin-coroutines.version>1.6.4</kotlin-coroutines.version>
         <jackson.version>2.14.2</jackson.version>
@@ -279,8 +279,8 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.11.0</version>
                 <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
+                    <source>11</source>
+                    <target>11</target>
                 </configuration>
             </plugin>
 
diff --git a/src/main/kotlin/graphql/kickstart/tools/GenericType.kt b/src/main/kotlin/graphql/kickstart/tools/GenericType.kt
@@ -83,8 +83,7 @@ internal open class GenericType(protected val mostSpecificType: JavaType, protec
          * Unwrap certain Java types to find the "real" class.
          */
         fun unwrapGenericType(javaType: JavaType): JavaType {
-            val type = replaceTypeVariable(javaType)
-            return when (type) {
+            return when (val type = replaceTypeVariable(javaType)) {
                 is ParameterizedType -> {
                     val rawType = type.rawType
                     val genericType = options.genericWrappers.find { it.type == rawType }
@@ -107,7 +106,7 @@ internal open class GenericType(protected val mostSpecificType: JavaType, protec
                     }
                 }
                 is WildcardType -> type.upperBounds.firstOrNull()
-                    ?: throw error("Unable to unwrap type, wildcard has no upper bound: $type")
+                    ?: error("Unable to unwrap type, wildcard has no upper bound: $type")
                 is Class<*> -> if (type.isPrimitive) Primitives.wrap(type) else type
                 else -> error("Unable to unwrap type: $type")
             }
diff --git a/src/main/kotlin/graphql/kickstart/tools/SchemaClassScanner.kt b/src/main/kotlin/graphql/kickstart/tools/SchemaClassScanner.kt
@@ -174,7 +174,7 @@ internal class SchemaClassScanner(
                     .coercing(provided.coercing)
                     .definition(definition)
                     .build()
-            }.associateBy { it.name!! }
+            }.associateBy { it.name }
 
         val unusedDefinitions = (definitionsByName.values - observedDefinitions).toSet()
         unusedDefinitions
diff --git a/src/main/kotlin/graphql/kickstart/tools/SchemaParserBuilder.kt b/src/main/kotlin/graphql/kickstart/tools/SchemaParserBuilder.kt
@@ -4,6 +4,7 @@ import graphql.language.Definition
 import graphql.language.Document
 import graphql.parser.MultiSourceReader
 import graphql.parser.Parser
+import graphql.parser.ParserEnvironment
 import graphql.parser.ParserOptions
 import graphql.schema.GraphQLScalarType
 import graphql.schema.idl.RuntimeWiring
@@ -175,11 +176,14 @@ class SchemaParserBuilder {
 
             files.forEach {
                 val sourceReader = MultiSourceReader.newMultiSourceReader().string(readFile(it), it).trackData(true).build()
-                documents.add(parser.parseDocument(sourceReader, options))
+                val environment = ParserEnvironment.newParserEnvironment().document(sourceReader).parserOptions(options).build()
+                documents.add(parser.parseDocument(environment))
             }
 
             if (schemaString.isNotEmpty()) {
-                documents.add(parser.parseDocument(schemaString.toString(), options))
+                val sourceReader = MultiSourceReader.newMultiSourceReader().string(schemaString.toString(), null).trackData(true).build()
+                val environment = ParserEnvironment.newParserEnvironment().document(sourceReader).parserOptions(options).build()
+                documents.add(parser.parseDocument(environment))
             }
         } catch (pce: ParseCancellationException) {
             val cause = pce.cause
@@ -206,6 +210,6 @@ class SchemaParserBuilder {
 }
 
 class InvalidSchemaError(pce: ParseCancellationException, private val recognitionException: RecognitionException) : RuntimeException(pce) {
-    override val message: String?
+    override val message: String
         get() = "Invalid schema provided (${recognitionException.javaClass.name}) at: ${recognitionException.offendingToken}"
 }
diff --git a/src/main/kotlin/graphql/kickstart/tools/TypeClassMatcher.kt b/src/main/kotlin/graphql/kickstart/tools/TypeClassMatcher.kt
@@ -68,7 +68,7 @@ internal class TypeClassMatcher(private val definitionsByName: Map<String, TypeD
             is ListType -> {
                 if (realType is ParameterizedType && isListType(realType, potentialMatch)) {
                     match(potentialMatch, graphQLType.type, realType.actualTypeArguments.first())
-                } else if ((realType as Class<*>).isArray) {
+                } else if (realType is Class<*> && realType.isArray) {
                     match(potentialMatch, graphQLType.type, realType.componentType)
                 } else {
                     throw error(potentialMatch, "Java class is not a List or generic type information was lost: $realType")
diff --git a/src/main/kotlin/graphql/kickstart/tools/directive/SchemaDirectiveWiringEnvironmentImpl.kt b/src/main/kotlin/graphql/kickstart/tools/directive/SchemaDirectiveWiringEnvironmentImpl.kt
@@ -56,7 +56,8 @@ class SchemaDirectiveWiringEnvironmentImpl<T : GraphQLDirectiveContainer?>(
     override fun getFieldDataFetcher(): DataFetcher<*> {
         checkNotNull(fieldDefinition) { "An output field must be in context to call this method" }
         checkNotNull(fieldsContainer) { "An output field container must be in context to call this method" }
-        return codeRegistry.getDataFetcher(fieldsContainer, fieldDefinition)
+        val coordinates = FieldCoordinates.coordinates(fieldsContainer, fieldDefinition)
+        return codeRegistry.getDataFetcher(coordinates, fieldDefinition)
     }
 
     override fun setFieldDataFetcher(newDataFetcher: DataFetcher<*>?): GraphQLFieldDefinition {
diff --git a/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/DirectiveTest.kt
@@ -4,10 +4,7 @@ import graphql.GraphQL
 import graphql.execution.AsyncExecutionStrategy
 import graphql.relay.Connection
 import graphql.relay.SimpleListConnection
-import graphql.schema.DataFetcherFactories
-import graphql.schema.DataFetchingEnvironment
-import graphql.schema.GraphQLFieldDefinition
-import graphql.schema.GraphQLObjectType
+import graphql.schema.*
 import graphql.schema.idl.SchemaDirectiveWiring
 import graphql.schema.idl.SchemaDirectiveWiringEnvironment
 import org.junit.Ignore
@@ -325,7 +322,7 @@ class DirectiveTest {
 
         override fun onField(environment: SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition>): GraphQLFieldDefinition {
             val field = environment.element
-            val parentType = environment.fieldsContainer
+            val parentType = FieldCoordinates.coordinates(environment.fieldsContainer, environment.fieldDefinition)
 
             val originalDataFetcher = environment.codeRegistry.getDataFetcher(parentType, field)
             val wrappedDataFetcher = DataFetcherFactories.wrapDataFetcher(originalDataFetcher) { _, value ->
@@ -342,15 +339,15 @@ class DirectiveTest {
 
         override fun onField(environment: SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition>): GraphQLFieldDefinition {
             val field = environment.element
-            val parentType = environment.fieldsContainer
+            val parentType = FieldCoordinates.coordinates(environment.fieldsContainer, environment.fieldDefinition)
 
             val originalDataFetcher = environment.codeRegistry.getDataFetcher(parentType, field)
             val wrappedDataFetcher = DataFetcherFactories.wrapDataFetcher(originalDataFetcher) { _, value ->
                 val string = value as? String
                 string + string
             }
 
-            environment.codeRegistry.dataFetcher(parentType, field, wrappedDataFetcher)
+            environment.codeRegistry.dataFetcher(parentType, wrappedDataFetcher)
 
             return field
         }
diff --git a/src/test/kotlin/graphql/kickstart/tools/EndToEndSpecHelper.kt b/src/test/kotlin/graphql/kickstart/tools/EndToEndSpecHelper.kt
@@ -1,8 +1,11 @@
 package graphql.kickstart.tools
 
+import graphql.GraphQLContext
+import graphql.execution.CoercedVariables
 import graphql.execution.DataFetcherResult
 import graphql.language.ObjectValue
 import graphql.language.StringValue
+import graphql.language.Value
 import graphql.schema.*
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.channels.Channel
@@ -444,18 +447,22 @@ val customScalarId = GraphQLScalarType.newScalar()
     .name("ID")
     .description("Overrides built-in ID")
     .coercing(object : Coercing<UUID, String> {
-        override fun serialize(input: Any): String? = when (input) {
+        override fun serialize(input: Any, context: GraphQLContext, locale: Locale) = when (input) {
             is String -> input
             is UUID -> input.toString()
             else -> null
         }
 
-        override fun parseValue(input: Any): UUID = parseLiteral(input)
-
-        override fun parseLiteral(input: Any): UUID = when (input) {
+        override fun parseValue(input: Any, context: GraphQLContext, locale: Locale) = when (input) {
             is StringValue -> UUID.fromString(input.value)
             else -> throw CoercingParseLiteralException()
         }
+
+        override fun parseLiteral(input: Value<*>, variables: CoercedVariables, context: GraphQLContext, locale: Locale) =
+            when (input) {
+                is StringValue -> UUID.fromString(input.value)
+                else -> throw CoercingParseLiteralException()
+            }
     })
     .build()
 
@@ -464,18 +471,22 @@ val customScalarUUID = GraphQLScalarType.newScalar()
     .description("UUID")
     .coercing(object : Coercing<UUID, String> {
 
-        override fun serialize(input: Any): String? = when (input) {
+        override fun serialize(input: Any, context: GraphQLContext, locale: Locale): String? = when (input) {
             is String -> input
             is UUID -> input.toString()
             else -> null
         }
 
-        override fun parseValue(input: Any): UUID = parseLiteral(input)
-
-        override fun parseLiteral(input: Any): UUID = when (input) {
+        override fun parseValue(input: Any, context: GraphQLContext, locale: Locale): UUID = when (input) {
             is StringValue -> UUID.fromString(input.value)
             else -> throw CoercingParseLiteralException()
         }
+
+        override fun parseLiteral(input: Value<*>, variables: CoercedVariables, context: GraphQLContext, locale: Locale): UUID =
+            when (input) {
+                is StringValue -> UUID.fromString(input.value)
+                else -> throw CoercingParseLiteralException()
+            }
     })
     .build()
 
@@ -485,12 +496,19 @@ val customScalarMap = GraphQLScalarType.newScalar()
     .coercing(object : Coercing<Map<String, Any>, Map<String, Any>> {
 
         @Suppress("UNCHECKED_CAST")
-        override fun parseValue(input: Any): Map<String, Any> = input as Map<String, Any>
+        override fun parseValue(input: Any, context: GraphQLContext, locale: Locale): Map<String, Any> = input as Map<String, Any>
 
         @Suppress("UNCHECKED_CAST")
-        override fun serialize(dataFetcherResult: Any): Map<String, Any> = dataFetcherResult as Map<String, Any>
-
-        override fun parseLiteral(input: Any): Map<String, Any> = (input as ObjectValue).objectFields.associateBy { it.name }.mapValues { (it.value.value as StringValue).value }
+        override fun serialize(dataFetcherResult: Any, context: GraphQLContext, locale: Locale): Map<String, Any> =
+            dataFetcherResult as Map<String, Any>
+
+        override fun parseLiteral(
+            input: Value<*>,
+            variables: CoercedVariables,
+            context: GraphQLContext,
+            locale: Locale
+        ): Map<String, Any> =
+            (input as ObjectValue).objectFields.associateBy { it.name }.mapValues { (it.value.value as StringValue).value }
     })
     .build()
 
@@ -499,11 +517,11 @@ val uploadScalar: GraphQLScalarType = GraphQLScalarType.newScalar()
     .name("Upload")
     .description("A file part in a multipart request")
     .coercing(object : Coercing<Part?, Void?> {
-        override fun serialize(dataFetcherResult: Any): Void? {
+        override fun serialize(dataFetcherResult: Any, context: GraphQLContext, locale: Locale): Void? {
             throw CoercingSerializeException("Upload is an input-only type")
         }
 
-        override fun parseValue(input: Any): Part {
+        override fun parseValue(input: Any, context: GraphQLContext, locale: Locale): Part {
             return when (input) {
                 is Part -> {
                     input
@@ -514,9 +532,8 @@ val uploadScalar: GraphQLScalarType = GraphQLScalarType.newScalar()
             }
         }
 
-        override fun parseLiteral(input: Any): Part {
-            throw CoercingParseLiteralException(
-                "Must use variables to specify Upload values")
+        override fun parseLiteral(input: Value<*>, variables: CoercedVariables, context: GraphQLContext, locale: Locale): Part {
+            throw CoercingParseLiteralException("Must use variables to specify Upload values")
         }
     }).build()
 
diff --git a/src/test/kotlin/graphql/kickstart/tools/FieldResolverScannerTest.kt b/src/test/kotlin/graphql/kickstart/tools/FieldResolverScannerTest.kt
@@ -10,9 +10,11 @@ import graphql.language.TypeName
 import graphql.relay.Connection
 import graphql.relay.DefaultConnection
 import graphql.relay.DefaultPageInfo
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import org.junit.Test
 import java.util.*
 
+@OptIn(ExperimentalCoroutinesApi::class)
 class FieldResolverScannerTest {
 
     private val options = defaultOptions()
diff --git a/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverDataFetcherTest.kt b/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverDataFetcherTest.kt
@@ -3,7 +3,7 @@ package graphql.kickstart.tools
 import graphql.ExecutionResult
 import graphql.GraphQLContext
 import graphql.execution.*
-import graphql.execution.instrumentation.SimpleInstrumentation
+import graphql.execution.instrumentation.SimplePerformantInstrumentation
 import graphql.kickstart.tools.resolver.FieldResolverError
 import graphql.kickstart.tools.resolver.FieldResolverScanner
 import graphql.language.FieldDefinition
@@ -24,6 +24,7 @@ import org.reactivestreams.tck.TestEnvironment
 import java.util.concurrent.CompletableFuture
 import kotlin.coroutines.coroutineContext
 
+@OptIn(ExperimentalCoroutinesApi::class)
 class MethodFieldResolverDataFetcherTest {
 
     @Test
@@ -311,7 +312,7 @@ class MethodFieldResolverDataFetcherTest {
         }
         val executionId = ExecutionId.from("executionId123")
         return ExecutionContextBuilder.newExecutionContextBuilder()
-            .instrumentation(SimpleInstrumentation.INSTANCE)
+            .instrumentation(SimplePerformantInstrumentation.INSTANCE)
             .executionId(executionId)
             .queryStrategy(executionStrategy)
             .mutationStrategy(executionStrategy)
diff --git a/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/MethodFieldResolverTest.kt
@@ -2,17 +2,22 @@ package graphql.kickstart.tools
 
 import graphql.ExecutionInput
 import graphql.GraphQL
+import graphql.GraphQLContext
+import graphql.execution.CoercedVariables
 import graphql.language.StringValue
+import graphql.language.Value
 import graphql.schema.Coercing
 import graphql.schema.CoercingParseLiteralException
 import graphql.schema.CoercingSerializeException
 import graphql.schema.GraphQLScalarType
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import org.junit.Test
 import java.lang.reflect.InvocationHandler
 import java.lang.reflect.Method
 import java.lang.reflect.Proxy
 import java.util.*
 
+@OptIn(ExperimentalCoroutinesApi::class)
 class MethodFieldResolverTest {
 
     @Test
@@ -228,14 +233,14 @@ class MethodFieldResolverTest {
         .description("customScalar")
         .coercing(object : Coercing<CustomScalar, String> {
 
-            override fun parseValue(input: Any) = CustomScalar.of(input)
+            override fun parseValue(input: Any, context: GraphQLContext, locale: Locale) = CustomScalar.of(input)
 
-            override fun parseLiteral(input: Any): CustomScalar = when (input) {
+            override fun parseLiteral(input: Value<*>, variables: CoercedVariables, context: GraphQLContext, locale: Locale): CustomScalar = when (input) {
                 is StringValue -> CustomScalar.of(input.value)
                 else -> throw CoercingParseLiteralException()
             }
 
-            override fun serialize(dataFetcherResult: Any) = when (dataFetcherResult) {
+            override fun serialize(dataFetcherResult: Any, context: GraphQLContext, locale: Locale) = when (dataFetcherResult) {
                 is CustomScalar -> dataFetcherResult.value
                 else -> throw CoercingSerializeException()
             }
diff --git a/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt b/src/test/kotlin/graphql/kickstart/tools/MissingFieldResolverTest.kt
@@ -6,9 +6,11 @@ import graphql.kickstart.tools.resolver.MissingResolverDataFetcherProvider
 import graphql.language.FieldDefinition
 import graphql.schema.DataFetcher
 import graphql.schema.DataFetchingEnvironment
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import org.junit.Test
 import java.util.*
 
+@OptIn(ExperimentalCoroutinesApi::class)
 class MissingFieldResolverTest {
 
     @Test(expected = FieldResolverError::class)
diff --git a/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt b/src/test/kotlin/graphql/kickstart/tools/ReactiveTest.kt
@@ -4,6 +4,7 @@ import graphql.GraphQL
 import graphql.execution.AsyncExecutionStrategy
 import graphql.kickstart.tools.SchemaParser.Companion.newParser
 import graphql.kickstart.tools.SchemaParserOptions.Companion.newOptions
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import org.junit.Test
 import java.util.*
 import java.util.concurrent.CompletableFuture
@@ -12,6 +13,7 @@ import java.util.concurrent.Future
 //import io.reactivex.Single;
 //import io.reactivex.internal.operators.single.SingleJust;
 //import static io.reactivex.Maybe.just;
+@OptIn(ExperimentalCoroutinesApi::class)
 class ReactiveTest {
 
     @Test
diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaClassScannerTest.kt
diff --git a/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt b/src/test/kotlin/graphql/kickstart/tools/SchemaParserTest.kt
diff --git a/src/test/kotlin/graphql/kickstart/tools/TypeClassMatcherTest.kt b/src/test/kotlin/graphql/kickstart/tools/TypeClassMatcherTest.kt

Original file line number	Diff line number	Diff line change
`@@ -83,8 +83,7 @@ internal open class GenericType(protected val mostSpecificType: JavaType, protec`
`83`	`83`	`* Unwrap certain Java types to find the "real" class.`
`84`	`84`	`*/`
`85`	`85`	`fun unwrapGenericType(javaType: JavaType): JavaType {`
`86`		`- val type = replaceTypeVariable(javaType)`
`87`		`- return when (type) {`
	`86`	`+ return when (val type = replaceTypeVariable(javaType)) {`
`88`	`87`	`is ParameterizedType -> {`
`89`	`88`	`val rawType = type.rawType`
`90`	`89`	`val genericType = options.genericWrappers.find { it.type == rawType }`
`@@ -107,7 +106,7 @@ internal open class GenericType(protected val mostSpecificType: JavaType, protec`
`107`	`106`	`}`
`108`	`107`	`}`
`109`	`108`	`is WildcardType -> type.upperBounds.firstOrNull()`
`110`		`- ?: throw error("Unable to unwrap type, wildcard has no upper bound: $type")`
	`109`	`+ ?: error("Unable to unwrap type, wildcard has no upper bound: $type")`
`111`	`110`	`is Class<*> -> if (type.isPrimitive) Primitives.wrap(type) else type`
`112`	`111`	`else -> error("Unable to unwrap type: $type")`
`113`	`112`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,8 @@ class SchemaDirectiveWiringEnvironmentImpl<T : GraphQLDirectiveContainer?>(`
`56`	`56`	`override fun getFieldDataFetcher(): DataFetcher<*> {`
`57`	`57`	`checkNotNull(fieldDefinition) { "An output field must be in context to call this method" }`
`58`	`58`	`checkNotNull(fieldsContainer) { "An output field container must be in context to call this method" }`
`59`		`- return codeRegistry.getDataFetcher(fieldsContainer, fieldDefinition)`
	`59`	`+ val coordinates = FieldCoordinates.coordinates(fieldsContainer, fieldDefinition)`
	`60`	`+ return codeRegistry.getDataFetcher(coordinates, fieldDefinition)`
`60`	`61`	`}`
`61`	`62`
`62`	`63`	`override fun setFieldDataFetcher(newDataFetcher: DataFetcher<*>?): GraphQLFieldDefinition {`