Add option printDirective to printSchema

Resolves graphql#2020

I initially thought about implementing this as graphql#2020 (comment),
but really could not think of a good use case where
a directive should be printed in a modified way.

Thus, I went for a simpler signature:

```ts
shouldPrintDirective?: (directiveNode: DirectiveNode) => boolean
```

This is only a partial implementation for now, there are more possible
locations in a schema that can have a directive. Before I finish the
implementation, I would like to validate the direction is right.

Author: spawnia

src/execution/__tests__/directives-test.ts

@@ -174,6 +174,7 @@ describe('Execute: handles directives', () => {
         data: { a: 'a', b: 'b' },
       });
     });
+
     it('unless false includes inline fragment', () => {
       const result = executeTestQuery(`
         query {
@@ -188,6 +189,7 @@ describe('Execute: handles directives', () => {
         data: { a: 'a', b: 'b' },
       });
     });
+
     it('unless true includes inline fragment', () => {
       const result = executeTestQuery(`
         query {
@@ -234,6 +236,7 @@ describe('Execute: handles directives', () => {
         data: { a: 'a', b: 'b' },
       });
     });
+
     it('unless false includes anonymous inline fragment', () => {
       const result = executeTestQuery(`
         query Q {
@@ -248,6 +251,7 @@ describe('Execute: handles directives', () => {
         data: { a: 'a', b: 'b' },
       });
     });
+
     it('unless true includes anonymous inline fragment', () => {
       const result = executeTestQuery(`
         query {

src/utilities/__tests__/printSchema-test.ts

@@ -21,12 +21,19 @@ import {
 } from '../../type/definition';
 
 import { buildSchema } from '../buildASTSchema';
-import { printSchema, printIntrospectionSchema } from '../printSchema';
+import type { PrintSchemaOptions } from '../printSchema';
+import {
+  printSchema,
+  printIntrospectionSchema,
+} from '../printSchema';
 
-function expectPrintedSchema(schema: GraphQLSchema) {
-  const schemaText = printSchema(schema);
+function expectPrintedSchema(
+  schema: GraphQLSchema,
+  options?: PrintSchemaOptions,
+) {
+  const schemaText = printSchema(schema, options);
   // keep printSchema and buildSchema in sync
-  expect(printSchema(buildSchema(schemaText))).to.equal(schemaText);
+  expect(printSchema(buildSchema(schemaText), options)).to.equal(schemaText);
   return expect(schemaText);
 }
 
@@ -260,6 +267,16 @@ describe('Type System Printer', () => {
     `);
   });
 
+  it('Omits schema of common names', () => {
+    const schema = new GraphQLSchema({
+      query: new GraphQLObjectType({ name: 'Query', fields: {} }),
+    });
+
+    expectPrintedSchema(schema).to.equal(dedent`
+      type Query
+    `);
+  });
+
   it('Prints schema with description', () => {
     const schema = new GraphQLSchema({
       description: 'Schema description.',
@@ -318,6 +335,79 @@ describe('Type System Printer', () => {
     `);
   });
 
+  it('Prints schema with directives', () => {
+    const schema = buildSchema(`
+      schema @foo {
+        query: Query
+      }
+
+      directive @foo on SCHEMA
+
+      type Query
+    `);
+
+    expectPrintedSchema(schema, { shouldPrintDirective: () => true }).to
+      .equal(dedent`
+      schema @foo {
+        query: Query
+      }
+
+      directive @foo on SCHEMA
+
+      type Query
+    `);
+  });
+
+  it('Includes directives conditionally', () => {
+    const schema = buildSchema(`
+      schema @foo @bar {
+        query: Query
+      }
+
+      directive @foo on SCHEMA
+
+      directive @bar on SCHEMA
+
+      type Query
+    `);
+
+    expectPrintedSchema(schema, {
+      shouldPrintDirective: (directive) => directive.name.value === 'foo',
+    }).to.equal(dedent`
+      schema @foo {
+        query: Query
+      }
+
+      directive @foo on SCHEMA
+
+      directive @bar on SCHEMA
+
+      type Query
+    `);
+
+    expectPrintedSchema(schema, { shouldPrintDirective: () => true }).to
+      .equal(dedent`
+      schema @foo @bar {
+        query: Query
+      }
+
+      directive @foo on SCHEMA
+
+      directive @bar on SCHEMA
+
+      type Query
+    `);
+
+    expectPrintedSchema(schema, { shouldPrintDirective: () => false }).to
+      .equal(dedent`
+      directive @foo on SCHEMA
+
+      directive @bar on SCHEMA
+
+      type Query
+    `);
+  });
+
   it('Print Interface', () => {
     const FooType = new GraphQLInterfaceType({
       name: 'Foo',

src/utilities/printSchema.ts

@@ -34,18 +34,39 @@ import {
   isInputObjectType,
 } from '../type/definition';
 
+import type { DirectiveNode } from '../language/ast';
+
 import { astFromValue } from './astFromValue';
 
-export function printSchema(schema: GraphQLSchema): string {
+export interface PrintSchemaOptions {
+  /**
+   * Should the given directive node be included in the print output?
+   */
+  shouldPrintDirective?: (directiveNode: DirectiveNode) => boolean;
+}
+
+export function printSchema(
+  schema: GraphQLSchema,
+  options?: PrintSchemaOptions,
+): string {
   return printFilteredSchema(
     schema,
     (n) => !isSpecifiedDirective(n),
     isDefinedType,
+    options,
   );
 }
 
-export function printIntrospectionSchema(schema: GraphQLSchema): string {
-  return printFilteredSchema(schema, isSpecifiedDirective, isIntrospectionType);
+export function printIntrospectionSchema(
+  schema: GraphQLSchema,
+  options?: PrintSchemaOptions,
+): string {
+  return printFilteredSchema(
+    schema,
+    isSpecifiedDirective,
+    isIntrospectionType,
+    options,
+  );
 }
 
 function isDefinedType(type: GraphQLNamedType): boolean {
@@ -56,21 +77,41 @@ function printFilteredSchema(
   schema: GraphQLSchema,
   directiveFilter: (type: GraphQLDirective) => boolean,
   typeFilter: (type: GraphQLNamedType) => boolean,
+  options?: PrintSchemaOptions,
 ): string {
   const directives = schema.getDirectives().filter(directiveFilter);
   const types = Object.values(schema.getTypeMap()).filter(typeFilter);
 
   return [
-    printSchemaDefinition(schema),
+    printSchemaDefinition(schema, options),
     ...directives.map((directive) => printDirective(directive)),
     ...types.map((type) => printType(type)),
   ]
     .filter(Boolean)
     .join('\n\n');
 }
 
-function printSchemaDefinition(schema: GraphQLSchema): Maybe<string> {
-  if (schema.description == null && isSchemaOfCommonNames(schema)) {
+function printSchemaDefinition(
+  schema: GraphQLSchema,
+  options?: PrintSchemaOptions,
+): Maybe<string> {
+  const directives: Array<string> = [];
+  const printDirectives = options?.shouldPrintDirective;
+  if (printDirectives) {
+    [schema.astNode, ...schema.extensionASTNodes].forEach((node) => {
+      node?.directives?.forEach((directive) => {
+        if (printDirectives(directive)) {
+          directives.push(print(directive));
+        }
+      });
+    });
+  }
+
+  if (
+    schema.description == null &&
+    directives.length === 0 &&
+    isSchemaOfCommonNames(schema)
+  ) {
     return;
   }
 
@@ -91,7 +132,12 @@ function printSchemaDefinition(schema: GraphQLSchema): Maybe<string> {
     operationTypes.push(`  subscription: ${subscriptionType.name}`);
   }
 
-  return printDescription(schema) + `schema {\n${operationTypes.join('\n')}\n}`;
+  return (
+    printDescription(schema) +
+    ['schema', directives.join(' '), `{\n${operationTypes.join('\n')}\n}`]
+      .filter(Boolean)
+      .join(' ')
+  );
 }
 
 /**