Merge branch 'master' into remove-undeclared-directives

andimarek · andimarek · commit e255b62fcd1a · 2020-01-30T10:42:28.000+11:00
diff --git a/src/main/java/graphql/schema/idl/SchemaGenerator.java b/src/main/java/graphql/schema/idl/SchemaGenerator.java
@@ -213,7 +213,9 @@ public SchemaGenerator() {
      *
      * @param typeRegistry this can be obtained via {@link SchemaParser#parse(String)}
      * @param wiring       this can be built using {@link RuntimeWiring#newRuntimeWiring()}
+     *
      * @return an executable schema
+     *
      * @throws SchemaProblem if there are problems in assembling a schema such as missing type resolvers or no operations defined
      */
     public GraphQLSchema makeExecutableSchema(TypeDefinitionRegistry typeRegistry, RuntimeWiring wiring) throws SchemaProblem {
@@ -227,7 +229,9 @@ public GraphQLSchema makeExecutableSchema(TypeDefinitionRegistry typeRegistry, R
      * @param options      the controlling options
      * @param typeRegistry this can be obtained via {@link SchemaParser#parse(String)}
      * @param wiring       this can be built using {@link RuntimeWiring#newRuntimeWiring()}
+     *
      * @return an executable schema
+     *
      * @throws SchemaProblem if there are problems in assembling a schema such as missing type resolvers or no operations defined
      */
     public GraphQLSchema makeExecutableSchema(Options options, TypeDefinitionRegistry typeRegistry, RuntimeWiring wiring) throws SchemaProblem {
@@ -351,6 +355,7 @@ private GraphQLObjectType buildOperation(BuildContext buildCtx, OperationTypeDef
      * but then we build the rest of the types specified and put them in as additional types
      *
      * @param buildCtx the context we need to work out what we are doing
+     *
      * @return the additional types not referenced from the top level operations
      */
     private Set<GraphQLType> buildAdditionalTypes(BuildContext buildCtx) {
@@ -368,6 +373,14 @@ private Set<GraphQLType> buildAdditionalTypes(BuildContext buildCtx) {
                 }
             }
         });
+        typeRegistry.scalars().values().forEach(scalarTypeDefinition -> {
+            if (ScalarInfo.isStandardScalar(scalarTypeDefinition.getName())) {
+                return;
+            }
+            if (buildCtx.hasInputType(scalarTypeDefinition) == null && buildCtx.hasOutputType(scalarTypeDefinition) == null) {
+                additionalTypes.add(buildScalar(buildCtx, scalarTypeDefinition));
+            }
+        });
         return additionalTypes;
     }
 
@@ -387,6 +400,7 @@ private Set<GraphQLDirective> buildAdditionalDirectives(BuildContext buildCtx) {
      *
      * @param buildCtx the context we need to work out what we are doing
      * @param rawType  the type to be built
+     *
      * @return an output type
      */
     @SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"})
diff --git a/src/test/groovy/graphql/schema/idl/MockedWiringFactory.groovy b/src/test/groovy/graphql/schema/idl/MockedWiringFactory.groovy
@@ -1,8 +1,13 @@
 package graphql.schema.idl
 
 import graphql.TypeResolutionEnvironment
+import graphql.schema.Coercing
+import graphql.schema.CoercingParseLiteralException
+import graphql.schema.CoercingParseValueException
+import graphql.schema.CoercingSerializeException
 import graphql.schema.DataFetcher
 import graphql.schema.GraphQLObjectType
+import graphql.schema.GraphQLScalarType
 import graphql.schema.PropertyDataFetcher
 import graphql.schema.TypeResolver
 
@@ -47,4 +52,31 @@ class MockedWiringFactory implements WiringFactory {
     DataFetcher getDataFetcher(FieldWiringEnvironment environment) {
         return new PropertyDataFetcher(environment.getFieldDefinition().getName())
     }
+
+    @Override
+    boolean providesScalar(ScalarWiringEnvironment environment) {
+        if (ScalarInfo.isStandardScalar(environment.getScalarTypeDefinition().getName())) {
+            return false
+        }
+        return true
+    }
+
+    GraphQLScalarType getScalar(ScalarWiringEnvironment environment) {
+        return GraphQLScalarType.newScalar().name(environment.getScalarTypeDefinition().getName()).coercing(new Coercing() {
+            @Override
+            Object serialize(Object dataFetcherResult) throws CoercingSerializeException {
+                throw new UnsupportedOperationException("Not implemented");
+            }
+
+            @Override
+            Object parseValue(Object input) throws CoercingParseValueException {
+                throw new UnsupportedOperationException("Not implemented");
+            }
+
+            @Override
+            Object parseLiteral(Object input) throws CoercingParseLiteralException {
+                throw new UnsupportedOperationException("Not implemented");
+            }
+        }).build()
+    }
 }
diff --git a/src/test/groovy/graphql/schema/idl/SchemaGeneratorTest.groovy b/src/test/groovy/graphql/schema/idl/SchemaGeneratorTest.groovy
@@ -1998,4 +1998,49 @@ class SchemaGeneratorTest extends Specification {
         GraphQLTypeUtil.simplePrint(directive.getArgument("enumArguments").getType()) == "[SomeEnum!]"
         directive.getArgument("enumArguments").getDefaultValue() == []
     }
+
+    def "scalar used as output is not in additional types"() {
+        given:
+
+        def spec = """
+        scalar UsedScalar
+        type Query{ foo: UsedScalar }
+        """
+        when:
+        def schema = schema(spec)
+        then:
+        schema.getType("UsedScalar") != null
+        schema.getAdditionalTypes().find { it.name == "UsedScalar" } == null
+    }
+
+    def "scalar used as input is not in additional types"() {
+        given:
+
+        def spec = """
+        scalar UsedScalar
+        input Input {
+            foo: UsedScalar
+        }
+        type Query{ foo(arg: Input): String }
+        """
+        when:
+        def schema = schema(spec)
+        then:
+        schema.getType("UsedScalar") != null
+        schema.getAdditionalTypes().find { it.name == "UsedScalar" } == null
+    }
+
+    def "unused scalar is not ignored and provided as additional type"() {
+        given:
+
+        def spec = """
+        scalar UnusedScalar
+        type Query{ foo: String }
+        """
+        when:
+        def schema = schema(spec)
+        then:
+        schema.getType("UnusedScalar") != null
+        schema.getAdditionalTypes().find { it.name == "UnusedScalar" } != null
+    }
 }
