#434 Add GraphQlInputObjectType reference for NonNull INput types at …

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

@@ -395,7 +395,7 @@ class SchemaParser internal constructor(
                         throw SchemaError("Expected type '${typeDefinition.name}' to be a ${expectedType.simpleName}, but it wasn't!  " +
                             "Was a type only permitted for object types incorrectly used as an input type, or vice-versa?")
                     }
-                    GraphQLTypeReference(typeDefinition.name)
+                    inputObjects.find { it.name == typeDefinition.name } ?: GraphQLTypeReference(typeDefinition.name)
                 }
             }
             else -> throw SchemaError("Unknown type: $typeDefinition")

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

@@ -2,7 +2,12 @@ package graphql.kickstart.tools
 
 import graphql.kickstart.tools.resolver.FieldResolverError
 import graphql.language.SourceLocation
+import graphql.schema.GraphQLArgument
+import graphql.schema.GraphQLInputObjectType
+import graphql.schema.GraphQLNonNull
 import graphql.schema.GraphQLSchema
+import graphql.schema.idl.SchemaDirectiveWiring
+import graphql.schema.idl.SchemaDirectiveWiringEnvironment
 import org.springframework.aop.framework.ProxyFactory
 import spock.lang.Specification
 
@@ -368,6 +373,45 @@ class SchemaParserSpec extends Specification {
         noExceptionThrown()
     }
 
+    def "NonNull and nullable input arguments should resolve to GraphQLInputObjectType"() {
+        when:
+        GraphQLSchema schema = SchemaParser.newParser().schemaString('''\
+                    type Query { 
+                        testNonNullable(filter: Filter!): Boolean
+                        testNullable(filter: Filter): Boolean
+                    }
+
+                    input Filter {
+                        filter: String
+                    }
+                '''.stripIndent())
+                .resolvers(new GraphQLQueryResolver() {
+                    boolean testNonNullable(Filter filter) { false }
+                    boolean testNullable(Filter filter) { false }
+                })
+                .directiveWiring(new SchemaDirectiveWiring(){
+                        GraphQLArgument onArgument(SchemaDirectiveWiringEnvironment<GraphQLArgument> environment) {
+                            switch (environment.getElement().type.class) {
+                                case GraphQLNonNull:
+                                    assert (environment.getElement().type as GraphQLNonNull).wrappedType.class == GraphQLInputObjectType
+                            }
+                            return environment.getElement()
+                        }})
+                .build()
+                .makeExecutableSchema()
+
+        then:
+        GraphQLArgument testNonNullableArgument = schema.getObjectType("Query")
+                .getFieldDefinition("testNonNullable")
+                .arguments.first()
+        GraphQLArgument testNullableArgument = schema.getObjectType("Query")
+                .getFieldDefinition("testNullable")
+                .arguments.first()
+        testNonNullableArgument.type.class == GraphQLNonNull
+        (testNonNullableArgument.type as GraphQLNonNull).wrappedType.class == GraphQLInputObjectType
+        testNullableArgument.type.class == GraphQLInputObjectType
+    }
+
     def "allow circular relations in input objects"() {
         when:
         SchemaParser.newParser().schemaString('''\