Merge branch 'master' of https://github.com/graphql-java-kickstart/graphql-java-tools

Author: KammererTob

README.md

@@ -2,7 +2,7 @@
 
 [![TravisCI Build](https://travis-ci.org/graphql-java-kickstart/graphql-java-tools.svg?branch=master)](https://travis-ci.org/graphql-java-kickstart/graphql-java-tools)
 [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.graphql-java-kickstart/graphql-java-tools/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.graphql-java-kickstart/graphql-java-tools)
-[![Chat on Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://graphqljavakickstart.slack.com)
+[![Chat on Slack](https://img.shields.io/badge/slack-join%20chat-informational)](https://graphqljavakickstart.slack.com)
 
 This library allows you to use the GraphQL schema language to build your [graphql-java](https://github.com/graphql-java/graphql-java) schema.
 Inspired by [graphql-tools](https://github.com/apollographql/graphql-tools), it parses the given GraphQL schema and allows you to BYOO (bring your own object) to fill in the implementations.
@@ -55,7 +55,7 @@ A few libraries exist to ease the boilerplate pain, including [GraphQL-Java's bu
 <dependency>
     <groupId>com.graphql-java-kickstart</groupId>
     <artifactId>graphql-java-tools</artifactId>
-    <version>6.0.2</version>
+    <version>6.2.0</version>
 </dependency>
 ```
 ```groovy

pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>com.graphql-java-kickstart</groupId>
     <artifactId>graphql-java-tools</artifactId>
-    <version>6.1.1-SNAPSHOT</version>
+    <version>6.2.1-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <name>GraphQL Java Tools</name>
@@ -14,10 +14,10 @@
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <java.version>1.8</java.version>
-        <kotlin.version>1.3.70</kotlin.version>
-        <kotlin-coroutines.version>1.2.1</kotlin-coroutines.version>
+        <kotlin.version>1.3.72</kotlin.version>
+        <kotlin-coroutines.version>1.3.9</kotlin-coroutines.version>
         <jackson.version>2.10.3</jackson.version>
-        <graphql-java.version>14.1</graphql-java.version>
+        <graphql-java.version>15.0</graphql-java.version>
 
         <maven.compiler.source>${java.version}</maven.compiler.source>
         <maven.compiler.target>${java.version}</maven.compiler.target>

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

@@ -19,9 +19,7 @@ internal class SchemaClassScanner(
     private val scalars: CustomScalarMap,
     private val options: SchemaParserOptions
 ) {
-    companion object {
-        val log = LoggerFactory.getLogger(SchemaClassScanner::class.java)!!
-    }
+    private val log = LoggerFactory.getLogger(javaClass)
 
     private val rootInfo = RootTypeInfo.fromSchemaDefinitions(allDefinitions.filterIsInstance<SchemaDefinition>())
 
@@ -147,15 +145,13 @@ internal class SchemaClassScanner(
         val scalars = scalarDefinitions
             .filter {
                 // Filter for any defined scalars OR scalars that aren't defined but also aren't standard
-                scalars.containsKey(it.name) || !ScalarInfo.STANDARD_SCALAR_DEFINITIONS.containsKey(it.name)
+                scalars.containsKey(it.name) || !ScalarInfo.GRAPHQL_SPECIFICATION_SCALARS_DEFINITIONS.containsKey(it.name)
             }.map { definition ->
                 val provided = scalars[definition.name]
                     ?: throw SchemaClassScannerError("Expected a user-defined GraphQL scalar type with name '${definition.name}' but found none!")
                 GraphQLScalarType.newScalar()
                     .name(provided.name)
-                    .description(
-                        if (definition.description != null) definition.description.content
-                        else SchemaParser.getDocumentation(definition) ?: provided.description)
+                    .description(definition.description?.content ?: getDocumentation(definition) ?: provided.description)
                     .coercing(provided.coercing)
                     .definition(definition)
                     .build()
@@ -322,7 +318,7 @@ internal class SchemaClassScanner(
             is InputObjectTypeDefinition -> {
                 graphQLType.inputValueDefinitions.forEach { inputValueDefinition ->
                     val inputGraphQLType = inputValueDefinition.type.unwrap()
-                    if (inputGraphQLType is TypeName && !ScalarInfo.STANDARD_SCALAR_DEFINITIONS.containsKey(inputGraphQLType.name)) {
+                    if (inputGraphQLType is TypeName && !ScalarInfo.GRAPHQL_SPECIFICATION_SCALARS_DEFINITIONS.containsKey(inputGraphQLType.name)) {
                         val inputValueJavaType = findInputValueType(inputValueDefinition.name, inputGraphQLType, javaType.unwrap())
                         if (inputValueJavaType != null) {
                             handleFoundType(typeClassMatcher.match(TypeClassMatcher.PotentialMatch.parameterType(

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

@@ -1,7 +1,9 @@
 package graphql.kickstart.tools
 
+import graphql.Scalars
 import graphql.introspection.Introspection
 import graphql.kickstart.tools.directive.SchemaGeneratorDirectiveHelper
+import graphql.kickstart.tools.util.getDocumentation
 import graphql.kickstart.tools.util.getExtendedFieldDefinitions
 import graphql.kickstart.tools.util.unwrap
 import graphql.language.*
@@ -11,7 +13,6 @@ import graphql.schema.idl.ScalarInfo
 import graphql.schema.idl.SchemaGeneratorHelper
 import graphql.schema.visibility.NoIntrospectionGraphqlFieldVisibility
 import org.slf4j.LoggerFactory
-import java.util.*
 import kotlin.reflect.KClass
 
 /**
@@ -24,17 +25,11 @@ class SchemaParser internal constructor(
     private val options: SchemaParserOptions,
     private val runtimeWiring: RuntimeWiring
 ) {
-    companion object {
-        val log = LoggerFactory.getLogger(SchemaClassScanner::class.java)!!
-        const val DEFAULT_DEPRECATION_MESSAGE = "No longer supported"
+    private val log = LoggerFactory.getLogger(javaClass)
 
+    companion object {
         @JvmStatic
         fun newParser() = SchemaParserBuilder()
-
-        internal fun getDocumentation(node: AbstractNode<*>): String? = node.comments?.asSequence()
-            ?.filter { !it.content.startsWith("#") }
-            ?.joinToString("\n") { it.content.trimEnd() }
-            ?.trimIndent()
     }
 
     private val dictionary = scanResult.dictionary
@@ -129,7 +124,7 @@ class SchemaParser internal constructor(
             .definition(objectDefinition)
             .description(if (objectDefinition.description != null) objectDefinition.description.content else getDocumentation(objectDefinition))
 
-        builder.withDirectives(*buildDirectives(objectDefinition.directives, setOf(), Introspection.DirectiveLocation.OBJECT))
+        builder.withDirectives(*buildDirectives(objectDefinition.directives, Introspection.DirectiveLocation.OBJECT))
 
         objectDefinition.implements.forEach { implementsDefinition ->
             val interfaceName = (implementsDefinition as TypeName).name
@@ -160,19 +155,6 @@ class SchemaParser internal constructor(
         return schemaGeneratorDirectiveHelper.onObject(objectType, directiveHelperParameters)
     }
 
-    private fun buildDirectives(directives: List<Directive>, directiveDefinitions: Set<GraphQLDirective>, directiveLocation: Introspection.DirectiveLocation): Array<GraphQLDirective> {
-        val names = HashSet<String>()
-
-        val output = ArrayList<GraphQLDirective>()
-        for (directive in directives) {
-            if (!names.contains(directive.name)) {
-                names.add(directive.name)
-                output.add(schemaGeneratorHelper.buildDirective(directive, directiveDefinitions, directiveLocation, runtimeWiring.comparatorRegistry))
-            }
-        }
-        return output.toTypedArray()
-    }
-
     private fun createInputObject(definition: InputObjectTypeDefinition, inputObjects: List<GraphQLInputObjectType>,
                                   referencingInputObjects: MutableSet<String>): GraphQLInputObjectType {
         val extensionDefinitions = inputExtensionDefinitions.filter { it.name == definition.name }
@@ -183,19 +165,19 @@ class SchemaParser internal constructor(
             .extensionDefinitions(extensionDefinitions)
             .description(if (definition.description != null) definition.description.content else getDocumentation(definition))
 
-        builder.withDirectives(*buildDirectives(definition.directives, setOf(), Introspection.DirectiveLocation.INPUT_OBJECT))
+        builder.withDirectives(*buildDirectives(definition.directives, Introspection.DirectiveLocation.INPUT_OBJECT))
 
         referencingInputObjects.add(definition.name)
 
         (extensionDefinitions + definition).forEach {
             it.inputValueDefinitions.forEach { inputDefinition ->
                 val fieldBuilder = GraphQLInputObjectField.newInputObjectField()
-                        .name(inputDefinition.name)
-                        .definition(inputDefinition)
-                        .description(if (inputDefinition.description != null) inputDefinition.description.content else getDocumentation(inputDefinition))
-                        .defaultValue(buildDefaultValue(inputDefinition.defaultValue))
-                        .type(determineInputType(inputDefinition.type, inputObjects, referencingInputObjects))
-                        .withDirectives(*buildDirectives(inputDefinition.directives, setOf(), Introspection.DirectiveLocation.INPUT_FIELD_DEFINITION))
+                    .name(inputDefinition.name)
+                    .definition(inputDefinition)
+                    .description(if (inputDefinition.description != null) inputDefinition.description.content else getDocumentation(inputDefinition))
+                    .defaultValue(buildDefaultValue(inputDefinition.defaultValue))
+                    .type(determineInputType(inputDefinition.type, inputObjects, referencingInputObjects))
+                    .withDirectives(*buildDirectives(inputDefinition.directives, setOf(), Introspection.DirectiveLocation.INPUT_FIELD_DEFINITION))
                 builder.field(fieldBuilder.build())
             }
         }
@@ -214,14 +196,14 @@ class SchemaParser internal constructor(
             .definition(definition)
             .description(if (definition.description != null) definition.description.content else getDocumentation(definition))
 
-        builder.withDirectives(*buildDirectives(definition.directives, setOf(), Introspection.DirectiveLocation.ENUM))
+        builder.withDirectives(*buildDirectives(definition.directives, Introspection.DirectiveLocation.ENUM))
 
         definition.enumValueDefinitions.forEach { enumDefinition ->
             val enumName = enumDefinition.name
             val enumValue = type.unwrap().enumConstants.find { (it as Enum<*>).name == enumName }
                 ?: throw SchemaError("Expected value for name '$enumName' in enum '${type.unwrap().simpleName}' but found none!")
 
-            val enumValueDirectives = buildDirectives(enumDefinition.directives, setOf(), Introspection.DirectiveLocation.ENUM_VALUE)
+            val enumValueDirectives = buildDirectives(enumDefinition.directives, Introspection.DirectiveLocation.ENUM_VALUE)
             getDeprecated(enumDefinition.directives).let {
                 val enumValueDefinition = GraphQLEnumValueDefinition.newEnumValueDefinition()
                     .name(enumName)
@@ -246,7 +228,7 @@ class SchemaParser internal constructor(
             .definition(interfaceDefinition)
             .description(if (interfaceDefinition.description != null) interfaceDefinition.description.content else getDocumentation(interfaceDefinition))
 
-        builder.withDirectives(*buildDirectives(interfaceDefinition.directives, setOf(), Introspection.DirectiveLocation.INTERFACE))
+        builder.withDirectives(*buildDirectives(interfaceDefinition.directives, Introspection.DirectiveLocation.INTERFACE))
 
         interfaceDefinition.fieldDefinitions.forEach { fieldDefinition ->
             builder.field { field -> createField(field, fieldDefinition, inputObjects) }
@@ -262,7 +244,7 @@ class SchemaParser internal constructor(
             .definition(definition)
             .description(if (definition.description != null) definition.description.content else getDocumentation(definition))
 
-        builder.withDirectives(*buildDirectives(definition.directives, setOf(), Introspection.DirectiveLocation.UNION))
+        builder.withDirectives(*buildDirectives(definition.directives, Introspection.DirectiveLocation.UNION))
 
         getLeafUnionObjects(definition, types).forEach { builder.possibleType(it) }
         return schemaGeneratorDirectiveHelper.onUnion(builder.build(), schemaDirectiveParameters)
@@ -289,25 +271,95 @@ class SchemaParser internal constructor(
     }
 
     private fun createField(field: GraphQLFieldDefinition.Builder, fieldDefinition: FieldDefinition, inputObjects: List<GraphQLInputObjectType>): GraphQLFieldDefinition.Builder {
-        field.name(fieldDefinition.name)
-        field.description(if (fieldDefinition.description != null) fieldDefinition.description.content else getDocumentation(fieldDefinition))
-        field.definition(fieldDefinition)
-        getDeprecated(fieldDefinition.directives)?.let { field.deprecate(it) }
-        field.type(determineOutputType(fieldDefinition.type, inputObjects))
+        field
+            .name(fieldDefinition.name)
+            .description(fieldDefinition.description?.content ?: getDocumentation(fieldDefinition))
+            .definition(fieldDefinition)
+            .apply { getDeprecated(fieldDefinition.directives)?.let { deprecate(it) } }
+            .type(determineOutputType(fieldDefinition.type, inputObjects))
+
         fieldDefinition.inputValueDefinitions.forEach { argumentDefinition ->
             val argumentBuilder = GraphQLArgument.newArgument()
                 .name(argumentDefinition.name)
                 .definition(argumentDefinition)
                 .description(if (argumentDefinition.description != null) argumentDefinition.description.content else getDocumentation(argumentDefinition))
-                .defaultValue(buildDefaultValue(argumentDefinition.defaultValue))
                 .type(determineInputType(argumentDefinition.type, inputObjects, setOf()))
-                .withDirectives(*buildDirectives(argumentDefinition.directives, setOf(), Introspection.DirectiveLocation.ARGUMENT_DEFINITION))
+                .apply { buildDefaultValue(argumentDefinition.defaultValue)?.let { defaultValue(it) } }
+                .withDirectives(*buildDirectives(argumentDefinition.directives, Introspection.DirectiveLocation.ARGUMENT_DEFINITION))
+
             field.argument(argumentBuilder.build())
         }
-        field.withDirectives(*buildDirectives(fieldDefinition.directives, setOf(), Introspection.DirectiveLocation.FIELD_DEFINITION))
+        field.withDirectives(*buildDirectives(fieldDefinition.directives, Introspection.DirectiveLocation.FIELD_DEFINITION))
+
         return field
     }
 
+    private fun buildDirectives(directives: List<Directive>, directiveLocation: Introspection.DirectiveLocation): Array<GraphQLDirective> {
+        val names = mutableSetOf<String>()
+
+        val output = mutableListOf<GraphQLDirective>()
+        for (directive in directives) {
+            if (!names.contains(directive.name)) {
+                names.add(directive.name)
+                val graphQLDirective = GraphQLDirective.newDirective()
+                    .name(directive.name)
+                    .apply {
+                        directive.arguments.forEach { arg ->
+                            argument(GraphQLArgument.newArgument()
+                                .name(arg.name)
+                                .type(buildDirectiveInputType(arg.value))
+                                .build())
+                        }
+                    }
+                    .build()
+
+
+                output.add(schemaGeneratorHelper.buildDirective(directive, setOf(graphQLDirective), directiveLocation, runtimeWiring.comparatorRegistry))
+            }
+        }
+
+        return output.toTypedArray()
+    }
+
+    private fun buildDirectiveInputType(value: Value<*>): GraphQLInputType? {
+        when (value) {
+            is NullValue -> return Scalars.GraphQLString
+            is FloatValue -> return Scalars.GraphQLFloat
+            is StringValue -> return Scalars.GraphQLString
+            is IntValue -> return Scalars.GraphQLInt
+            is BooleanValue -> return Scalars.GraphQLBoolean
+            is ArrayValue -> return GraphQLList.list(buildDirectiveInputType(getArrayValueWrappedType(value)))
+            else -> throw SchemaError("Directive values of type '${value::class.simpleName}' are not supported yet.")
+        }
+    }
+
+    private fun getArrayValueWrappedType(value: ArrayValue): Value<*> {
+        // empty array [] is equivalent to [null]
+        if (value.values.isEmpty()) {
+            return NullValue.newNullValue().build()
+        }
+
+        // get rid of null values
+        val nonNullValueList = value.values.filter { v -> v !is NullValue }
+
+        // [null, null, ...] unwrapped is null
+        if (nonNullValueList.isEmpty()) {
+            return NullValue.newNullValue().build()
+        }
+
+        // make sure the array isn't polymorphic
+        val distinctTypes = nonNullValueList
+            .map { it::class.java }
+            .distinct()
+
+        if (distinctTypes.size > 1) {
+            throw SchemaError("Arrays containing multiple types of values are not supported yet.")
+        }
+
+        // peek at first value, value exists and is assured to be non-null
+        return nonNullValueList[0]
+    }
+
     private fun buildDefaultValue(value: Value<*>?): Any? {
         return when (value) {
             null -> null
@@ -335,7 +387,7 @@ class SchemaParser internal constructor(
             }
             is TypeName -> {
                 val scalarType = customScalars[typeDefinition.name]
-                    ?: graphQLScalars[typeDefinition.name]
+                    ?: GRAPHQL_SCALARS[typeDefinition.name]
                 if (scalarType != null) {
                     scalarType
                 } else {
@@ -365,7 +417,7 @@ class SchemaParser internal constructor(
             }
             is TypeName -> {
                 val scalarType = customScalars[typeDefinition.name]
-                    ?: graphQLScalars[typeDefinition.name]
+                    ?: GRAPHQL_SCALARS[typeDefinition.name]
                 if (scalarType != null) {
                     scalarType
                 } else {
@@ -417,4 +469,6 @@ class SchemaParser internal constructor(
 
 class SchemaError(message: String, cause: Throwable? = null) : RuntimeException(message, cause)
 
-val graphQLScalars = ScalarInfo.STANDARD_SCALARS.associateBy { it.name }
+val GRAPHQL_SCALARS = ScalarInfo.GRAPHQL_SPECIFICATION_SCALARS.associateBy { it.name }
+
+const val DEFAULT_DEPRECATION_MESSAGE = "No longer supported"

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

@@ -169,7 +169,7 @@ class SchemaParserBuilder {
             files.forEach { documents.add(parser.parseDocument(readFile(it), it)) }
 
             if (schemaString.isNotEmpty()) {
-                documents.add(parser.parseDocument(this.schemaString.toString()))
+                documents.add(parser.parseDocument(schemaString.toString()))
             }
         } catch (pce: ParseCancellationException) {
             val cause = pce.cause