fix for graphql-java#1434 directive definition printing

bbakerman · bbakerman · commit 4a8051999938 · 2019-03-19T11:25:37.000+11:00
diff --git a/src/main/java/graphql/schema/idl/SchemaPrinter.java b/src/main/java/graphql/schema/idl/SchemaPrinter.java
@@ -33,7 +33,9 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static graphql.schema.visibility.DefaultGraphqlFieldVisibility.DEFAULT_FIELD_VISIBILITY;
@@ -64,11 +66,11 @@ public static class Options {
         private final SchemaPrinterComparatorRegistry comparatorRegistry;
 
         private Options(boolean includeIntrospectionTypes,
-                boolean includeScalars,
-                boolean includeExtendedScalars,
-                boolean includeSchemaDefinition,
-                boolean includeDirectives,
-                SchemaPrinterComparatorRegistry comparatorRegistry) {
+                        boolean includeScalars,
+                        boolean includeExtendedScalars,
+                        boolean includeSchemaDefinition,
+                        boolean includeDirectives,
+                        SchemaPrinterComparatorRegistry comparatorRegistry) {
             this.includeIntrospectionTypes = includeIntrospectionTypes;
             this.includeScalars = includeScalars;
             this.includeExtendedScalars = includeExtendedScalars;
@@ -106,6 +108,7 @@ public static Options defaultOptions() {
          * This will allow you to include introspection types that are contained in a schema
          *
          * @param flag whether to include them
+         *
          * @return options
          */
         public Options includeIntrospectionTypes(boolean flag) {
@@ -116,6 +119,7 @@ public Options includeIntrospectionTypes(boolean flag) {
          * This will allow you to include scalar types that are contained in a schema
          *
          * @param flag whether to include them
+         *
          * @return options
          */
         public Options includeScalarTypes(boolean flag) {
@@ -127,6 +131,7 @@ public Options includeScalarTypes(boolean flag) {
          * GraphQLBigDecimal or GraphQLBigInteger
          *
          * @param flag whether to include them
+         *
          * @return options
          */
         public Options includeExtendedScalarTypes(boolean flag) {
@@ -140,6 +145,7 @@ public Options includeExtendedScalarTypes(boolean flag) {
          * types do not use the default names.
          *
          * @param flag whether to force include the schema definition
+         *
          * @return options
          */
         public Options includeSchemaDefintion(boolean flag) {
@@ -151,6 +157,7 @@ public Options includeSchemaDefintion(boolean flag) {
          * make the printout noisy and having this flag would allow cleaner printout. On by default.
          *
          * @param flag whether to print directives
+         *
          * @return new instance of options
          */
         public Options includeDirectives(boolean flag) {
@@ -161,6 +168,7 @@ public Options includeDirectives(boolean flag) {
          * The comparator registry controls the printing order for registered {@code GraphQLType}s.
          *
          * @param comparatorRegistry The registry containing the {@code Comparator} and environment scoping rules.
+         *
          * @return options
          */
         public Options setComparators(SchemaPrinterComparatorRegistry comparatorRegistry) {
@@ -199,6 +207,7 @@ public SchemaPrinter(Options options) {
      * first to get the {@link graphql.language.Document} and then print that.
      *
      * @param schemaIDL the parsed schema IDL
+     *
      * @return the logical schema definition
      */
     public String print(Document schemaIDL) {
@@ -210,6 +219,7 @@ public String print(Document schemaIDL) {
      * This can print an in memory GraphQL schema back to a logical schema definition
      *
      * @param schema the schema in play
+     *
      * @return the logical schema definition
      */
     public String print(GraphQLSchema schema) {
@@ -436,10 +446,10 @@ private static String printAst(Object value, GraphQLInputType type) {
     }
 
     private TypePrinter<GraphQLSchema> schemaPrinter() {
-        return (out, type, visibility) -> {
-            GraphQLObjectType queryType = type.getQueryType();
-            GraphQLObjectType mutationType = type.getMutationType();
-            GraphQLObjectType subscriptionType = type.getSubscriptionType();
+        return (out, schema, visibility) -> {
+            GraphQLObjectType queryType = schema.getQueryType();
+            GraphQLObjectType mutationType = schema.getMutationType();
+            GraphQLObjectType subscriptionType = schema.getSubscriptionType();
 
             // when serializing a GraphQL schema using the type system language, a
             // schema definition should be omitted if only uses the default root type names.
@@ -470,9 +480,26 @@ private TypePrinter<GraphQLSchema> schemaPrinter() {
                 }
                 out.format("}\n\n");
             }
+
+            if (options.includeDirectives) {
+                out.format("%s", directiveDefinitions(getDirectives(schema)));
+            }
         };
     }
 
+    private List<GraphQLDirective> getDirectives(GraphQLSchema schema) {
+
+        // we don't print the standard directives that always ship with graphql-java
+        List<String> standardDirectives = Arrays.asList(
+                "skip",
+                "include",
+                "defer",
+                "deprecated");
+
+        Predicate<GraphQLDirective> standard = directive -> standardDirectives.contains(directive.getName());
+        return schema.getDirectives().stream().filter(standard.negate()).collect(Collectors.toList());
+    }
+
     String typeString(GraphQLType rawType) {
         return GraphQLTypeUtil.simplePrint(rawType);
     }
@@ -612,6 +639,50 @@ private String directiveString(GraphQLDirective directive) {
         return sb.toString();
     }
 
+    private String directiveDefinitions(List<GraphQLDirective> directives) {
+        StringBuilder sb = new StringBuilder();
+        for (GraphQLDirective directive : directives) {
+            sb.append(directiveDefinition(directive));
+            sb.append("\n\n");
+        }
+        return sb.toString();
+    }
+
+    private String directiveDefinition(GraphQLDirective directive) {
+        StringBuilder sb = new StringBuilder();
+
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+
+        printComments(pw, directive, "");
+
+        sb.append(sw.toString());
+
+        sb.append("directive @").append(directive.getName());
+
+        SchemaPrinterComparatorEnvironment environment = SchemaPrinterComparatorEnvironment.newEnvironment()
+                .parentType(GraphQLDirective.class)
+                .elementType(GraphQLArgument.class)
+                .build();
+        Comparator<? super GraphQLType> comparator = options.comparatorRegistry.getComparator(environment);
+
+        List<GraphQLArgument> args = directive.getArguments();
+        args = args
+                .stream()
+                .sorted(comparator)
+                .collect(toList());
+
+        sb.append(argsString(GraphQLDirective.class, args));
+
+        sb.append(" on ");
+
+        String locations = directive.validLocations().stream().map(Enum::name).collect(Collectors.joining(" | "));
+        sb.append(locations);
+
+        return sb.toString();
+    }
+
+
     @SuppressWarnings("unchecked")
     private <T> TypePrinter<T> printer(Class<?> clazz) {
         TypePrinter typePrinter = printers.computeIfAbsent(clazz, k -> {
@@ -732,13 +803,16 @@ private AstDescriptionAndComments getDescriptionAndComments(Object descriptionHo
         } else if (descriptionHolder instanceof GraphQLArgument) {
             GraphQLArgument type = (GraphQLArgument) descriptionHolder;
             return descriptionAndComments(type::getDescription, type::getDefinition, () -> type.getDefinition().getDescription());
+        } else if (descriptionHolder instanceof GraphQLDirective) {
+            GraphQLDirective type = (GraphQLDirective) descriptionHolder;
+            return descriptionAndComments(type::getDescription, () -> null, () -> null);
         } else {
             return Assert.assertShouldNeverHappen();
         }
     }
 
-    AstDescriptionAndComments descriptionAndComments(Supplier<String> stringSupplier, Supplier<Node> nodeSupplier, Supplier<Description> descriptionSupplier) {
-        String runtimeDesc = stringSupplier.get();
+    AstDescriptionAndComments descriptionAndComments(Supplier<String> runtimeDescriptionSupplier, Supplier<Node> nodeSupplier, Supplier<Description> descriptionSupplier) {
+        String runtimeDesc = runtimeDescriptionSupplier.get();
         Node node = nodeSupplier.get();
         Description description = null;
         List<Comment> comments = null;
diff --git a/src/test/groovy/graphql/schema/idl/SchemaPrinterTest.groovy b/src/test/groovy/graphql/schema/idl/SchemaPrinterTest.groovy
@@ -922,4 +922,48 @@ enum Enum {
 '''
     }
 
+
+    def "directives are printed as top level types when the includeDirectives flag is set"() {
+        def simpleIdlWithDirective = '''
+                directive @example on FIELD_DEFINITION
+                
+                directive @moreComplex(arg1 : String = "default", arg2 : Int) 
+                    on FIELD_DEFINITION | 
+                        INPUT_FIELD_DEFINITION
+               
+                type Query {
+                    fieldA : String @example @moreComplex(arg2 : 666)
+                }
+            '''
+        given:
+        def registry = new SchemaParser().parse(simpleIdlWithDirective)
+        def runtimeWiring = newRuntimeWiring().build()
+        def options = SchemaGenerator.Options.defaultOptions().enforceSchemaDirectives(true)
+        def schema = new SchemaGenerator().makeExecutableSchema(options, registry, runtimeWiring)
+
+        when:
+        def resultWithNoDirectives = new SchemaPrinter(defaultOptions().includeDirectives(false)).print(schema)
+
+        then:
+        resultWithNoDirectives == '''\
+type Query {
+  fieldA: String
+}
+'''
+
+        when:
+        def resultWithDirectives = new SchemaPrinter(defaultOptions().includeDirectives(true)).print(schema)
+
+        then:
+        resultWithDirectives == '''\
+directive @example on FIELD_DEFINITION
+
+directive @moreComplex(arg1: String = "default", arg2: Int) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION
+
+type Query {
+  fieldA: String @example @moreComplex(arg1 : "default", arg2 : 666)
+}
+'''
+    }
+
 }
