Make 'buildASTSchema' assign 'astNode' to types

Author: IvanGoncharov

src/utilities/__tests__/buildASTSchema-test.js

@@ -9,7 +9,7 @@
 
 import { expect } from 'chai';
 import { describe, it } from 'mocha';
-import { parse } from '../../language';
+import { parse, print } from '../../language';
 import { printSchema } from '../schemaPrinter';
 import { buildASTSchema, buildSchema } from '../buildASTSchema';
 import {
@@ -558,6 +558,78 @@ type Query {
     expect(rootFields.field2.isDeprecated).to.equal(true);
     expect(rootFields.field2.deprecationReason).to.equal('Because I said so');
   });
+
+  it('Correctly assign AST nodes', () => {
+    const schema = buildSchema(`
+      schema {
+        query: Query
+      }
+
+      type Query {
+        testField(testArg: TestInput): TestUnion
+      }
+
+      input TestInput {
+        testInputField: TestEnum
+      }
+
+      enum TestEnum {
+        TEST_VALUE
+      }
+
+      union TestUnion = TestType
+
+      interface TestInterface {
+        interfaceField: String
+      }
+
+      type TestType implements TestInterface {
+        interfaceField: String
+      }
+
+      directive @test(arg: Int) on FIELD
+    `);
+    const query = schema.getType('Query');
+    const testInput = schema.getType('TestInput');
+    const testEnum = schema.getType('TestEnum');
+    const testUnion = schema.getType('TestUnion');
+    const testInterface = schema.getType('TestInterface');
+    const testType = schema.getType('TestType');
+    const testDirective = schema.getDirective('test');
+
+    const restoredIDL = printSchema(buildSchema(
+      print(schema.astNode) + '\n' +
+      print(query.astNode) + '\n' +
+      print(testInput.astNode) + '\n' +
+      print(testEnum.astNode) + '\n' +
+      print(testUnion.astNode) + '\n' +
+      print(testInterface.astNode) + '\n' +
+      print(testType.astNode) + '\n' +
+      print(testDirective.astNode)
+    ));
+    expect(restoredIDL).to.be.equal(printSchema(schema));
+
+    const testField = query.getFields().testField;
+    expect(print(testField.astNode)).to.equal(
+      'testField(testArg: TestInput): TestUnion'
+    );
+    expect(print(testField.args[0].astNode)).to.equal(
+      'testArg: TestInput'
+    );
+    expect(print(testInput.getFields().testInputField.astNode)).to.equal(
+      'testInputField: TestEnum'
+    );
+    expect(print(testEnum.getValue('TEST_VALUE').astNode)).to.equal(
+      'TEST_VALUE'
+    );
+    expect(print(testInterface.getFields().interfaceField.astNode)).to.equal(
+      'interfaceField: String'
+    );
+    expect(print(testType.getFields().interfaceField.astNode)).to.equal(
+      'interfaceField: String'
+    );
+    expect(print(testDirective.args[0].astNode)).to.equal('arg: Int');
+  });
 });
 
 describe('Failures', () => {

src/utilities/buildASTSchema.js

@@ -272,6 +272,7 @@ export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
       null,
     types,
     directives,
+    astNode: schemaDef,
   });
 
   function getDirective(
@@ -284,6 +285,7 @@ export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
         node => ((node.value: any): DirectiveLocationEnum)
       ),
       args: directiveNode.arguments && makeInputValues(directiveNode.arguments),
+      astNode: directiveNode,
     });
   }
 
@@ -368,6 +370,7 @@ export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
       description: getDescription(def),
       fields: () => makeFieldDefMap(def),
       interfaces: () => makeImplementedInterfaces(def),
+      astNode: def,
     });
   }
 
@@ -381,7 +384,8 @@ export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
         type: produceOutputType(field.type),
         description: getDescription(field),
         args: makeInputValues(field.arguments),
-        deprecationReason: getDeprecationReason(field.directives)
+        deprecationReason: getDeprecationReason(field.directives),
+        astNode: field,
       })
     );
   }
@@ -400,7 +404,8 @@ export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
         return {
           type,
           description: getDescription(value),
-          defaultValue: valueFromAST(value.defaultValue, type)
+          defaultValue: valueFromAST(value.defaultValue, type),
+          astNode: value,
         };
       }
     );
@@ -412,6 +417,7 @@ export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
       name: typeName,
       description: getDescription(def),
       fields: () => makeFieldDefMap(def),
+      astNode: def,
       resolveType: cannotExecuteSchema,
     });
   }
@@ -425,9 +431,11 @@ export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
         enumValue => enumValue.name.value,
         enumValue => ({
           description: getDescription(enumValue),
-          deprecationReason: getDeprecationReason(enumValue.directives)
+          deprecationReason: getDeprecationReason(enumValue.directives),
+          astNode: enumValue
         })
       ),
+      astNode: def,
     });
 
     return enumType;
@@ -439,13 +447,15 @@ export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
       description: getDescription(def),
       types: def.types.map(t => produceObjectType(t)),
       resolveType: cannotExecuteSchema,
+      astNode: def,
     });
   }
 
   function makeScalarDef(def: ScalarTypeDefinitionNode) {
     return new GraphQLScalarType({
       name: def.name.value,
       description: getDescription(def),
+      astNode: def,
       serialize: () => null,
       // Note: validation calls the parse functions to determine if a
       // literal value is correct. Returning null would cause use of custom
@@ -461,6 +471,7 @@ export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
       name: def.name.value,
       description: getDescription(def),
       fields: () => makeInputValues(def.fields),
+      astNode: def,
     });
   }
 }