Merge branch 'master' into bugfix/383_find_camelCaseGetter_from_snake_case_field

Author: plaurina

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,5 @@
 blank_issues_enabled: false
 contact_links:
   - name: Question
-    url: https://spectrum.chat/graphql-java-kick
-    about: Anything you are not sure about? Ask the community on Spectrum!
+    url: https://github.com/graphql-java-kickstart/graphql-java-tools/discussions
+    about: Anything you are not sure about? Ask the community!

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 Spectrum](https://img.shields.io/badge/spectrum-join%20the%20community-%23800080)](https://spectrum.chat/graphql-java-kick)
+[![Discuss on GitHub](https://img.shields.io/badge/GitHub-discuss-orange)](https://github.com/graphql-java-kickstart/graphql-java-tools/discussions)
 
 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.
@@ -11,9 +11,10 @@ GraphQL Java Tools works well if you already have domain POJOs that hold your da
 GraphQL Java Tools aims for seamless integration with Java, but works for any JVM language.  Try it with Kotlin!
 
 ## We are looking for contributors!
+
 Are you interested in improving our documentation, working on the codebase, reviewing PRs?
 
-[Reach out to us on Spectrum](https://spectrum.chat/graphql-java-kick) and join the team!
+[Reach out to us on GitHub](https://github.com/graphql-java-kickstart/graphql-java-tools/discussions) and join the team!
 
 ## Quick start
 
@@ -25,7 +26,7 @@ kotlin.version=1.3.70
 
 Add the dependency:
 ```groovy
-compile 'com.graphql-java-kickstart:graphql-java-tools:6.2.0'
+compile 'com.graphql-java-kickstart:graphql-java-tools:6.3.0'
 ```
 
 ### Using Maven
@@ -41,7 +42,7 @@ Add the dependency:
 <dependency>
     <groupId>com.graphql-java-kickstart</groupId>
     <artifactId>graphql-java-tools</artifactId>
-    <version>6.2.0</version>
+    <version>6.3.0</version>
 </dependency>
 ```
 

pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>com.graphql-java-kickstart</groupId>
     <artifactId>graphql-java-tools</artifactId>
-    <version>6.2.1-SNAPSHOT</version>
+    <version>6.3.1-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <name>GraphQL Java Tools</name>

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

@@ -76,7 +76,7 @@ class SchemaParser internal constructor(
         val inputObjects: MutableList<GraphQLInputObjectType> = mutableListOf()
         inputObjectDefinitions.forEach {
             if (inputObjects.none { io -> io.name == it.name }) {
-                inputObjects.add(createInputObject(it, inputObjects))
+                inputObjects.add(createInputObject(it, inputObjects, mutableSetOf()))
             }
         }
         val interfaces = interfaceDefinitions.map { createInterfaceObject(it, inputObjects) }
@@ -155,7 +155,8 @@ class SchemaParser internal constructor(
         return schemaGeneratorDirectiveHelper.onObject(objectType, directiveHelperParameters)
     }
 
-    private fun createInputObject(definition: InputObjectTypeDefinition, inputObjects: List<GraphQLInputObjectType>): GraphQLInputObjectType {
+    private fun createInputObject(definition: InputObjectTypeDefinition, inputObjects: List<GraphQLInputObjectType>,
+                                  referencingInputObjects: MutableSet<String>): GraphQLInputObjectType {
         val extensionDefinitions = inputExtensionDefinitions.filter { it.name == definition.name }
 
         val builder = GraphQLInputObjectType.newInputObject()
@@ -166,14 +167,16 @@ class SchemaParser internal constructor(
 
         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))
+                    .type(determineInputType(inputDefinition.type, inputObjects, referencingInputObjects))
                     .withDirectives(*buildDirectives(inputDefinition.directives, Introspection.DirectiveLocation.INPUT_FIELD_DEFINITION))
                 builder.field(fieldBuilder.build())
             }
@@ -280,7 +283,7 @@ class SchemaParser internal constructor(
                 .name(argumentDefinition.name)
                 .definition(argumentDefinition)
                 .description(if (argumentDefinition.description != null) argumentDefinition.description.content else getDocumentation(argumentDefinition))
-                .type(determineInputType(argumentDefinition.type, inputObjects))
+                .type(determineInputType(argumentDefinition.type, inputObjects, setOf()))
                 .apply { buildDefaultValue(argumentDefinition.defaultValue)?.let { defaultValue(it) } }
                 .withDirectives(*buildDirectives(argumentDefinition.directives, Introspection.DirectiveLocation.ARGUMENT_DEFINITION))
 
@@ -380,7 +383,7 @@ class SchemaParser internal constructor(
             is NonNullType -> GraphQLNonNull(determineType(expectedType, typeDefinition.type, allowedTypeReferences, inputObjects))
             is InputObjectTypeDefinition -> {
                 log.info("Create input object")
-                createInputObject(typeDefinition, inputObjects)
+                createInputObject(typeDefinition, inputObjects, mutableSetOf())
             }
             is TypeName -> {
                 val scalarType = customScalars[typeDefinition.name]
@@ -398,16 +401,19 @@ class SchemaParser internal constructor(
             else -> throw SchemaError("Unknown type: $typeDefinition")
         }
 
-    private fun determineInputType(typeDefinition: Type<*>, inputObjects: List<GraphQLInputObjectType>) =
-        determineInputType(GraphQLInputType::class, typeDefinition, permittedTypesForInputObject, inputObjects) as GraphQLInputType
+    private fun determineInputType(typeDefinition: Type<*>, inputObjects: List<GraphQLInputObjectType>, referencingInputObjects: Set<String>) =
+        determineInputType(GraphQLInputType::class, typeDefinition, permittedTypesForInputObject, inputObjects, referencingInputObjects) as GraphQLInputType
 
-    private fun <T : Any> determineInputType(expectedType: KClass<T>, typeDefinition: Type<*>, allowedTypeReferences: Set<String>, inputObjects: List<GraphQLInputObjectType>): GraphQLType =
+    private fun <T : Any> determineInputType(expectedType: KClass<T>,
+                                             typeDefinition: Type<*>, allowedTypeReferences: Set<String>,
+                                             inputObjects: List<GraphQLInputObjectType>,
+                                             referencingInputObjects: Set<String>): GraphQLType =
         when (typeDefinition) {
             is ListType -> GraphQLList(determineType(expectedType, typeDefinition.type, allowedTypeReferences, inputObjects))
             is NonNullType -> GraphQLNonNull(determineType(expectedType, typeDefinition.type, allowedTypeReferences, inputObjects))
             is InputObjectTypeDefinition -> {
                 log.info("Create input object")
-                createInputObject(typeDefinition, inputObjects)
+                createInputObject(typeDefinition, inputObjects, referencingInputObjects as MutableSet<String>)
             }
             is TypeName -> {
                 val scalarType = customScalars[typeDefinition.name]
@@ -425,9 +431,14 @@ class SchemaParser internal constructor(
                     } else {
                         val filteredDefinitions = inputObjectDefinitions.filter { it.name == typeDefinition.name }
                         if (filteredDefinitions.isNotEmpty()) {
-                            val inputObject = createInputObject(filteredDefinitions[0], inputObjects)
-                            (inputObjects as MutableList).add(inputObject)
-                            inputObject
+                            val referencingInputObject = referencingInputObjects.find { it == typeDefinition.name }
+                            if (referencingInputObject != null) {
+                                GraphQLTypeReference(referencingInputObject)
+                            } else {
+                                val inputObject = createInputObject(filteredDefinitions[0], inputObjects, referencingInputObjects as MutableSet<String>)
+                                (inputObjects as MutableList).add(inputObject)
+                                inputObject
+                            }
                         } else {
                             // todo: handle enum type
                             GraphQLTypeReference(typeDefinition.name)

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

@@ -80,7 +80,7 @@ internal class MethodFieldResolver(
                     return@add Optional.empty<Any>()
                 }
 
-                if (value != null && shouldValueBeConverted(value, definition, parameterType, environment)) {
+                if (value == null || shouldValueBeConverted(value, definition, parameterType, environment)) {
                     return@add mapper.convertValue(value, object : TypeReference<Any>() {
                         override fun getType() = parameterType
                     })

src/test/groovy/graphql/kickstart/tools/SchemaParserSpec.groovy

@@ -368,6 +368,50 @@ class SchemaParserSpec extends Specification {
         noExceptionThrown()
     }
 
+    def "allow circular relations in input objects"() {
+        when:
+        SchemaParser.newParser().schemaString('''\
+            input A {
+                id: ID!
+                b: B
+            }
+            input B {
+                id: ID!
+                a: A
+            }
+            input C {
+                id: ID!
+                c: C
+            }
+            type Query {}
+            type Mutation {
+                test(input: A!): Boolean
+                testC(input: C!): Boolean
+            }
+            '''.stripIndent())
+        .resolvers(new GraphQLMutationResolver() {
+            static class A {
+                String id;
+                B b;
+            }
+            static class B {
+                String id;
+                A a;
+            }
+            static class C {
+                String id;
+                C c;
+            }
+            boolean test(A a) { return true }
+            boolean testC(C c) { return true }
+        }, new GraphQLQueryResolver() {})
+        .build()
+        .makeExecutableSchema()
+
+        then:
+        noExceptionThrown()
+    }
+
     enum EnumType {
         TEST
     }

src/test/kotlin/graphql/kickstart/tools/ResolverMethodsTest.java

@@ -0,0 +1,52 @@
+package graphql.kickstart.tools;
+
+import graphql.ExecutionInput;
+import graphql.ExecutionResult;
+import graphql.GraphQL;
+import graphql.schema.GraphQLSchema;
+import org.junit.Test;
+
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class ResolverMethodsTest {
+    // Note: don't convert this code to Kotlin or Groovy, since it's quite important that the
+    //       resolver method is defined with an argument of primitive type, like 'boolean', not 'Boolean':
+    //         String testOmittedBoolean(boolean value1, Boolean value2)
+    @Test
+    public void testOmittedBooleanArgument() {
+        // In this schema, the 'value1' argument is optional, but the Java resolver defines it as 'boolean'
+        // Instead of failing with an error, we expect the argument to be set to the Java default (i.e. false for booleans)
+        GraphQLSchema schema = SchemaParser.newParser()
+                .schemaString("" +
+                        "type Query {" +
+                        "   testOmittedBoolean(value1: Boolean, value2: Boolean): String" +
+                        "}")
+                .resolvers(new Resolver())
+                .build()
+                .makeExecutableSchema();
+
+        GraphQL gql = GraphQL.newGraphQL(schema).build();
+
+        ExecutionResult result = gql
+                .execute(ExecutionInput.newExecutionInput()
+                        .query("" +
+                                "query { " +
+                                "  testOmittedBoolean" +
+                                "}")
+                        .context(new Object())
+                        .root(new Object()));
+
+        assertTrue(result.getErrors().isEmpty());
+        assertEquals("false,null", ((Map<?, ?>) result.getData()).get("testOmittedBoolean"));
+    }
+
+    static class Resolver implements GraphQLQueryResolver {
+        @SuppressWarnings("unused")
+        public String testOmittedBoolean(boolean value1, Boolean value2) {
+            return value1 + "," + value2;
+        }
+    }
+}