Added example mutation showing partial updates

Author: oliemansm

src/main/kotlin/com/coxautodev/graphql/tools/SchemaClassScanner.kt

@@ -17,8 +17,8 @@ import graphql.language.TypeName
 import graphql.language.UnionTypeDefinition
 import graphql.schema.GraphQLScalarType
 import graphql.schema.idl.ScalarInfo
+import graphql.schema.idl.SchemaDirectiveWiring
 import org.slf4j.LoggerFactory
-import java.lang.reflect.Field
 import java.lang.reflect.Method
 
 /**
@@ -134,7 +134,7 @@ internal class SchemaClassScanner(initialDictionary: BiMap<String, Class<*>>, al
         val dictionary = try {
             Maps.unmodifiableBiMap(HashBiMap.create<TypeDefinition<*>, JavaType>().also {
                 dictionary.filter {
-                            it.value.javaType != null
+                    it.value.javaType != null
                             && it.value.typeClass() != java.lang.Object::class.java
                             && !java.util.Map::class.java.isAssignableFrom(it.value.typeClass())
                             && it.key !is InputObjectTypeDefinition
@@ -216,9 +216,9 @@ internal class SchemaClassScanner(initialDictionary: BiMap<String, Class<*>>, al
         }
     }
 
-    private fun getResolverInfoFromTypeDictionary(typeName: String) : ResolverInfo? {
+    private fun getResolverInfoFromTypeDictionary(typeName: String): ResolverInfo? {
         val dictionaryType = initialDictionary[typeName]?.get()
-        return if(dictionaryType != null) {
+        return if (dictionaryType != null) {
             resolverInfosByDataClass[dictionaryType] ?: DataClassResolverInfo(dictionaryType);
         } else {
             null
@@ -233,13 +233,13 @@ internal class SchemaClassScanner(initialDictionary: BiMap<String, Class<*>>, al
         val resolverInfo: ResolverInfo? = if (resolverInfoList.size > 1) {
             MultiResolverInfo(resolverInfoList)
         } else {
-            if(item.clazz.equals(Object::class.java)) {
+            if (item.clazz.equals(Object::class.java)) {
                 getResolverInfoFromTypeDictionary(item.type.name)
             } else {
                 resolverInfosByDataClass[item.clazz] ?: DataClassResolverInfo(item.clazz)
             }
         }
-        if(resolverInfo == null) {
+        if (resolverInfo == null) {
             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.")
         }
 
@@ -287,7 +287,7 @@ internal class SchemaClassScanner(initialDictionary: BiMap<String, Class<*>>, al
                 if (options.preferGraphQLResolver && realEntry.hasResolverRef()) {
                     log.warn("The real entry ${realEntry.joinReferences()} is a GraphQLResolver so ignoring this one ${javaType.unwrap()} $reference")
                 } else {
-                    if(java.util.Map::class.java.isAssignableFrom(javaType.unwrap())) {
+                    if (java.util.Map::class.java.isAssignableFrom(javaType.unwrap())) {
                         throw SchemaClassScannerError("Two different property map classes used for type ${type.name}:\n${realEntry.joinReferences()}\n\n- ${javaType}:\n|   ${reference.getDescription()}")
                     }
                     throw SchemaClassScannerError("Two different classes used for type ${type.name}:\n${realEntry.joinReferences()}\n\n- ${javaType.unwrap()}:\n|   ${reference.getDescription()}")

src/main/kotlin/com/coxautodev/graphql/tools/SchemaParser.kt

@@ -1,5 +1,6 @@
 package com.coxautodev.graphql.tools
 
+import graphql.introspection.Introspection
 import graphql.language.AbstractNode
 import graphql.language.ArrayValue
 import graphql.language.BooleanValue
@@ -22,6 +23,7 @@ import graphql.language.TypeDefinition
 import graphql.language.TypeName
 import graphql.language.UnionTypeDefinition
 import graphql.language.Value
+import graphql.schema.GraphQLDirective
 import graphql.schema.GraphQLEnumType
 import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.GraphQLInputObjectType
@@ -36,15 +38,20 @@ import graphql.schema.GraphQLType
 import graphql.schema.GraphQLTypeReference
 import graphql.schema.GraphQLUnionType
 import graphql.schema.TypeResolverProxy
+import graphql.schema.idl.DirectiveBehavior
+import graphql.schema.idl.RuntimeWiring
 import graphql.schema.idl.ScalarInfo
+import graphql.schema.idl.SchemaGeneratorHelper
+import java.util.ArrayList
+import java.util.HashSet
 import kotlin.reflect.KClass
 
 /**
  * Parses a GraphQL Schema and maps object fields to provided class methods.
  *
  * @author Andrew Potter
  */
-class SchemaParser internal constructor(scanResult: ScannedSchemaObjects, private val options: SchemaParserOptions) {
+class SchemaParser internal constructor(scanResult: ScannedSchemaObjects, private val options: SchemaParserOptions, private val runtimeWiring: RuntimeWiring) {
 
     companion object {
         const val DEFAULT_DEPRECATION_MESSAGE = "No longer supported"
@@ -79,6 +86,9 @@ class SchemaParser internal constructor(scanResult: ScannedSchemaObjects, privat
     private val permittedTypesForInputObject: Set<String> =
             (inputObjectDefinitions.map { it.name } + enumDefinitions.map { it.name }).toSet()
 
+    private val schemaGeneratorHelper = SchemaGeneratorHelper()
+    private val directiveGenerator = DirectiveBehavior()
+
     /**
      * Parses the given schema with respect to the given dictionary and returns GraphQL objects.
      */
@@ -124,19 +134,42 @@ class SchemaParser internal constructor(scanResult: ScannedSchemaObjects, privat
             .definition(definition)
             .description(getDocumentation(definition))
 
+        val directiveDefinitions = setOf<GraphQLDirective>()
+        builder.withDirectives(*buildDirectives(definition.directives, directiveDefinitions, Introspection.DirectiveLocation.OBJECT))
+
         definition.implements.forEach { implementsDefinition ->
             val interfaceName = (implementsDefinition as TypeName).name
             builder.withInterface(interfaces.find { it.name == interfaceName } ?: throw SchemaError("Expected interface type with name '$interfaceName' but found none!"))
         }
 
         definition.getExtendedFieldDefinitions(extensionDefinitions).forEach { fieldDefinition ->
+            fieldDefinition.description
             builder.field { field ->
                 createField(field, fieldDefinition)
+                // todo: apply directives to the fieldDefinition to use to find dataFetcher we're really after
                 field.dataFetcher(fieldResolversByType[definition]?.get(fieldDefinition)?.createDataFetcher() ?: throw SchemaError("No resolver method found for object type '${definition.name}' and field '${fieldDefinition.name}', this is most likely a bug with graphql-java-tools"))
+
+                val wiredField = directiveGenerator.onField(field.build(), DirectiveBehavior.Params(runtimeWiring))
+                GraphQLFieldDefinition.Builder(wiredField)
             }
         }
 
-        return builder.build()
+        val objectType = builder.build()
+
+        return directiveGenerator.onObject(objectType, DirectiveBehavior.Params(runtimeWiring))
+    }
+
+    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))
+            }
+        }
+        return output.toTypedArray()
     }
 
     private fun createInputObject(definition: InputObjectTypeDefinition): GraphQLInputObjectType {
@@ -243,6 +276,7 @@ class SchemaParser internal constructor(scanResult: ScannedSchemaObjects, privat
                 argument.type(determineInputType(argumentDefinition.type))
             }
         }
+        field.withDirectives(*buildDirectives(fieldDefinition.directives, setOf(), Introspection.DirectiveLocation.FIELD_DEFINITION))
         return field
     }
 

src/main/kotlin/com/coxautodev/graphql/tools/SchemaParserBuilder.kt

@@ -8,6 +8,8 @@ import graphql.language.Document
 import graphql.parser.Parser
 import graphql.schema.DataFetchingEnvironment
 import graphql.schema.GraphQLScalarType
+import graphql.schema.idl.RuntimeWiring
+import graphql.schema.idl.SchemaDirectiveWiring
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.channels.ReceiveChannel
@@ -31,6 +33,7 @@ class SchemaParserBuilder constructor(private val dictionary: SchemaParserDictio
     private val files = mutableListOf<String>()
     private val resolvers = mutableListOf<GraphQLResolver<*>>()
     private val scalars = mutableListOf<GraphQLScalarType>()
+    private val runtimeWiringBuilder = RuntimeWiring.newRuntimeWiring()
     private var options = SchemaParserOptions.defaultOptions()
 
     /**
@@ -78,6 +81,10 @@ class SchemaParserBuilder constructor(private val dictionary: SchemaParserDictio
         this.scalars.addAll(scalars)
     }
 
+    fun directive(name: String, directive: SchemaDirectiveWiring) = this.apply {
+        this.runtimeWiringBuilder.directive(name, directive)
+    }
+
     /**
      * Add arbitrary classes to the parser's dictionary, overriding the generated type name.
      */
@@ -181,7 +188,7 @@ class SchemaParserBuilder constructor(private val dictionary: SchemaParserDictio
     /**
      * Build the parser with the supplied schema and dictionary.
      */
-    fun build() = SchemaParser(scan(), options)
+    fun build() = SchemaParser(scan(), options, runtimeWiringBuilder.build())
 }
 
 class InvalidSchemaError(pce: ParseCancellationException, private val recognitionException: RecognitionException) : RuntimeException(pce) {

src/main/kotlin/graphql/schema/idl/DirectiveBehavior.kt

@@ -0,0 +1,22 @@
+package graphql.schema.idl
+
+import graphql.schema.GraphQLFieldDefinition
+import graphql.schema.GraphQLObjectType
+
+class DirectiveBehavior {
+
+    private val directiveHelper = SchemaGeneratorDirectiveHelper()
+
+    fun onObject(element: GraphQLObjectType, params: Params): GraphQLObjectType {
+        return directiveHelper.onObject(element, params.toParameters())
+    }
+
+    fun onField(element: GraphQLFieldDefinition, params: Params): GraphQLFieldDefinition {
+        return directiveHelper.onField(element, params.toParameters())
+    }
+
+
+    data class Params(val runtimeWiring: RuntimeWiring) {
+        internal fun toParameters() = SchemaGeneratorDirectiveHelper.Parameters(null, runtimeWiring, null, null)
+    }
+}

src/test/groovy/com/coxautodev/graphql/tools/RelayConnectionSpec.groovy

@@ -13,6 +13,8 @@ class RelayConnectionSpec extends Specification {
     def "relay connection types are compatible"() {
         when:
             GraphQLSchema schema = SchemaParser.newParser().schemaString('''\
+                        directive @uppercase on FIELD_DEFINITION
+                        
                         type Query {
                             users(first: Int, after: String): UserConnection
                             otherTypes: AnotherTypeConnection
@@ -27,9 +29,10 @@ class RelayConnectionSpec extends Specification {
                             node: User!
                         }
                         
+                        
                         type User {
                             id: ID!
-                            name: String
+                            name: String @uppercase
                         }
                         
                         type PageInfo {
@@ -48,6 +51,7 @@ class RelayConnectionSpec extends Specification {
                         }
                     ''')
                     .resolvers(new QueryResolver())
+                    .directive("uppercase", new RelayConnectionTest.UppercaseDirective())
                     .build()
                     .makeExecutableSchema()
             GraphQL gql = GraphQL.newGraphQL(schema)
@@ -79,7 +83,7 @@ class RelayConnectionSpec extends Specification {
             noExceptionThrown()
             data.users.edges.size == 1
             data.users.edges[0].node.id == "1"
-            data.users.edges[0].node.name == "name"
+            data.users.edges[0].node.name == "NAME"
             data.otherTypes.edges.size == 1
             data.otherTypes.edges[0].node.echo == "echo"
     }

src/test/java/com/coxautodev/graphql/tools/RelayConnectionTest.java

@@ -2,18 +2,27 @@
 
 import graphql.relay.Connection;
 import graphql.relay.SimpleListConnection;
-import graphql.schema.DataFetchingEnvironment;
+import graphql.schema.*;
+import graphql.schema.idl.SchemaDirectiveWiring;
+import graphql.schema.idl.SchemaDirectiveWiringEnvironment;
+import graphql.schema.idl.SchemaDirectiveWiringEnvironmentImpl;
 import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 
 public class RelayConnectionTest {
 
+    private static final Logger log = LoggerFactory.getLogger(RelayConnectionTest.class);
+
     @Test
     public void compiles() {
         SchemaParser.newParser().file("RelayConnection.graphqls")
                 .resolvers(new QueryResolver())
                 .dictionary(User.class)
+                .directive("connection", new RelayConnection())
+                .directive("uppercase", new UppercaseDirective())
                 .build()
                 .makeExecutableSchema();
     }
@@ -29,4 +38,31 @@ static class User {
         Long id;
         String name;
     }
+
+    static class RelayConnection implements SchemaDirectiveWiring {
+
+        @Override
+        public GraphQLFieldDefinition onField(SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition> environment) {
+            GraphQLFieldDefinition field = environment.getElement();
+            log.info("Transforming field");
+            return field;
+        }
+
+    }
+
+    static class UppercaseDirective implements SchemaDirectiveWiring {
+
+        @Override
+        public GraphQLFieldDefinition onField(SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition> env) {
+            GraphQLFieldDefinition field = env.getElement();
+            DataFetcher dataFetcher = DataFetcherFactories.wrapDataFetcher(field.getDataFetcher(), ((dataFetchingEnvironment, value) -> {
+                if (value == null) {
+                    return null;
+                }
+                String uppercase = ((String) value).toUpperCase();
+                return uppercase;
+            }));
+            return field.transform(builder -> builder.dataFetcher(dataFetcher));
+        }
+    }
 }

src/test/resources/RelayConnection.graphqls

@@ -1,5 +1,8 @@
+directive @connection on FIELD_DEFINITION
+directive @uppercase on FIELD_DEFINITION
+
 type Query {
-    users(first: Int, after: String): UserConnection
+    users(first: Int, after: String): UserConnection @connection
 }
 
 type UserConnection {
@@ -14,7 +17,7 @@ type UserEdge {
 
 type User {
     id: ID!
-    name: String
+    name: String @uppercase
 }
 
 type PageInfo {