[RFC] Added support for repeatable directives

src/language/__tests__/schema-kitchen-sink.graphql

@@ -124,6 +124,10 @@ directive @include2(if: Boolean!) on
   | FRAGMENT_SPREAD
   | INLINE_FRAGMENT
 
+directive @myRepeatableDir(name: String!) repeatable on
+  | OBJECT
+  | INTERFACE
+
 extend schema @onSchema
 
 extend schema @onSchema {

src/language/__tests__/schema-parser-test.js

@@ -804,6 +804,108 @@ input Hello {
     );
   });
 
+  it('Directive definition', () => {
+    const body = 'directive @foo on OBJECT | INTERFACE';
+    const doc = parse(body);
+
+    expect(toJSONDeep(doc)).to.deep.equal({
+      kind: 'Document',
+      definitions: [
+        {
+          kind: 'DirectiveDefinition',
+          description: undefined,
+          name: {
+            kind: 'Name',
+            value: 'foo',
+            loc: {
+              start: 11,
+              end: 14,
+            },
+          },
+          arguments: [],
+          isRepeatable: false,
+          locations: [
+            {
+              kind: 'Name',
+              value: 'OBJECT',
+              loc: {
+                start: 18,
+                end: 24,
+              },
+            },
+            {
+              kind: 'Name',
+              value: 'INTERFACE',
+              loc: {
+                start: 27,
+                end: 36,
+              },
+            },
+          ],
+          loc: {
+            start: 0,
+            end: 36,
+          },
+        },
+      ],
+      loc: {
+        start: 0,
+        end: 36,
+      },
+    });
+  });
+
+  it('Repeatable directive definition', () => {
+    const body = 'directive @foo repeatable on OBJECT | INTERFACE';
+    const doc = parse(body);
+
+    expect(toJSONDeep(doc)).to.deep.equal({
+      kind: 'Document',
+      definitions: [
+        {
+          kind: 'DirectiveDefinition',
+          description: undefined,
+          name: {
+            kind: 'Name',
+            value: 'foo',
+            loc: {
+              start: 11,
+              end: 14,
+            },
+          },
+          arguments: [],
+          isRepeatable: true,
+          locations: [
+            {
+              kind: 'Name',
+              value: 'OBJECT',
+              loc: {
+                start: 29,
+                end: 35,
+              },
+            },
+            {
+              kind: 'Name',
+              value: 'INTERFACE',
+              loc: {
+                start: 38,
+                end: 47,
+              },
+            },
+          ],
+          loc: {
+            start: 0,
+            end: 47,
+          },
+        },
+      ],
+      loc: {
+        start: 0,
+        end: 47,
+      },
+    });
+  });
+
   it('Directive with incorrect locations', () => {
     expectSyntaxError(
       `

src/language/__tests__/schema-printer-test.js

@@ -164,6 +164,8 @@ describe('Printer: SDL document', () => {
 
       directive @include2(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
 
+      directive @myRepeatableDir(name: String!) repeatable on OBJECT | INTERFACE
+
       extend schema @onSchema
 
       extend schema @onSchema {

src/language/ast.js

@@ -508,6 +508,7 @@ export type DirectiveDefinitionNode = {
   +description?: StringValueNode,
   +name: NameNode,
   +arguments?: $ReadOnlyArray<InputValueDefinitionNode>,
+  +isRepeatable: boolean,
   +locations: $ReadOnlyArray<NameNode>,
 };
 

src/language/parser.js

@@ -1378,7 +1378,7 @@ function parseInputObjectTypeExtension(
 
 /**
  * DirectiveDefinition :
- *   - Description? directive @ Name ArgumentsDefinition? on DirectiveLocations
+ *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations
  */
 function parseDirectiveDefinition(lexer: Lexer<*>): DirectiveDefinitionNode {
   const start = lexer.token;
@@ -1387,13 +1387,15 @@ function parseDirectiveDefinition(lexer: Lexer<*>): DirectiveDefinitionNode {
   expect(lexer, TokenKind.AT);
   const name = parseName(lexer);
   const args = parseArgumentDefs(lexer);
+  const repeatable = expectOptionalKeyword(lexer, 'repeatable');
   expectKeyword(lexer, 'on');
   const locations = parseDirectiveLocations(lexer);
   return {
     kind: Kind.DIRECTIVE_DEFINITION,
     description,
     name,
     arguments: args,
+    isRepeatable: repeatable,
     locations,
     loc: loc(lexer, start),
   };
@@ -1529,6 +1531,21 @@ function expectKeyword(lexer: Lexer<*>, value: string): Token {
   );
 }
 
+/**
+ * If the next token is a keyword with the given value, return true after advancing
+ * the lexer. Otherwise, do not change the parser state and return false.
+ */
+function expectOptionalKeyword(lexer: Lexer<*>, value: string): boolean {
+  const token = lexer.token;
+  const match = token.kind === TokenKind.NAME && token.value === value;
+
+  if (match) {
+    lexer.advance();
+  }
+
+  return match;
+}
+
 /**
  * Helper function for creating an error when an unexpected lexed token
  * is encountered.

src/language/printer.js

@@ -181,12 +181,13 @@ const printDocASTReducer = {
   ),
 
   DirectiveDefinition: addDescription(
-    ({ name, arguments: args, locations }) =>
+    ({ name, arguments: args, locations, isRepeatable }) =>
       'directive @' +
       name +
       (args.every(arg => arg.indexOf('\n') === -1)
         ? wrap('(', join(args, ', '), ')')
         : wrap('(\n', indent(join(args, '\n')), '\n)')) +
+      (isRepeatable ? ' repeatable' : '') +
       ' on ' +
       join(locations, ' | '),
   ),

src/type/__tests__/introspection-test.js

@@ -700,6 +700,21 @@ describe('Introspection', () => {
                   isDeprecated: false,
                   deprecationReason: null,
                 },
+                {
+                  args: [],
+                  deprecationReason: null,
+                  isDeprecated: false,
+                  name: 'isRepeatable',
+                  type: {
+                    kind: 'NON_NULL',
+                    name: null,
+                    ofType: {
+                      kind: 'SCALAR',
+                      name: 'Boolean',
+                      ofType: null,
+                    },
+                  },
+                },
               ],
               inputFields: null,
               interfaces: [],
@@ -872,6 +887,81 @@ describe('Introspection', () => {
     });
   });
 
+  it('includes repeatable flag on directives', () => {
+    const EmptySchema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'QueryRoot',
+        fields: {
+          onlyField: { type: GraphQLString },
+        },
+      }),
+    });
+    const query = getIntrospectionQuery({
+      descriptions: false,
+      directiveRepeatableFlag: true,
+    });
+    const result = graphqlSync(EmptySchema, query);
+
+    expect((result.data: any).__schema.directives).to.deep.equal([
+      {
+        name: 'include',
+        locations: ['FIELD', 'FRAGMENT_SPREAD', 'INLINE_FRAGMENT'],
+        args: [
+          {
+            name: 'if',
+            type: {
+              kind: 'NON_NULL',
+              name: null,
+              ofType: {
+                kind: 'SCALAR',
+                name: 'Boolean',
+                ofType: null,
+              },
+            },
+            defaultValue: null,
+          },
+        ],
+        isRepeatable: false,
+      },
+      {
+        name: 'skip',
+        locations: ['FIELD', 'FRAGMENT_SPREAD', 'INLINE_FRAGMENT'],
+        args: [
+          {
+            name: 'if',
+            type: {
+              kind: 'NON_NULL',
+              name: null,
+              ofType: {
+                kind: 'SCALAR',
+                name: 'Boolean',
+                ofType: null,
+              },
+            },
+            defaultValue: null,
+          },
+        ],
+        isRepeatable: false,
+      },
+      {
+        name: 'deprecated',
+        locations: ['FIELD_DEFINITION', 'ENUM_VALUE'],
+        args: [
+          {
+            name: 'reason',
+            type: {
+              kind: 'SCALAR',
+              name: 'String',
+              ofType: null,
+            },
+            defaultValue: '"No longer supported"',
+          },
+        ],
+        isRepeatable: false,
+      },
+    ]);
+  });
+
   it('introspects on input object', () => {
     const TestInputObject = new GraphQLInputObjectType({
       name: 'TestInputObject',

src/type/directives.js

@@ -44,12 +44,16 @@ export class GraphQLDirective {
   locations: Array<DirectiveLocationEnum>;
   args: Array<GraphQLArgument>;
   astNode: ?DirectiveDefinitionNode;
+  isRepeatable: boolean;
 
   constructor(config: GraphQLDirectiveConfig): void {
     this.name = config.name;
     this.description = config.description;
     this.locations = config.locations;
     this.astNode = config.astNode;
+    this.isRepeatable =
+      config.isRepeatable == null ? false : config.isRepeatable;
+
     invariant(config.name, 'Directive must be named.');
     invariant(
       Array.isArray(config.locations),
@@ -92,6 +96,7 @@ export type GraphQLDirectiveConfig = {|
   locations: Array<DirectiveLocationEnum>,
   args?: ?GraphQLFieldConfigArgumentMap,
   astNode?: ?DirectiveDefinitionNode,
+  isRepeatable?: ?boolean,
 |};
 
 /**

src/type/introspection.js

@@ -98,6 +98,12 @@ export const __Directive = new GraphQLObjectType({
       type: GraphQLNonNull(GraphQLList(GraphQLNonNull(__InputValue))),
       resolve: directive => directive.args || [],
     },
+    isRepeatable: {
+      type: GraphQLNonNull(GraphQLBoolean),
+      description:
+        'Permits using the directive multiple times at the same location.',
+      resolve: directive => directive.isRepeatable,
+    },
   }),
 });
 

src/utilities/__tests__/buildASTSchema-test.js

@@ -91,6 +91,22 @@ describe('Schema Builder', () => {
     expect(output).to.equal(body);
   });
 
+  it('With repeatable directives', () => {
+    const body = dedent`
+      directive @foo(arg: Int) repeatable on FIELD
+
+      type Query {
+        str: String
+      }
+    `;
+
+    const output = cycleOutput(body);
+    expect(output).to.equal(body);
+
+    const schema = buildASTSchema(parse(body));
+    expect(schema.getDirective('foo').isRepeatable).to.equal(true);
+  });
+
   it('Supports descriptions', () => {
     const body = dedent`
       """This is a directive"""

src/utilities/__tests__/buildClientSchema-test.js

@@ -37,9 +37,19 @@ import {
 // query against the client-side schema, it should get a result identical to
 // what was returned by the server.
 function testSchema(serverSchema) {
-  const initialIntrospection = introspectionFromSchema(serverSchema);
+  const introspectionOptions = {
+    descriptions: true,
+    directiveRepeatableFlag: true,
+  };
+  const initialIntrospection = introspectionFromSchema(
+    serverSchema,
+    introspectionOptions,
+  );
   const clientSchema = buildClientSchema(initialIntrospection);
-  const secondIntrospection = introspectionFromSchema(clientSchema);
+  const secondIntrospection = introspectionFromSchema(
+    clientSchema,
+    introspectionOptions,
+  );
   expect(secondIntrospection).to.deep.equal(initialIntrospection);
 }
 
@@ -583,6 +593,12 @@ describe('Type System: build schema from introspection', () => {
           description: 'This is a custom directive',
           locations: ['FIELD'],
         }),
+        new GraphQLDirective({
+          name: 'customRepeatableDirective',
+          description: 'This is a custom repeatable directive',
+          isRepeatable: true,
+          locations: ['FIELD'],
+        }),
       ],
     });