Added partial support for repeatable directives (#1965)

Code is based on #1541 but without introspection changes
and without breaking change detection

src/__fixtures__/schema-kitchen-sink.graphql

@@ -142,6 +142,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

@@ -815,6 +815,78 @@ 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: [],
+          repeatable: 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: [],
+          repeatable: 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

@@ -160,6 +160,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>,
+  +repeatable: boolean,
   +locations: $ReadOnlyArray<NameNode>,
 };
 

src/language/parser.js

@@ -1358,7 +1358,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;
@@ -1367,13 +1367,15 @@ function parseDirectiveDefinition(lexer: Lexer<*>): DirectiveDefinitionNode {
   expectToken(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,
+    repeatable,
     locations,
     loc: loc(lexer, start),
   };

src/language/printer.js

@@ -184,12 +184,13 @@ const printDocASTReducer: any = {
   ),
 
   DirectiveDefinition: addDescription(
-    ({ name, arguments: args, locations }) =>
+    ({ name, arguments: args, repeatable, locations }) =>
       'directive @' +
       name +
       (hasMultilineItems(args)
         ? wrap('(\n', indent(join(args, '\n')), '\n)')
         : wrap('(', join(args, ', '), ')')) +
+      (repeatable ? ' repeatable' : '') +
       ' on ' +
       join(locations, ' | '),
   ),

src/type/__tests__/directive-test.js

@@ -22,6 +22,7 @@ describe('Type System: Directive', () => {
     expect(directive).to.deep.include({
       name: 'Foo',
       args: [],
+      isRepeatable: false,
       locations: ['QUERY'],
     });
   });
@@ -54,6 +55,22 @@ describe('Type System: Directive', () => {
           astNode: undefined,
         },
       ],
+      isRepeatable: false,
+      locations: ['QUERY'],
+    });
+  });
+
+  it('defines a repeatable directive', () => {
+    const directive = new GraphQLDirective({
+      name: 'Foo',
+      isRepeatable: true,
+      locations: ['QUERY'],
+    });
+
+    expect(directive).to.deep.include({
+      name: 'Foo',
+      args: [],
+      isRepeatable: true,
       locations: ['QUERY'],
     });
   });

src/type/directives.js

@@ -53,13 +53,16 @@ export class GraphQLDirective {
   name: string;
   description: ?string;
   locations: Array<DirectiveLocationEnum>;
+  isRepeatable: boolean;
   args: Array<GraphQLArgument>;
   astNode: ?DirectiveDefinitionNode;
 
   constructor(config: GraphQLDirectiveConfig): void {
     this.name = config.name;
     this.description = config.description;
+
     this.locations = config.locations;
+    this.isRepeatable = config.isRepeatable != null && config.isRepeatable;
     this.astNode = config.astNode;
     invariant(config.name, 'Directive must be named.');
     invariant(
@@ -89,12 +92,14 @@ export class GraphQLDirective {
   toConfig(): {|
     ...GraphQLDirectiveConfig,
     args: GraphQLFieldConfigArgumentMap,
+    isRepeatable: boolean,
   |} {
     return {
       name: this.name,
       description: this.description,
       locations: this.locations,
       args: argsToArgsConfig(this.args),
+      isRepeatable: this.isRepeatable,
       astNode: this.astNode,
     };
   }
@@ -109,6 +114,7 @@ export type GraphQLDirectiveConfig = {|
   description?: ?string,
   locations: Array<DirectiveLocationEnum>,
   args?: ?GraphQLFieldConfigArgumentMap,
+  isRepeatable?: ?boolean,
   astNode?: ?DirectiveDefinitionNode,
 |};
 

src/utilities/__tests__/buildASTSchema-test.js

@@ -121,6 +121,8 @@ describe('Schema Builder', () => {
   it('With directives', () => {
     const sdl = dedent`
       directive @foo(arg: Int) on FIELD
+
+      directive @repeatableFoo(arg: Int) repeatable on FIELD
     `;
     expect(cycleSDL(sdl)).to.equal(sdl);
   });

src/utilities/__tests__/extendSchema-test.js

@@ -107,6 +107,7 @@ const FooDirective = new GraphQLDirective({
   args: {
     input: { type: SomeInputType },
   },
+  isRepeatable: true,
   locations: [
     DirectiveLocation.SCHEMA,
     DirectiveLocation.SCALAR,
@@ -448,7 +449,7 @@ describe('extendSchema', () => {
         interfaceField: String
       }
 
-      directive @test(arg: Int) on FIELD | SCALAR
+      directive @test(arg: Int) repeatable on FIELD | SCALAR
     `);
     const extendedTwiceSchema = extendSchema(extendedSchema, ast);
 
@@ -1091,7 +1092,7 @@ describe('extendSchema', () => {
 
   it('may extend directives with new complex directive', () => {
     const extendedSchema = extendTestSchema(`
-      directive @profile(enable: Boolean! tag: String) on QUERY | FIELD
+      directive @profile(enable: Boolean! tag: String) repeatable on QUERY | FIELD
     `);
 
     const extendedDirective = assertDirective(

src/utilities/__tests__/schemaPrinter-test.js

@@ -461,15 +461,30 @@ describe('Type System Printer', () => {
   });
 
   it('Prints custom directives', () => {
-    const CustomDirective = new GraphQLDirective({
-      name: 'customDirective',
+    const SimpleDirective = new GraphQLDirective({
+      name: 'simpleDirective',
       locations: [DirectiveLocation.FIELD],
     });
+    const ComplexDirective = new GraphQLDirective({
+      name: 'complexDirective',
+      description: 'Complex Directive',
+      args: {
+        stringArg: { type: GraphQLString },
+        intArg: { type: GraphQLInt, defaultValue: -1 },
+      },
+      isRepeatable: true,
+      locations: [DirectiveLocation.FIELD, DirectiveLocation.QUERY],
+    });
 
-    const Schema = new GraphQLSchema({ directives: [CustomDirective] });
+    const Schema = new GraphQLSchema({
+      directives: [SimpleDirective, ComplexDirective],
+    });
     const output = printForTest(Schema);
     expect(output).to.equal(dedent`
-      directive @customDirective on FIELD
+      directive @simpleDirective on FIELD
+
+      """Complex Directive"""
+      directive @complexDirective(stringArg: String, intArg: Int = -1) repeatable on FIELD | QUERY
     `);
   });
 

src/utilities/buildASTSchema.js

@@ -242,6 +242,7 @@ export class ASTDefinitionBuilder {
       name: directive.name.value,
       description: getDescription(directive, this._options),
       locations,
+      isRepeatable: directive.repeatable,
       args: keyByNameNode(directive.arguments || [], arg => this.buildArg(arg)),
       astNode: directive,
     });

src/utilities/schemaPrinter.js

@@ -296,6 +296,7 @@ function printDirective(directive, options) {
     'directive @' +
     directive.name +
     printArgs(options, directive.args) +
+    (directive.isRepeatable ? ' repeatable' : '') +
     ' on ' +
     directive.locations.join(' | ')
   );