Updates to schema coordinates (#3044)

src/language/__tests__/parser-test.ts

@@ -690,25 +690,21 @@ describe('Parser', () => {
     it('parses Name', () => {
       const result = parseSchemaCoordinate('MyType');
       expectJSON(result).toDeepEqual({
-        kind: Kind.SCHEMA_COORDINATE,
+        kind: Kind.TYPE_COORDINATE,
         loc: { start: 0, end: 6 },
-        ofDirective: false,
         name: {
           kind: Kind.NAME,
           loc: { start: 0, end: 6 },
           value: 'MyType',
         },
-        memberName: undefined,
-        argumentName: undefined,
       });
     });
 
     it('parses Name . Name', () => {
       const result = parseSchemaCoordinate('MyType.field');
       expectJSON(result).toDeepEqual({
-        kind: Kind.SCHEMA_COORDINATE,
+        kind: Kind.MEMBER_COORDINATE,
         loc: { start: 0, end: 12 },
-        ofDirective: false,
         name: {
           kind: Kind.NAME,
           loc: { start: 0, end: 6 },
@@ -719,7 +715,6 @@ describe('Parser', () => {
           loc: { start: 7, end: 12 },
           value: 'field',
         },
-        argumentName: undefined,
       });
     });
 
@@ -735,15 +730,14 @@ describe('Parser', () => {
     it('parses Name . Name ( Name : )', () => {
       const result = parseSchemaCoordinate('MyType.field(arg:)');
       expectJSON(result).toDeepEqual({
-        kind: Kind.SCHEMA_COORDINATE,
+        kind: Kind.ARGUMENT_COORDINATE,
         loc: { start: 0, end: 18 },
-        ofDirective: false,
         name: {
           kind: Kind.NAME,
           loc: { start: 0, end: 6 },
           value: 'MyType',
         },
-        memberName: {
+        fieldName: {
           kind: Kind.NAME,
           loc: { start: 7, end: 12 },
           value: 'field',
@@ -768,31 +762,26 @@ describe('Parser', () => {
     it('parses @ Name', () => {
       const result = parseSchemaCoordinate('@myDirective');
       expectJSON(result).toDeepEqual({
-        kind: Kind.SCHEMA_COORDINATE,
+        kind: Kind.DIRECTIVE_COORDINATE,
         loc: { start: 0, end: 12 },
-        ofDirective: true,
         name: {
           kind: Kind.NAME,
           loc: { start: 1, end: 12 },
           value: 'myDirective',
         },
-        memberName: undefined,
-        argumentName: undefined,
       });
     });
 
     it('parses @ Name ( Name : )', () => {
       const result = parseSchemaCoordinate('@myDirective(arg:)');
       expectJSON(result).toDeepEqual({
-        kind: Kind.SCHEMA_COORDINATE,
+        kind: Kind.DIRECTIVE_ARGUMENT_COORDINATE,
         loc: { start: 0, end: 18 },
-        ofDirective: true,
         name: {
           kind: Kind.NAME,
           loc: { start: 1, end: 12 },
           value: 'myDirective',
         },
-        memberName: undefined,
         argumentName: {
           kind: Kind.NAME,
           loc: { start: 13, end: 16 },

src/language/__tests__/predicates-test.ts

@@ -145,7 +145,11 @@ describe('AST node predicates', () => {
 
   it('isSchemaCoordinateNode', () => {
     expect(filterNodes(isSchemaCoordinateNode)).to.deep.equal([
-      'SchemaCoordinate',
+      'ArgumentCoordinate',
+      'DirectiveArgumentCoordinate',
+      'DirectiveCoordinate',
+      'MemberCoordinate',
+      'TypeCoordinate',
     ]);
   });
 });

src/language/ast.ts

@@ -182,7 +182,11 @@ export type ASTNode =
   | UnionTypeExtensionNode
   | EnumTypeExtensionNode
   | InputObjectTypeExtensionNode
-  | SchemaCoordinateNode;
+  | TypeCoordinateNode
+  | MemberCoordinateNode
+  | ArgumentCoordinateNode
+  | DirectiveCoordinateNode
+  | DirectiveArgumentCoordinateNode;
 
 /**
  * Utility type listing all nodes indexed by their kind.
@@ -288,7 +292,13 @@ export const QueryDocumentKeys: {
   UnionTypeExtension: ['name', 'directives', 'types'],
   EnumTypeExtension: ['name', 'directives', 'values'],
   InputObjectTypeExtension: ['name', 'directives', 'fields'],
-  SchemaCoordinate: ['name', 'memberName', 'argumentName'],
+
+  // Schema Coordinates
+  TypeCoordinate: ['name'],
+  MemberCoordinate: ['name', 'memberName'],
+  ArgumentCoordinate: ['name', 'fieldName', 'argumentName'],
+  DirectiveCoordinate: ['name'],
+  DirectiveArgumentCoordinate: ['name', 'argumentName'],
 };
 
 const kindValues = new Set<string>(Object.keys(QueryDocumentKeys));
@@ -765,13 +775,45 @@ export interface InputObjectTypeExtensionNode {
   readonly fields?: ReadonlyArray<InputValueDefinitionNode> | undefined;
 }
 
-// Schema Coordinates
+/** Schema Coordinates */
+
+export type SchemaCoordinateNode =
+  | TypeCoordinateNode
+  | MemberCoordinateNode
+  | ArgumentCoordinateNode
+  | DirectiveCoordinateNode
+  | DirectiveArgumentCoordinateNode;
+
+export interface TypeCoordinateNode {
+  readonly kind: typeof Kind.TYPE_COORDINATE;
+  readonly loc?: Location;
+  readonly name: NameNode;
+}
+
+export interface MemberCoordinateNode {
+  readonly kind: typeof Kind.MEMBER_COORDINATE;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly memberName: NameNode;
+}
+
+export interface ArgumentCoordinateNode {
+  readonly kind: typeof Kind.ARGUMENT_COORDINATE;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly fieldName: NameNode;
+  readonly argumentName: NameNode;
+}
+
+export interface DirectiveCoordinateNode {
+  readonly kind: typeof Kind.DIRECTIVE_COORDINATE;
+  readonly loc?: Location;
+  readonly name: NameNode;
+}
 
-export interface SchemaCoordinateNode {
-  readonly kind: 'SchemaCoordinate';
+export interface DirectiveArgumentCoordinateNode {
+  readonly kind: typeof Kind.DIRECTIVE_ARGUMENT_COORDINATE;
   readonly loc?: Location;
-  readonly ofDirective: boolean;
   readonly name: NameNode;
-  readonly memberName?: NameNode | undefined;
-  readonly argumentName?: NameNode | undefined;
+  readonly argumentName: NameNode;
 }

src/language/kinds_.ts

@@ -110,5 +110,18 @@ export const INPUT_OBJECT_TYPE_EXTENSION = 'InputObjectTypeExtension';
 export type INPUT_OBJECT_TYPE_EXTENSION = typeof INPUT_OBJECT_TYPE_EXTENSION;
 
 /** Schema Coordinates */
-export const SCHEMA_COORDINATE = 'SchemaCoordinate';
-export type SCHEMA_COORDINATE = typeof SCHEMA_COORDINATE;
+export const TYPE_COORDINATE = 'TypeCoordinate';
+export type TYPE_COORDINATE = typeof TYPE_COORDINATE;
+
+export const MEMBER_COORDINATE = 'MemberCoordinate';
+export type MEMBER_COORDINATE = typeof MEMBER_COORDINATE;
+
+export const ARGUMENT_COORDINATE = 'ArgumentCoordinate';
+export type ARGUMENT_COORDINATE = typeof ARGUMENT_COORDINATE;
+
+export const DIRECTIVE_COORDINATE = 'DirectiveCoordinate';
+export type DIRECTIVE_COORDINATE = typeof DIRECTIVE_COORDINATE;
+
+export const DIRECTIVE_ARGUMENT_COORDINATE = 'DirectiveArgumentCoordinate';
+export type DIRECTIVE_ARGUMENT_COORDINATE =
+  typeof DIRECTIVE_ARGUMENT_COORDINATE;

src/language/parser.ts

@@ -4,6 +4,7 @@ import type { GraphQLError } from '../error/GraphQLError.js';
 import { syntaxError } from '../error/syntaxError.js';
 
 import type {
+  ArgumentCoordinateNode,
   ArgumentNode,
   BooleanValueNode,
   ConstArgumentNode,
@@ -13,6 +14,8 @@ import type {
   ConstObjectValueNode,
   ConstValueNode,
   DefinitionNode,
+  DirectiveArgumentCoordinateNode,
+  DirectiveCoordinateNode,
   DirectiveDefinitionNode,
   DirectiveNode,
   DocumentNode,
@@ -35,6 +38,7 @@ import type {
   IntValueNode,
   ListTypeNode,
   ListValueNode,
+  MemberCoordinateNode,
   NamedTypeNode,
   NameNode,
   NonNullTypeNode,
@@ -54,6 +58,7 @@ import type {
   SelectionSetNode,
   StringValueNode,
   Token,
+  TypeCoordinateNode,
   TypeNode,
   TypeSystemExtensionNode,
   UnionTypeDefinitionNode,
@@ -1481,12 +1486,38 @@ export class Parser {
       this.expectToken(TokenKind.COLON);
       this.expectToken(TokenKind.PAREN_R);
     }
-    return this.node<SchemaCoordinateNode>(start, {
-      kind: Kind.SCHEMA_COORDINATE,
-      ofDirective,
+
+    if (ofDirective) {
+      if (argumentName) {
+        return this.node<DirectiveArgumentCoordinateNode>(start, {
+          kind: Kind.DIRECTIVE_ARGUMENT_COORDINATE,
+          name,
+          argumentName,
+        });
+      }
+      return this.node<DirectiveCoordinateNode>(start, {
+        kind: Kind.DIRECTIVE_COORDINATE,
+        name,
+      });
+    } else if (memberName) {
+      if (argumentName) {
+        return this.node<ArgumentCoordinateNode>(start, {
+          kind: Kind.ARGUMENT_COORDINATE,
+          name,
+          fieldName: memberName,
+          argumentName,
+        });
+      }
+      return this.node<MemberCoordinateNode>(start, {
+        kind: Kind.MEMBER_COORDINATE,
+        name,
+        memberName,
+      });
+    }
+
+    return this.node<TypeCoordinateNode>(start, {
+      kind: Kind.TYPE_COORDINATE,
       name,
-      memberName,
-      argumentName,
     });
   }
 

src/language/predicates.ts

@@ -115,5 +115,11 @@ export function isTypeExtensionNode(node: ASTNode): node is TypeExtensionNode {
 export function isSchemaCoordinateNode(
   node: ASTNode,
 ): node is SchemaCoordinateNode {
-  return node.kind === Kind.SCHEMA_COORDINATE;
+  return (
+    node.kind === Kind.TYPE_COORDINATE ||
+    node.kind === Kind.MEMBER_COORDINATE ||
+    node.kind === Kind.ARGUMENT_COORDINATE ||
+    node.kind === Kind.DIRECTIVE_COORDINATE ||
+    node.kind === Kind.DIRECTIVE_ARGUMENT_COORDINATE
+  );
 }

src/language/printer.ts

@@ -321,16 +321,24 @@ const printDocASTReducer: ASTReducer<string> = {
       join(['extend input', name, join(directives, ' '), block(fields)], ' '),
   },
 
-  // Schema Coordinate
-
-  SchemaCoordinate: {
-    leave: ({ ofDirective, name, memberName, argumentName }) =>
-      join([
-        ofDirective ? '@' : '',
-        name,
-        wrap('.', memberName),
-        wrap('(', argumentName, ':)'),
-      ]),
+  // Schema Coordinates
+
+  TypeCoordinate: { leave: ({ name }) => name },
+
+  MemberCoordinate: {
+    leave: ({ name, memberName }) => join([name, wrap('.', memberName)]),
+  },
+
+  ArgumentCoordinate: {
+    leave: ({ name, fieldName, argumentName }) =>
+      join([name, wrap('.', fieldName), wrap('(', argumentName, ':)')]),
+  },
+
+  DirectiveCoordinate: { leave: ({ name }) => join(['@', name]) },
+
+  DirectiveArgumentCoordinate: {
+    leave: ({ name, argumentName }) =>
+      join(['@', name, wrap('(', argumentName, ':)')]),
   },
 };