Updates to allow printing of Schema Directives

CHANGELOG.md

@@ -17,6 +17,7 @@
 + Cannot return null for non-nullable field "parentType.fieldName".
 ```
 - Simplified Deferred implementation
+- Allow SchemaPrinter to print Schema Directives
 
 #### v0.13.5
 - Fix coroutine executor when using with promise (#486) 

src/Utils/SchemaPrinter.php

@@ -5,6 +5,9 @@
 namespace GraphQL\Utils;
 
 use GraphQL\Error\Error;
+use GraphQL\Language\AST\InterfaceTypeDefinitionNode;
+use GraphQL\Language\AST\NodeList;
+use GraphQL\Language\AST\ObjectTypeDefinitionNode;
 use GraphQL\Language\Printer;
 use GraphQL\Type\Definition\Directive;
 use GraphQL\Type\Definition\EnumType;
@@ -24,6 +27,7 @@
 use function count;
 use function explode;
 use function implode;
+use function iterator_to_array;
 use function ksort;
 use function mb_strlen;
 use function preg_match_all;
@@ -366,7 +370,7 @@ static function ($i) {
             : '';
 
         return self::printDescription($options, $type) .
-            sprintf("type %s%s {\n%s\n}", $type->name, $implementedInterfaces, self::printFields($options, $type));
+            sprintf("type %s%s%s {\n%s\n}", $type->name, $implementedInterfaces, self::printSchemaDirectives($type), self::printFields($options, $type));
     }
 
     /**
@@ -410,7 +414,7 @@ private static function printDeprecated($fieldOrEnumVal) : string
     private static function printInterface(InterfaceType $type, array $options) : string
     {
         return self::printDescription($options, $type) .
-            sprintf("interface %s {\n%s\n}", $type->name, self::printFields($options, $type));
+            sprintf("interface %s%s {\n%s\n}", $type->name, self::printSchemaDirectives($type), self::printFields($options, $type));
     }
 
     /**
@@ -487,4 +491,46 @@ public static function printIntrospectionSchema(Schema $schema, array $options =
             $options
         );
     }
+
+    public static function printSchemaDirectives(Type $type) : string
+    {
+        if ($type->astNode === null) {
+            return '';
+        }
+
+        if ($type->astNode instanceof ObjectTypeDefinitionNode) {
+            $directives = $type->astNode->directives;
+        } elseif ($type->astNode instanceof InterfaceTypeDefinitionNode) {
+            $directives = $type->astNode->directives;
+        } else {
+            return '';
+        }
+
+        if ($directives instanceof NodeList) {
+            $count      = $directives->count();
+            $directives = iterator_to_array($directives->getIterator());
+        } else {
+            $count = count($directives);
+        }
+
+        return $count > 0 ? (' ' . implode(
+            ' ',
+            array_map(
+                static function ($directive) : string {
+                    $directiveString = '@' . $directive->name->value;
+                    if ($directive->arguments->count() > 0) {
+                        $directiveString .= '(';
+                        foreach ($directive->arguments as $argument) {
+                            $directiveString .= $argument->name->value . ': ';
+                            $directiveString .= Printer::doPrint($argument->value);
+                        }
+                        $directiveString .= ')';
+                    }
+
+                    return $directiveString;
+                },
+                $directives
+            )
+        )) : '';
+    }
 }

tests/Utils/SchemaPrinterTest.php

@@ -1237,4 +1237,203 @@ enum __TypeKind {
 EOT;
         self::assertEquals($introspectionSchema, $output);
     }
+
+    public function testPrintSchemaDirectiveNoArgs()
+    {
+        $exceptedSdl = '
+directive @sd on OBJECT
+
+type Bar @sd {
+  foo: String
+}
+
+type Query {
+  foo: Bar
+}
+';
+
+        $schema = BuildSchema::build($exceptedSdl);
+        $actual = $this->printForTest($schema);
+
+        self::assertEquals($exceptedSdl, $actual);
+    }
+
+    public function testPrintSchemaDirectiveWithStringArgs()
+    {
+        $exceptedSdl = '
+directive @sd(field: String!) on OBJECT
+
+type Bar @sd(field: "String") {
+  foo: String
+}
+
+type Query {
+  foo: Bar
+}
+';
+
+        $schema = BuildSchema::build($exceptedSdl);
+        $actual = $this->printForTest($schema);
+
+        self::assertEquals($exceptedSdl, $actual);
+    }
+
+    public function testPrintSchemaDirectiveWithNumberArgs()
+    {
+        $exceptedSdl = '
+directive @sd(field: Int!) on OBJECT
+
+type Bar @sd(field: 1) {
+  foo: String
+}
+
+type Query {
+  foo: Bar
+}
+';
+
+        $schema = BuildSchema::build($exceptedSdl);
+        $actual = $this->printForTest($schema);
+
+        self::assertEquals($exceptedSdl, $actual);
+    }
+
+    public function testPrintSchemaDirectiveWithArrayArgs()
+    {
+        $exceptedSdl = '
+directive @sd(field: [Int!]) on OBJECT
+
+type Bar @sd(field: [1, 2, 3, 4]) {
+  foo: String
+}
+
+type Query {
+  foo: Bar
+}
+';
+
+        $schema = BuildSchema::build($exceptedSdl);
+        $actual = $this->printForTest($schema);
+
+        self::assertEquals($exceptedSdl, $actual);
+    }
+
+    public function testPrintSchemaDirectiveWithTypeArgs()
+    {
+        $exceptedSdl = '
+directive @sd(field: Foo) on OBJECT
+
+type Bar @sd(field: {bar: "test"}) {
+  foo: String
+}
+
+type Foo {
+  bar: String
+}
+
+type Query {
+  foo: Bar
+}
+';
+
+        $schema = BuildSchema::build($exceptedSdl);
+        $actual = $this->printForTest($schema);
+
+        self::assertEquals($exceptedSdl, $actual);
+    }
+
+    public function testPrintSchemaDirectiveOptionalArgs()
+    {
+        $exceptedSdl = '
+directive @sd(field: String) on OBJECT
+
+type Bar @sd(field: "Testing") {
+  foo: String
+}
+
+type Foo @sd {
+  bar: String
+}
+
+type Query {
+  foo: Bar
+  bar: Foo
+}
+';
+
+        $schema = BuildSchema::build($exceptedSdl);
+        $actual = $this->printForTest($schema);
+
+        self::assertEquals($exceptedSdl, $actual);
+    }
+
+    public function testPrintMultipleSchemaDirectives()
+    {
+        $exceptedSdl = '
+directive @sd(field: [Int!]) on OBJECT
+
+directive @sdb on OBJECT
+
+type Bar @sd(field: [1, 2, 3, 4]) @sdb {
+  foo: String
+}
+
+type Query {
+  foo: Bar
+}
+';
+
+        $schema = BuildSchema::build($exceptedSdl);
+        $actual = $this->printForTest($schema);
+
+        self::assertEquals($exceptedSdl, $actual);
+    }
+
+    public function testPrintSchemaDirectiveOnClassWithInterface()
+    {
+        $exceptedSdl = '
+directive @sd on OBJECT
+
+type Bar implements Foo @sd {
+  foo: String
+}
+
+interface Foo {
+  bar: String
+}
+
+type Query {
+  foo: Bar
+}
+';
+
+        $schema = BuildSchema::build($exceptedSdl);
+        $actual = $this->printForTest($schema);
+
+        self::assertEquals($exceptedSdl, $actual);
+    }
+
+    public function testPrintSchemaDirectiveOnInterface()
+    {
+        $exceptedSdl = '
+directive @sd on INTERFACE
+
+type Bar implements Foo {
+  foo: String
+}
+
+interface Foo @sd {
+  bar: String
+}
+
+type Query {
+  foo: Bar
+}
+';
+
+        $schema = BuildSchema::build($exceptedSdl);
+        $actual = $this->printForTest($schema);
+
+        self::assertEquals($exceptedSdl, $actual);
+    }
 }