add enum syntax

Author: magicmark

src/language/__tests__/parser-test.ts

@@ -703,14 +703,14 @@ describe('Parser', () => {
     it('parses Name . Name', () => {
       const result = parseSchemaCoordinate('MyType.field');
       expectJSON(result).toDeepEqual({
-        kind: Kind.MEMBER_COORDINATE,
+        kind: Kind.FIELD_COORDINATE,
         loc: { start: 0, end: 12 },
         name: {
           kind: Kind.NAME,
           loc: { start: 0, end: 6 },
           value: 'MyType',
         },
-        memberName: {
+        fieldName: {
           kind: Kind.NAME,
           loc: { start: 7, end: 12 },
           value: 'field',
@@ -727,6 +727,24 @@ describe('Parser', () => {
         });
     });
 
+    it('parses Name :: Name', () => {
+      const result = parseSchemaCoordinate('MyEnum::value');
+      expectJSON(result).toDeepEqual({
+        kind: Kind.VALUE_COORDINATE,
+        loc: { start: 0, end: 13 },
+        name: {
+          kind: Kind.NAME,
+          loc: { start: 0, end: 6 },
+          value: 'MyEnum',
+        },
+        valueName: {
+          kind: Kind.NAME,
+          loc: { start: 8, end: 13 },
+          value: 'value',
+        },
+      });
+    });
+
     it('parses Name . Name ( Name : )', () => {
       const result = parseSchemaCoordinate('MyType.field(arg:)');
       expectJSON(result).toDeepEqual({

src/language/__tests__/predicates-test.ts

@@ -148,8 +148,9 @@ describe('AST node predicates', () => {
       'ArgumentCoordinate',
       'DirectiveArgumentCoordinate',
       'DirectiveCoordinate',
-      'MemberCoordinate',
+      'FieldCoordinate',
       'TypeCoordinate',
+      'ValueCoordinate',
     ]);
   });
 });

src/language/ast.ts

@@ -183,8 +183,9 @@ export type ASTNode =
   | EnumTypeExtensionNode
   | InputObjectTypeExtensionNode
   | TypeCoordinateNode
-  | MemberCoordinateNode
+  | FieldCoordinateNode
   | ArgumentCoordinateNode
+  | ValueCoordinateNode
   | DirectiveCoordinateNode
   | DirectiveArgumentCoordinateNode;
 
@@ -295,8 +296,9 @@ export const QueryDocumentKeys: {
 
   // Schema Coordinates
   TypeCoordinate: ['name'],
-  MemberCoordinate: ['name', 'memberName'],
+  FieldCoordinate: ['name', 'fieldName'],
   ArgumentCoordinate: ['name', 'fieldName', 'argumentName'],
+  ValueCoordinate: ['name', 'valueName'],
   DirectiveCoordinate: ['name'],
   DirectiveArgumentCoordinate: ['name', 'argumentName'],
 };
@@ -779,8 +781,9 @@ export interface InputObjectTypeExtensionNode {
 
 export type SchemaCoordinateNode =
   | TypeCoordinateNode
-  | MemberCoordinateNode
+  | FieldCoordinateNode
   | ArgumentCoordinateNode
+  | ValueCoordinateNode
   | DirectiveCoordinateNode
   | DirectiveArgumentCoordinateNode;
 
@@ -790,11 +793,11 @@ export interface TypeCoordinateNode {
   readonly name: NameNode;
 }
 
-export interface MemberCoordinateNode {
-  readonly kind: typeof Kind.MEMBER_COORDINATE;
+export interface FieldCoordinateNode {
+  readonly kind: typeof Kind.FIELD_COORDINATE;
   readonly loc?: Location;
   readonly name: NameNode;
-  readonly memberName: NameNode;
+  readonly fieldName: NameNode;
 }
 
 export interface ArgumentCoordinateNode {
@@ -805,6 +808,13 @@ export interface ArgumentCoordinateNode {
   readonly argumentName: NameNode;
 }
 
+export interface ValueCoordinateNode {
+  readonly kind: typeof Kind.VALUE_COORDINATE;
+  readonly loc?: Location;
+  readonly name: NameNode;
+  readonly valueName: NameNode;
+}
+
 export interface DirectiveCoordinateNode {
   readonly kind: typeof Kind.DIRECTIVE_COORDINATE;
   readonly loc?: Location;

src/language/kinds_.ts

@@ -113,12 +113,15 @@ export type INPUT_OBJECT_TYPE_EXTENSION = typeof INPUT_OBJECT_TYPE_EXTENSION;
 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 FIELD_COORDINATE = 'FieldCoordinate';
+export type FIELD_COORDINATE = typeof FIELD_COORDINATE;
 
 export const ARGUMENT_COORDINATE = 'ArgumentCoordinate';
 export type ARGUMENT_COORDINATE = typeof ARGUMENT_COORDINATE;
 
+export const VALUE_COORDINATE = 'ValueCoordinate';
+export type VALUE_COORDINATE = typeof VALUE_COORDINATE;
+
 export const DIRECTIVE_COORDINATE = 'DirectiveCoordinate';
 export type DIRECTIVE_COORDINATE = typeof DIRECTIVE_COORDINATE;
 

src/language/lexer.ts

@@ -98,6 +98,7 @@ export function isPunctuatorTokenKind(kind: TokenKind): boolean {
     kind === TokenKind.DOT ||
     kind === TokenKind.SPREAD ||
     kind === TokenKind.COLON ||
+    kind === TokenKind.TWO_COLON ||
     kind === TokenKind.EQUALS ||
     kind === TokenKind.AT ||
     kind === TokenKind.BRACKET_L ||
@@ -271,6 +272,14 @@ function readNextToken(lexer: Lexer, start: number): Token {
         return readDot(lexer, position);
       }
       case 0x003a: // :
+        if (body.charCodeAt(position + 1) === 0x003a) {
+          return createToken(
+            lexer,
+            TokenKind.TWO_COLON,
+            position,
+            position + 2,
+          );
+        }
         return createToken(lexer, TokenKind.COLON, position, position + 1);
       case 0x003d: // =
         return createToken(lexer, TokenKind.EQUALS, position, position + 1);

src/language/parser.ts

@@ -23,6 +23,7 @@ import type {
   EnumTypeExtensionNode,
   EnumValueDefinitionNode,
   EnumValueNode,
+  FieldCoordinateNode,
   FieldDefinitionNode,
   FieldNode,
   FloatValueNode,
@@ -38,7 +39,6 @@ import type {
   IntValueNode,
   ListTypeNode,
   ListValueNode,
-  MemberCoordinateNode,
   NamedTypeNode,
   NameNode,
   NonNullTypeNode,
@@ -63,6 +63,7 @@ import type {
   TypeSystemExtensionNode,
   UnionTypeDefinitionNode,
   UnionTypeExtensionNode,
+  ValueCoordinateNode,
   ValueNode,
   VariableDefinitionNode,
   VariableNode,
@@ -1466,13 +1467,24 @@ export class Parser {
    *   - Name
    *   - Name . Name
    *   - Name . Name ( Name : )
+   *   - Name :: Name
    *   - @ Name
    *   - @ Name ( Name : )
    */
   parseSchemaCoordinate(): SchemaCoordinateNode {
     const start = this._lexer.token;
     const ofDirective = this.expectOptionalToken(TokenKind.AT);
     const name = this.parseName();
+
+    if (!ofDirective && this.expectOptionalToken(TokenKind.TWO_COLON)) {
+      const valueName = this.parseName();
+      return this.node<ValueCoordinateNode>(start, {
+        kind: Kind.VALUE_COORDINATE,
+        name,
+        valueName,
+      });
+    }
+
     let memberName: NameNode | undefined;
     if (!ofDirective && this.expectOptionalToken(TokenKind.DOT)) {
       memberName = this.parseName();
@@ -1508,10 +1520,10 @@ export class Parser {
           argumentName,
         });
       }
-      return this.node<MemberCoordinateNode>(start, {
-        kind: Kind.MEMBER_COORDINATE,
+      return this.node<FieldCoordinateNode>(start, {
+        kind: Kind.FIELD_COORDINATE,
         name,
-        memberName,
+        fieldName: memberName,
       });
     }
 

src/language/predicates.ts

@@ -117,8 +117,9 @@ export function isSchemaCoordinateNode(
 ): node is SchemaCoordinateNode {
   return (
     node.kind === Kind.TYPE_COORDINATE ||
-    node.kind === Kind.MEMBER_COORDINATE ||
+    node.kind === Kind.FIELD_COORDINATE ||
     node.kind === Kind.ARGUMENT_COORDINATE ||
+    node.kind === Kind.VALUE_COORDINATE ||
     node.kind === Kind.DIRECTIVE_COORDINATE ||
     node.kind === Kind.DIRECTIVE_ARGUMENT_COORDINATE
   );

src/language/printer.ts

@@ -325,15 +325,19 @@ const printDocASTReducer: ASTReducer<string> = {
 
   TypeCoordinate: { leave: ({ name }) => name },
 
-  MemberCoordinate: {
-    leave: ({ name, memberName }) => join([name, wrap('.', memberName)]),
+  FieldCoordinate: {
+    leave: ({ name, fieldName }) => join([name, wrap('.', fieldName)]),
   },
 
   ArgumentCoordinate: {
     leave: ({ name, fieldName, argumentName }) =>
       join([name, wrap('.', fieldName), wrap('(', argumentName, ':)')]),
   },
 
+  ValueCoordinate: {
+    leave: ({ name, valueName }) => join([name, wrap('::', valueName)]),
+  },
+
   DirectiveCoordinate: { leave: ({ name }) => join(['@', name]) },
 
   DirectiveArgumentCoordinate: {

src/language/tokenKind.ts

@@ -13,6 +13,7 @@ export const TokenKind = {
   DOT: '.',
   SPREAD: '...' as const,
   COLON: ':' as const,
+  TWO_COLON: '::' as const,
   EQUALS: '=' as const,
   AT: '@' as const,
   BRACKET_L: '[' as const,

src/utilities/__tests__/resolveSchemaCoordinate-test.ts

@@ -71,7 +71,7 @@ describe('resolveSchemaCoordinate', () => {
     );
 
     expect(() => resolveSchemaCoordinate(schema, 'String.field')).to.throw(
-      'Expected "String" to be an object type, interface type, input object type, or enum type.',
+      'Expected "String" to be an Input Object, Object or Interface type.',
     );
   });
 
@@ -101,15 +101,15 @@ describe('resolveSchemaCoordinate', () => {
     const type = schema.getType('SearchFilter') as GraphQLEnumType;
     const enumValue = type.getValue('OPEN_NOW');
     expect(
-      resolveSchemaCoordinate(schema, 'SearchFilter.OPEN_NOW'),
+      resolveSchemaCoordinate(schema, 'SearchFilter::OPEN_NOW'),
     ).to.deep.equal({
       kind: 'EnumValue',
       type,
       enumValue,
     });
 
     expect(
-      resolveSchemaCoordinate(schema, 'SearchFilter.UNKNOWN'),
+      resolveSchemaCoordinate(schema, 'SearchFilter::UNKNOWN'),
     ).to.deep.equal(undefined);
   });