Fixed some deprecation warnings

oliemansm · oliemansm · commit dc95d2e15851 · 2019-06-18T13:09:01.000+02:00
diff --git a/src/main/kotlin/com/coxautodev/graphql/tools/SchemaClassScanner.kt b/src/main/kotlin/com/coxautodev/graphql/tools/SchemaClassScanner.kt
@@ -8,8 +8,6 @@ import graphql.language.FieldDefinition
 import graphql.language.InputObjectTypeDefinition
 import graphql.language.InputValueDefinition
 import graphql.language.InterfaceTypeDefinition
-import graphql.language.ListType
-import graphql.language.NonNullType
 import graphql.language.ObjectTypeDefinition
 import graphql.language.ObjectTypeExtensionDefinition
 import graphql.language.ScalarTypeDefinition
@@ -154,17 +152,22 @@ internal class SchemaClassScanner(initialDictionary: BiMap<String, Class<*>>, al
         }.map { definition ->
             val provided = scalars[definition.name]
                     ?: throw SchemaClassScannerError("Expected a user-defined GraphQL scalar type with name '${definition.name}' but found none!")
-            GraphQLScalarType(provided.name,
-                    if (definition.description != null) definition.description.content else SchemaParser.getDocumentation(definition)
-                    ?: provided.description, provided.coercing, listOf(), definition)
+            GraphQLScalarType.newScalar()
+                    .name(provided.name)
+                    .description(
+                            if (definition.description != null) definition.description.content
+                            else SchemaParser.getDocumentation(definition) ?: provided.description)
+                    .coercing(provided.coercing)
+                    .definition(definition)
+                    .build()
         }.associateBy { it.name!! }
 
         val unusedDefinitions = (definitionsByName.values - observedDefinitions).toSet()
         unusedDefinitions
                 .filter { definition -> definition.name != "PageInfo" }
                 .forEach { definition ->
-            log.warn("Schema type was defined but can never be accessed, and can be safely deleted: ${definition.name}")
-        }
+                    log.warn("Schema type was defined but can never be accessed, and can be safely deleted: ${definition.name}")
+                }
 
         val fieldResolvers = fieldResolversByType.flatMap { it.value.map { it.value } }
         val observedNormalResolverInfos = fieldResolvers.map { it.resolverInfo }.distinct().filterIsInstance<NormalResolverInfo>()
@@ -242,26 +245,27 @@ internal class SchemaClassScanner(initialDictionary: BiMap<String, Class<*>>, al
             } else {
                 resolverInfosByDataClass[item.clazz] ?: DataClassResolverInfo(item.clazz)
             }
-        }) ?: throw throw SchemaClassScannerError("The GraphQL schema type '${item.type.name}' maps to a field of type java.lang.Object however there is no matching entry for this type in the type dictionary. You may need to add this type to the dictionary before building the schema.")
+        })
+                ?: throw throw SchemaClassScannerError("The GraphQL schema type '${item.type.name}' maps to a field of type java.lang.Object however there is no matching entry for this type in the type dictionary. You may need to add this type to the dictionary before building the schema.")
 
         scanResolverInfoForPotentialMatches(item.type, resolverInfo)
     }
 
     private fun scanResolverInfoForPotentialMatches(type: ObjectTypeDefinition, resolverInfo: ResolverInfo) {
         type.getExtendedFieldDefinitions(extensionDefinitions).forEach { field ->
-//            val searchField = applyDirective(field)
+            //            val searchField = applyDirective(field)
             val fieldResolver = fieldResolverScanner.findFieldResolver(field, resolverInfo)
 
             fieldResolversByType.getOrPut(type) { mutableMapOf() }[fieldResolver.field] = fieldResolver
 
             fieldResolver.scanForMatches().forEach { potentialMatch ->
-//                if (potentialMatch.graphQLType is TypeName && !definitionsByName.containsKey((potentialMatch.graphQLType.name))) {
+                //                if (potentialMatch.graphQLType is TypeName && !definitionsByName.containsKey((potentialMatch.graphQLType.name))) {
 //                    val typeDefinition = ObjectTypeDefinition.newObjectTypeDefinition()
 //                            .name(potentialMatch.graphQLType.name)
 //                            .build()
 //                    handleFoundType(TypeClassMatcher.ValidMatch(typeDefinition, typeClassMatcher.toRealType(potentialMatch), potentialMatch.reference))
 //                } else {
-                    handleFoundType(typeClassMatcher.match(potentialMatch))
+                handleFoundType(typeClassMatcher.match(potentialMatch))
 //                }
             }
         }
diff --git a/src/main/kotlin/com/coxautodev/graphql/tools/SchemaObjects.kt b/src/main/kotlin/com/coxautodev/graphql/tools/SchemaObjects.kt
@@ -1,5 +1,6 @@
 package com.coxautodev.graphql.tools
 
+import graphql.schema.GraphQLCodeRegistry
 import graphql.schema.GraphQLObjectType
 import graphql.schema.GraphQLSchema
 import graphql.schema.GraphQLType
@@ -21,7 +22,11 @@ data class SchemaObjects(val query: GraphQLObjectType, val mutation: GraphQLObje
                 .additionalTypes(dictionary)
 
         if (!introspectionEnabled) {
-            builder.fieldVisibility(NoIntrospectionGraphqlFieldVisibility.NO_INTROSPECTION_FIELD_VISIBILITY)
+            builder.codeRegistry(
+                    GraphQLCodeRegistry.newCodeRegistry()
+                            .fieldVisibility(NoIntrospectionGraphqlFieldVisibility.NO_INTROSPECTION_FIELD_VISIBILITY)
+                            .build()
+            )
         }
 
         return builder.build()
diff --git a/src/main/kotlin/com/coxautodev/graphql/tools/SchemaParserBuilder.kt b/src/main/kotlin/com/coxautodev/graphql/tools/SchemaParserBuilder.kt
@@ -290,6 +290,7 @@ data class SchemaParserOptions internal constructor(
         fun newOptions() = Builder()
 
         @JvmStatic
+        @ExperimentalCoroutinesApi
         fun defaultOptions() = Builder().build()
     }
 
diff --git a/src/main/kotlin/graphql/schema/idl/DirectiveBehavior.kt b/src/main/kotlin/graphql/schema/idl/DirectiveBehavior.kt
@@ -19,6 +19,7 @@ class DirectiveBehavior {
         return directiveHelper.onObject(element, params.toParameters())
     }
 
+    @Suppress("UNUSED_PARAMETER")
     fun onField(element: GraphQLFieldDefinition, params: Params): GraphQLFieldDefinition {
         // noop, since the actual behaviour has moved to onObject/onInterface since graphql-java 12.0
         return element
@@ -36,11 +37,13 @@ class DirectiveBehavior {
     fun onEnum(element: GraphQLEnumType, params: Params): GraphQLEnumType =
             directiveHelper.onEnum(element, params.toParameters())
 
+    @Suppress("UNUSED_PARAMETER")
     fun onEnumValue(element: GraphQLEnumValueDefinition, params: Params): GraphQLEnumValueDefinition {
         // noop, since the actual behaviour has moved to onEnum since graphql-java 12.0
         return element
     }
 
+    @Suppress("UNUSED_PARAMETER")
     fun onArgument(element: GraphQLArgument, params: Params): GraphQLArgument {
         // noop, since the actual behaviour has moved to onObject/onInterface since graphql-java 12.0
         return element
@@ -49,6 +52,7 @@ class DirectiveBehavior {
     fun onInputObject(element: GraphQLInputObjectType, params: Params): GraphQLInputObjectType =
             directiveHelper.onInputObjectType(element, params.toParameters())
 
+    @Suppress("UNUSED_PARAMETER")
     fun onInputObjectField(element: GraphQLInputObjectField, params: Params): GraphQLInputObjectField {
         // noop, since the actual behaviour has moved to onInputObjectType since graphql-java 12.0
         return element
diff --git a/src/test/kotlin/com/coxautodev/graphql/tools/EndToEndSpecHelper.kt b/src/test/kotlin/com/coxautodev/graphql/tools/EndToEndSpecHelper.kt
@@ -7,24 +7,24 @@ import graphql.language.StringValue
 import graphql.schema.Coercing
 import graphql.schema.DataFetchingEnvironment
 import graphql.schema.GraphQLScalarType
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.ReceiveChannel
+import kotlinx.coroutines.coroutineScope
 import org.reactivestreams.Publisher
-import java.util.Optional
-import java.util.UUID
+import java.util.*
 import java.util.concurrent.CompletableFuture
 
 fun createSchema() = SchemaParser.newParser()
-    .schemaString(schemaDefinition)
-    .resolvers(Query(), Mutation(), Subscription(), ItemResolver(), UnusedRootResolver(), UnusedResolver())
-    .scalars(customScalarUUID, customScalarMap, customScalarId)
-    .dictionary("OtherItem", OtherItemWithWrongName::class)
-    .dictionary("ThirdItem", ThirdItem::class)
-    .dictionary("ComplexMapItem", ComplexMapItem::class)
-    .dictionary("NestedComplexMapItem", NestedComplexMapItem::class)
-    .build()
-    .makeExecutableSchema()
+        .schemaString(schemaDefinition)
+        .resolvers(Query(), Mutation(), Subscription(), ItemResolver(), UnusedRootResolver(), UnusedResolver())
+        .scalars(customScalarUUID, customScalarMap, customScalarId)
+        .dictionary("OtherItem", OtherItemWithWrongName::class)
+        .dictionary("ThirdItem", ThirdItem::class)
+        .dictionary("ComplexMapItem", ComplexMapItem::class)
+        .dictionary("NestedComplexMapItem", NestedComplexMapItem::class)
+        .build()
+        .makeExecutableSchema()
 
 val schemaDefinition = """
 
@@ -210,13 +210,13 @@ type ItemWithGenericProperties {
 
 
 val items = mutableListOf(
-    Item(0, "item1", Type.TYPE_1, UUID.fromString("38f685f1-b460-4a54-a17f-7fd69e8cf3f8"), listOf(Tag(1, "item1-tag1"), Tag(2, "item1-tag2"))),
-    Item(1, "item2", Type.TYPE_2, UUID.fromString("38f685f1-b460-4a54-b17f-7fd69e8cf3f8"), listOf(Tag(3, "item2-tag1"), Tag(4, "item2-tag2")))
+        Item(0, "item1", Type.TYPE_1, UUID.fromString("38f685f1-b460-4a54-a17f-7fd69e8cf3f8"), listOf(Tag(1, "item1-tag1"), Tag(2, "item1-tag2"))),
+        Item(1, "item2", Type.TYPE_2, UUID.fromString("38f685f1-b460-4a54-b17f-7fd69e8cf3f8"), listOf(Tag(3, "item2-tag1"), Tag(4, "item2-tag2")))
 )
 
 val otherItems = mutableListOf(
-    OtherItemWithWrongName(0, "otherItem1", Type.TYPE_1, UUID.fromString("38f685f1-b460-4a54-c17f-7fd69e8cf3f8")),
-    OtherItemWithWrongName(1, "otherItem2", Type.TYPE_2, UUID.fromString("38f685f1-b460-4a54-d17f-7fd69e8cf3f8"))
+        OtherItemWithWrongName(0, "otherItem1", Type.TYPE_1, UUID.fromString("38f685f1-b460-4a54-c17f-7fd69e8cf3f8")),
+        OtherItemWithWrongName(1, "otherItem2", Type.TYPE_2, UUID.fromString("38f685f1-b460-4a54-d17f-7fd69e8cf3f8"))
 )
 
 val thirdItems = mutableListOf(
@@ -244,7 +244,7 @@ val propertyMapWithNestedComplexItems = mutableListOf(
         hashMapOf("nested" to NestedComplexMapItem(UndiscoveredItem(63)), "age" to 72)
 )
 
-class Query: GraphQLQueryResolver, ListListResolver<String>() {
+class Query : GraphQLQueryResolver, ListListResolver<String>() {
     fun isEmpty() = items.isEmpty()
     fun allBaseItems() = items
     fun items(input: ItemSearchInput): List<Item> = items.filter { it.name == input.name }
@@ -257,8 +257,9 @@ class Query: GraphQLQueryResolver, ListListResolver<String>() {
     fun itemByBuiltInId(id: UUID): Item? {
         return items.find { it.uuid == id }
     }
-    fun itemsWithOptionalInput(input: ItemSearchInput?) = if(input == null) items else items(input)
-    fun itemsWithOptionalInputExplicit(input: Optional<ItemSearchInput>) = if(input.isPresent) items(input.get()) else items
+
+    fun itemsWithOptionalInput(input: ItemSearchInput?) = if (input == null) items else items(input)
+    fun itemsWithOptionalInputExplicit(input: Optional<ItemSearchInput>) = if (input.isPresent) items(input.get()) else items
     fun enumInputType(type: Type) = type
     fun customScalarMapInputType(customScalarMap: Map<String, Any>) = customScalarMap
     fun itemWithGenericProperties() = ItemWithGenericProperties(listOf("A", "B"))
@@ -269,7 +270,9 @@ class Query: GraphQLQueryResolver, ListListResolver<String>() {
     fun futureItems() = CompletableFuture.completedFuture(items)
     fun complexNullableType(): ComplexNullable? = null
 
-    fun complexInputType(input: List<List<ComplexInputType>?>?) = input?.firstOrNull()?.firstOrNull()?.let { it.first == "foo" && it.second?.firstOrNull()?.firstOrNull()?.first == "bar" } ?: false
+    fun complexInputType(input: List<List<ComplexInputType>?>?) = input?.firstOrNull()?.firstOrNull()?.let { it.first == "foo" && it.second?.firstOrNull()?.firstOrNull()?.first == "bar" }
+            ?: false
+
     fun extendedType() = ExtendedType()
 
     fun getItemsWithGetResolver() = items
@@ -286,16 +289,16 @@ class Query: GraphQLQueryResolver, ListListResolver<String>() {
     private val propertyField = "test"
 
     fun dataFetcherResult(): DataFetcherResult<Item> {
-        return DataFetcherResult(items.first(), listOf())
+        return DataFetcherResult.newResult<Item>().data(items.first()).build()
     }
 
     suspend fun coroutineItems(): List<Item> = CompletableDeferred(items).await()
 
     fun arrayItems() = items.toTypedArray()
 }
 
-class UnusedRootResolver: GraphQLQueryResolver
-class UnusedResolver: GraphQLResolver<String>
+class UnusedRootResolver : GraphQLQueryResolver
+class UnusedResolver : GraphQLResolver<String>
 
 class ExtendedType {
     fun first() = "test"
@@ -306,7 +309,7 @@ abstract class ListListResolver<out E> {
     fun listList(): List<List<E>> = listOf(listOf())
 }
 
-class Mutation: GraphQLMutationResolver {
+class Mutation : GraphQLMutationResolver {
     fun addItem(input: NewItemInput): Item {
         return Item(items.size, input.name, input.type, UUID.randomUUID(), listOf()) // Don't actually add the item to the list, since we want the test to be deterministic
     }
@@ -316,10 +319,10 @@ class OnItemCreatedContext(val newItem: Item)
 
 class Subscription : GraphQLSubscriptionResolver {
     fun onItemCreated(env: DataFetchingEnvironment) =
-        Publisher<Item> { subscriber ->
-            subscriber.onNext(env.getContext<OnItemCreatedContext>().newItem)
+            Publisher<Item> { subscriber ->
+                subscriber.onNext(env.getContext<OnItemCreatedContext>().newItem)
 //            subscriber.onComplete()
-        }
+            }
 
     fun onItemCreatedCoroutineChannel(env: DataFetchingEnvironment): ReceiveChannel<Item> {
         val channel = Channel<Item>(1)
@@ -343,7 +346,11 @@ class ItemResolver : GraphQLResolver<Item> {
     fun batchedName(items: List<Item>) = items.map { it.name }
 
     @Batched
-    fun batchedWithParamsTags(items: List<Item>, names: List<String>?): List<List<Tag>> = items.map{ it.tags.filter { names?.contains(it.name) ?: true } }
+    fun batchedWithParamsTags(items: List<Item>, names: List<String>?): List<List<Tag>> = items.map {
+        it.tags.filter {
+            names?.contains(it.name) ?: true
+        }
+    }
 }
 
 interface ItemInterface {
@@ -353,8 +360,8 @@ interface ItemInterface {
 }
 
 enum class Type { TYPE_1, TYPE_2 }
-data class Item(val id: Int, override val name: String, override val type: Type, override val uuid:UUID, val tags: List<Tag>) : ItemInterface
-data class OtherItemWithWrongName(val id: Int, override val name: String, override val type: Type, override val uuid:UUID) : ItemInterface
+data class Item(val id: Int, override val name: String, override val type: Type, override val uuid: UUID, val tags: List<Tag>) : ItemInterface
+data class OtherItemWithWrongName(val id: Int, override val name: String, override val type: Type, override val uuid: UUID) : ItemInterface
 data class ThirdItem(val id: Int)
 data class ComplexMapItem(val id: Int)
 data class UndiscoveredItem(val id: Int)
@@ -367,44 +374,56 @@ data class ComplexInputType(val first: String, val second: List<List<ComplexInpu
 data class ComplexInputTypeTwo(val first: String)
 data class ItemWithGenericProperties(val keys: List<String>)
 
-val customScalarId = GraphQLScalarType("ID", "Overrides built-in ID", object : Coercing<UUID, String> {
-    override fun serialize(input: Any): 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) {
-        is StringValue -> UUID.fromString(input.value)
-        else -> null
-    }
-})
-
-val customScalarUUID = GraphQLScalarType("UUID", "UUID", object : Coercing<UUID, String> {
-
-    override fun serialize(input: Any): 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) {
-        is StringValue -> UUID.fromString(input.value)
-        else -> null
-    }
-})
-
-val customScalarMap = GraphQLScalarType("customScalarMap", "customScalarMap", object: Coercing<Map<String, Any>, Map<String, Any>> {
-
-    @Suppress("UNCHECKED_CAST")
-    override fun parseValue(input: Any?): 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 }
-})
+val customScalarId = GraphQLScalarType.newScalar()
+        .name("ID")
+        .description("Overrides built-in ID")
+        .coercing(object : Coercing<UUID, String> {
+            override fun serialize(input: Any): 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) {
+                is StringValue -> UUID.fromString(input.value)
+                else -> null
+            }
+        })
+        .build()
+
+val customScalarUUID = GraphQLScalarType.newScalar()
+        .name("UUID")
+        .description("UUID")
+        .coercing(object : Coercing<UUID, String> {
+
+            override fun serialize(input: Any): 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) {
+                is StringValue -> UUID.fromString(input.value)
+                else -> null
+            }
+        })
+        .build()
+
+val customScalarMap = GraphQLScalarType.newScalar()
+        .name("customScalarMap")
+        .description("customScalarMap")
+        .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>
+
+            @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 }
+        })
+        .build()
diff --git a/src/test/kotlin/com/coxautodev/graphql/tools/MethodFieldResolverDataFetcherTest.kt b/src/test/kotlin/com/coxautodev/graphql/tools/MethodFieldResolverDataFetcherTest.kt

Original file line number	Diff line number	Diff line change
`@@ -290,6 +290,7 @@ data class SchemaParserOptions internal constructor(`
`290`	`290`	`fun newOptions() = Builder()`
`291`	`291`
`292`	`292`	`@JvmStatic`
	`293`	`+ @ExperimentalCoroutinesApi`
`293`	`294`	`fun defaultOptions() = Builder().build()`
`294`	`295`	`}`
`295`	`296`