Add directives to FieldDefinition

Author: igorcanadi

src/language/__tests__/kitchen-sink.graphql

@@ -55,3 +55,7 @@ fragment frag on Friend {
   unnamed(truthy: true, falsey: false),
   query
 }
+
+extend type User {
+  name: String @iAmDirective(default: "Foo")
+}

src/language/__tests__/printer.js

@@ -97,6 +97,10 @@ fragment frag on Friend {
   unnamed(truthy: true, falsey: false)
   query
 }
+
+extend type User {
+  name: String @iAmDirective(default: "Foo")
+}
 `);
 
   });

src/language/__tests__/schema-parser.js

@@ -42,16 +42,30 @@ function nameNode(name, loc) {
   };
 }
 
+function directiveNode(name, args, loc) {
+  return {
+    kind: 'Directive',
+    name,
+    arguments: args,
+    loc
+  };
+}
+
 function fieldNode(name, type, loc) {
   return fieldNodeWithArgs(name, type, [], loc);
 }
 
 function fieldNodeWithArgs(name, type, args, loc) {
+  return fieldNodeWithArgsAndDirectives(name, type, args, [], loc);
+}
+
+function fieldNodeWithArgsAndDirectives(name, type, args, directives, loc) {
   return {
     kind: 'FieldDefinition',
     name,
     arguments: args,
     type,
+    directives,
     loc,
   };
 }
@@ -541,4 +555,83 @@ input Hello {
     expect(() => parse(body)).to.throw('Error');
   });
 
+  it('Simple fields with directives', () => {
+    var body = `
+type Hello {
+  world: String @mock(value: "hello")
+  hello: Int @mock(value: 2) @ignore
+}`;
+    var doc = parse(body);
+    var loc = createLocFn(body);
+    var expected = {
+      kind: 'Document',
+      definitions: [
+        {
+          kind: 'ObjectTypeDefinition',
+          name: nameNode('Hello', loc(6, 11)),
+          interfaces: [],
+          fields: [
+            fieldNodeWithArgsAndDirectives(
+              nameNode('world', loc(16, 21)),
+              typeNode('String', loc(23, 29)),
+              [],
+              [
+                directiveNode(
+                  nameNode('mock', loc(31, 35)),
+                  [
+                    {
+                      kind: 'Argument',
+                      name: nameNode('value', loc(36, 41)),
+                      value: {
+                        kind: 'StringValue',
+                        value: 'hello',
+                        loc: loc(43, 50),
+                      },
+                      loc: loc(36, 50),
+                    }
+                  ],
+                  loc(30, 51)
+                ),
+              ],
+              loc(16, 51)
+            ),
+            fieldNodeWithArgsAndDirectives(
+              nameNode('hello', loc(54, 59)),
+              typeNode('Int', loc(61, 64)),
+              [],
+              [
+                directiveNode(
+                  nameNode('mock', loc(66, 70)),
+                  [
+                    {
+                      kind: 'Argument',
+                      name: nameNode('value', loc(71, 76)),
+                      value: {
+                        kind: 'IntValue',
+                        value: '2',
+                        loc: loc(78, 79),
+                      },
+                      loc: loc(71, 79),
+                    }
+                  ],
+                  loc(65, 80)
+                ),
+                directiveNode(
+                  nameNode('ignore', loc(82, 88)),
+                  [],
+                  loc(81, 88)
+                ),
+              ],
+              loc(54, 88)
+            )
+          ],
+          loc: loc(1, 90),
+        }
+      ],
+      loc: loc(1, 90),
+    };
+    expect(printJson(doc)).to.equal(printJson(expected));
+  });
+
+
 });

src/language/__tests__/visitor.js

@@ -547,7 +547,32 @@ describe('Visitor', () => {
       [ 'leave', 'Field', 1, undefined ],
       [ 'leave', 'SelectionSet', 'selectionSet', 'OperationDefinition' ],
       [ 'leave', 'OperationDefinition', 4, undefined ],
-      [ 'leave', 'Document', undefined, undefined ] ]);
+      [ 'enter', 'TypeExtensionDefinition', 5, undefined ],
+      [ 'enter', 'ObjectTypeDefinition', 'definition', 'TypeExtensionDefinition' ],
+      [ 'enter', 'Name', 'name', 'ObjectTypeDefinition' ],
+      [ 'leave', 'Name', 'name', 'ObjectTypeDefinition' ],
+      [ 'enter', 'FieldDefinition', 0, undefined ],
+      [ 'enter', 'Name', 'name', 'FieldDefinition' ],
+      [ 'leave', 'Name', 'name', 'FieldDefinition' ],
+      [ 'enter', 'NamedType', 'type', 'FieldDefinition' ],
+      [ 'enter', 'Name', 'name', 'NamedType' ],
+      [ 'leave', 'Name', 'name', 'NamedType' ],
+      [ 'leave', 'NamedType', 'type', 'FieldDefinition' ],
+      [ 'enter', 'Directive', 0, undefined ],
+      [ 'enter', 'Name', 'name', 'Directive' ],
+      [ 'leave', 'Name', 'name', 'Directive' ],
+      [ 'enter', 'Argument', 0, undefined ],
+      [ 'enter', 'Name', 'name', 'Argument' ],
+      [ 'leave', 'Name', 'name', 'Argument' ],
+      [ 'enter', 'StringValue', 'value', 'Argument' ],
+      [ 'leave', 'StringValue', 'value', 'Argument' ],
+      [ 'leave', 'Argument', 0, undefined ],
+      [ 'leave', 'Directive', 0, undefined ],
+      [ 'leave', 'FieldDefinition', 0, undefined ],
+      [ 'leave', 'ObjectTypeDefinition', 'definition', 'TypeExtensionDefinition' ],
+      [ 'leave', 'TypeExtensionDefinition', 5, undefined ],
+      [ 'leave', 'Document', undefined, undefined ],
+    ]);
   });
 
   describe('visitInParallel', () => {

src/language/parser.js

@@ -709,19 +709,21 @@ function parseImplementsInterfaces(parser): Array<NamedType> {
 }
 
 /**
- * FieldDefinition : Name ArgumentsDefinition? : Type
+ * FieldDefinition : Name ArgumentsDefinition? : Type Directives?
  */
 function parseFieldDefinition(parser): FieldDefinition {
   var start = parser.token.start;
   var name = parseName(parser);
   var args = parseArgumentDefs(parser);
   expect(parser, TokenKind.COLON);
   var type = parseType(parser);
+  var directives = parseDirectives(parser);
   return {
     kind: FIELD_DEFINITION,
     name,
     arguments: args,
     type,
+    directives,
     loc: loc(parser, start),
   };
 }

src/language/printer.js

@@ -96,8 +96,9 @@ var printDocASTReducer = {
     wrap('implements ', join(interfaces, ', '), ' ') +
     block(fields),
 
-  FieldDefinition: ({ name, arguments: args, type }) =>
-    name + wrap('(', join(args, ', '), ')') + ': ' + type,
+  FieldDefinition: ({ name, arguments: args, type, directives }) =>
+    name + wrap('(', join(args, ', '), ')') + ': ' +
+    type + wrap(' ', join(directives, ' ')),
 
   InputValueDefinition: ({ name, type, defaultValue }) =>
     name + ': ' + type + wrap(' = ', defaultValue),

src/language/visitor.js

@@ -39,7 +39,7 @@ export var QueryDocumentKeys = {
   NonNullType: [ 'type' ],
 
   ObjectTypeDefinition: [ 'name', 'interfaces', 'fields' ],
-  FieldDefinition: [ 'name', 'arguments', 'type' ],
+  FieldDefinition: [ 'name', 'arguments', 'type', 'directives' ],
   InputValueDefinition: [ 'name', 'type', 'defaultValue' ],
   InterfaceTypeDefinition: [ 'name', 'fields' ],
   UnionTypeDefinition: [ 'name', 'types' ],