Add coordinate field to schema element definitions

* Defines a `GraphQLSchemaElement` base class which defines a `.coordinate` property and `toString`/`toJSON` methods.
* Adds base class to types, fields, arguments, input fields, enum values, and directives.
* Uses this in validation error printing string templates.

Author: leebyron

src/index.ts

@@ -32,14 +32,17 @@ export { graphql, graphqlSync } from './graphql';
 /** Create and operate on GraphQL type definitions and schema. */
 export {
   /** Definitions */
-  GraphQLSchema,
-  GraphQLDirective,
+  GraphQLSchemaElement,
   GraphQLScalarType,
   GraphQLObjectType,
   GraphQLInterfaceType,
   GraphQLUnionType,
   GraphQLEnumType,
   GraphQLInputObjectType,
+  GraphQLField,
+  GraphQLArgument,
+  GraphQLEnumValue,
+  GraphQLInputField,
   GraphQLList,
   GraphQLNonNull,
   /** Standard GraphQL Scalars */
@@ -144,23 +147,19 @@ export type {
   GraphQLSchemaExtensions,
   GraphQLDirectiveConfig,
   GraphQLDirectiveExtensions,
-  GraphQLArgument,
   GraphQLArgumentConfig,
   GraphQLArgumentExtensions,
   GraphQLEnumTypeConfig,
   GraphQLEnumTypeExtensions,
-  GraphQLEnumValue,
   GraphQLEnumValueConfig,
   GraphQLEnumValueConfigMap,
   GraphQLEnumValueExtensions,
-  GraphQLField,
   GraphQLFieldConfig,
   GraphQLFieldConfigArgumentMap,
   GraphQLFieldConfigMap,
   GraphQLFieldExtensions,
   GraphQLFieldMap,
   GraphQLFieldResolver,
-  GraphQLInputField,
   GraphQLInputFieldConfig,
   GraphQLInputFieldConfigMap,
   GraphQLInputFieldExtensions,

src/type/__tests__/definition-test.ts

@@ -165,11 +165,11 @@ describe('Type System: Objects', () => {
       },
     };
     const testObject1 = new GraphQLObjectType({
-      name: 'Test1',
+      name: 'Test',
       fields: outputFields,
     });
     const testObject2 = new GraphQLObjectType({
-      name: 'Test2',
+      name: 'Test',
       fields: outputFields,
     });
 
@@ -191,11 +191,11 @@ describe('Type System: Objects', () => {
       field2: { type: ScalarType },
     };
     const testInputObject1 = new GraphQLInputObjectType({
-      name: 'Test1',
+      name: 'Test',
       fields: inputFields,
     });
     const testInputObject2 = new GraphQLInputObjectType({
-      name: 'Test2',
+      name: 'Test',
       fields: inputFields,
     });
 
@@ -243,6 +243,7 @@ describe('Type System: Objects', () => {
     });
     expect(objType.getFields()).to.deep.equal({
       f: {
+        coordinate: 'SomeObject.f',
         name: 'f',
         description: undefined,
         type: ScalarType,
@@ -270,11 +271,13 @@ describe('Type System: Objects', () => {
     });
     expect(objType.getFields()).to.deep.equal({
       f: {
+        coordinate: 'SomeObject.f',
         name: 'f',
         description: undefined,
         type: ScalarType,
         args: [
           {
+            coordinate: 'SomeObject.f(arg:)',
             name: 'arg',
             description: undefined,
             type: ScalarType,
@@ -624,6 +627,7 @@ describe('Type System: Enums', () => {
 
     expect(EnumTypeWithNullishValue.getValues()).to.deep.equal([
       {
+        coordinate: 'EnumWithNullishValue.NULL',
         name: 'NULL',
         description: undefined,
         value: null,
@@ -632,6 +636,7 @@ describe('Type System: Enums', () => {
         astNode: undefined,
       },
       {
+        coordinate: 'EnumWithNullishValue.NAN',
         name: 'NAN',
         description: undefined,
         value: NaN,
@@ -640,6 +645,7 @@ describe('Type System: Enums', () => {
         astNode: undefined,
       },
       {
+        coordinate: 'EnumWithNullishValue.NO_CUSTOM_VALUE',
         name: 'NO_CUSTOM_VALUE',
         description: undefined,
         value: 'NO_CUSTOM_VALUE',
@@ -730,6 +736,7 @@ describe('Type System: Input Objects', () => {
       });
       expect(inputObjType.getFields()).to.deep.equal({
         f: {
+          coordinate: 'SomeInputObject.f',
           name: 'f',
           description: undefined,
           type: ScalarType,
@@ -750,6 +757,7 @@ describe('Type System: Input Objects', () => {
       });
       expect(inputObjType.getFields()).to.deep.equal({
         f: {
+          coordinate: 'SomeInputObject.f',
           name: 'f',
           description: undefined,
           type: ScalarType,

src/type/__tests__/directive-test.ts

@@ -33,6 +33,7 @@ describe('Type System: Directive', () => {
       name: 'Foo',
       args: [
         {
+          coordinate: '@Foo(foo:)',
           name: 'foo',
           description: undefined,
           type: GraphQLString,
@@ -42,6 +43,7 @@ describe('Type System: Directive', () => {
           astNode: undefined,
         },
         {
+          coordinate: '@Foo(bar:)',
           name: 'bar',
           description: undefined,
           type: GraphQLInt,

src/type/__tests__/enumType-test.ts

@@ -342,6 +342,7 @@ describe('Type System: Enum Values', () => {
     const values = ComplexEnum.getValues();
     expect(values).to.have.deep.ordered.members([
       {
+        coordinate: 'Complex.ONE',
         name: 'ONE',
         description: undefined,
         value: Complex1,
@@ -350,6 +351,7 @@ describe('Type System: Enum Values', () => {
         astNode: undefined,
       },
       {
+        coordinate: 'Complex.TWO',
         name: 'TWO',
         description: undefined,
         value: Complex2,

src/type/__tests__/introspection-test.ts

@@ -1480,7 +1480,7 @@ describe('Introspection', () => {
       errors: [
         {
           message:
-            'Field "__type" argument "name" of type "String!" is required, but it was not provided.',
+            'Argument <meta>.__type(name:) of type "String!" is required, but it was not provided.',
           locations: [{ line: 3, column: 9 }],
         },
       ],

src/type/__tests__/predicate-test.ts

@@ -1,11 +1,7 @@
 import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
-import type {
-  GraphQLArgument,
-  GraphQLInputField,
-  GraphQLInputType,
-} from '../definition';
+import type { GraphQLInputType } from '../definition';
 import {
   GraphQLDirective,
   GraphQLSkipDirective,
@@ -29,8 +25,10 @@ import {
   GraphQLScalarType,
   GraphQLEnumType,
   GraphQLInputObjectType,
+  GraphQLInputField,
   GraphQLInterfaceType,
   GraphQLObjectType,
+  GraphQLArgument,
   GraphQLUnionType,
   isType,
   isScalarType,
@@ -567,15 +565,7 @@ describe('Type predicates', () => {
       type: GraphQLInputType;
       defaultValue?: unknown;
     }): GraphQLArgument {
-      return {
-        name: 'someArg',
-        type: config.type,
-        description: undefined,
-        defaultValue: config.defaultValue,
-        deprecationReason: null,
-        extensions: undefined,
-        astNode: undefined,
-      };
+      return new GraphQLArgument('SomeType.someField', 'someArg', config);
     }
 
     it('returns true for required arguments', () => {
@@ -615,15 +605,7 @@ describe('Type predicates', () => {
       type: GraphQLInputType;
       defaultValue?: unknown;
     }): GraphQLInputField {
-      return {
-        name: 'someInputField',
-        type: config.type,
-        description: undefined,
-        defaultValue: config.defaultValue,
-        deprecationReason: null,
-        extensions: undefined,
-        astNode: undefined,
-      };
+      return new GraphQLInputField('SomeType', 'someInputField', config);
     }
 
     it('returns true for required input field', () => {

src/type/__tests__/validation-test.ts

@@ -1974,7 +1974,7 @@ describe('Objects must adhere to Interface they implement', () => {
     expect(validateSchema(schema)).to.deep.equal([
       {
         message:
-          'Object field AnotherObject.field includes required argument requiredArg that is missing from the Interface field AnotherInterface.field.',
+          'Argument AnotherObject.field(requiredArg:) must not be required type String! if not provided by the Interface field AnotherInterface.field.',
         locations: [
           { line: 13, column: 11 },
           { line: 7, column: 9 },
@@ -2169,11 +2169,11 @@ describe('Interfaces must adhere to Interface they implement', () => {
       }
 
       interface ParentInterface {
-        field(input: String): String
+        field(input: String!): String
       }
 
       interface ChildInterface implements ParentInterface {
-        field(input: String, anotherInput: String): String
+        field(input: String!, anotherInput: String): String
       }
     `);
     expect(validateSchema(schema)).to.deep.equal([]);
@@ -2431,7 +2431,7 @@ describe('Interfaces must adhere to Interface they implement', () => {
     expect(validateSchema(schema)).to.deep.equal([
       {
         message:
-          'Object field ChildInterface.field includes required argument requiredArg that is missing from the Interface field ParentInterface.field.',
+          'Argument ChildInterface.field(requiredArg:) must not be required type String! if not provided by the Interface field ParentInterface.field.',
         locations: [
           { line: 13, column: 11 },
           { line: 7, column: 9 },