Merge pull request #480 from thomasw21/nested_inputs_in_extensions_do_not_work

Allowing nested inputs defined in extensions to be parsed as well

Author: vojtapol

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

@@ -333,26 +333,29 @@ internal class SchemaClassScanner(
             }
 
             is InputObjectTypeDefinition -> {
-                graphQLType.inputValueDefinitions.forEach { inputValueDefinition ->
-                    val inputGraphQLType = inputValueDefinition.type.unwrap()
-                    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(
-                                inputValueDefinition.type,
-                                inputValueJavaType,
-                                GenericType(javaType, options).relativeToType(inputValueJavaType),
-                                InputObjectReference(inputValueDefinition)
-                            )))
-                        } else {
-                            var mappingAdvice = "Try adding it manually to the dictionary"
-                            if (javaType.unwrap().name.contains("Map")) {
-                                mappingAdvice = " or add a class to represent your input type instead of a Map."
+                val inputObjectTypes = listOf(graphQLType) + inputExtensionDefinitions.filter { it.name == graphQLType.name }
+                inputObjectTypes
+                    .flatMap { it.inputValueDefinitions }
+                    .forEach { inputValueDefinition ->
+                        val inputGraphQLType = inputValueDefinition.type.unwrap()
+                        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(
+                                    inputValueDefinition.type,
+                                    inputValueJavaType,
+                                    GenericType(javaType, options).relativeToType(inputValueJavaType),
+                                    InputObjectReference(inputValueDefinition)
+                                )))
+                            } else {
+                                var mappingAdvice = "Try adding it manually to the dictionary"
+                                if (javaType.unwrap().name.contains("Map")) {
+                                    mappingAdvice = " or add a class to represent your input type instead of a Map."
+                                }
+                                log.warn("Cannot find definition for field '${inputValueDefinition.name}: ${inputGraphQLType.name}' on input type '${graphQLType.name}' -> ${javaType.unwrap().name}. $mappingAdvice")
                             }
-                            log.warn("Cannot find definition for field '${inputValueDefinition.name}: ${inputGraphQLType.name}' on input type '${graphQLType.name}' -> ${javaType.unwrap().name}. $mappingAdvice")
                         }
                     }
-                }
             }
         }
     }

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

@@ -53,6 +53,55 @@ class NestedInputTypesSpec extends Specification {
         data.materials == []
     }
 
+    def "nested input in extensions are parsed"() {
+        when:
+        GraphQLSchema schema = SchemaParser.newParser().schemaString('''\
+                        type Query {
+                            materials(filter: MaterialFilter): [Material!]!
+                        }
+                        
+                        input MaterialFilter {
+                            title: String
+                        }
+                        
+                        extend input MaterialFilter {
+                            requestFilter: RequestFilter
+                        }
+                        
+                        input RequestFilter {
+                            and: [RequestFilter!]
+                            or: [RequestFilter!]
+                            discountTypeFilter: DiscountTypeFilter
+                        }
+                        
+                        input DiscountTypeFilter {
+                            name: String
+                        }
+                        
+                        type Material {
+                            id: ID!
+                        }
+                    ''').resolvers(new QueryResolver())
+                .build()
+                .makeExecutableSchema()
+        GraphQL gql = GraphQL.newGraphQL(schema)
+                .queryExecutionStrategy(new AsyncExecutionStrategy())
+                .build()
+        def data = Utils.assertNoGraphQlErrors(gql, [filter: [title: "title", requestFilter: [discountTypeFilter: [name: "discount"]]]]) {
+            '''
+                query materials($filter: MaterialFilter!) {
+                    materials(filter: $filter) {
+                        id
+                    }
+                }
+                '''
+        }
+
+        then:
+        noExceptionThrown()
+        data.materials == []
+    }
+
     class QueryResolver implements GraphQLQueryResolver {
         List<Material> materials(MaterialFilter filter) { Collections.emptyList() }
     }