Schema parser add Union AST definition

Adds Union definition to AST, uses in parser. Order definitions in all files to be in same order.

Author: leebyron

src/language/schema/ast.js

@@ -24,8 +24,9 @@ export type SchemaDocument = {
 export type SchemaDefinition =
   TypeDefinition |
   InterfaceDefinition |
-  EnumDefinition |
+  UnionDefinition |
   ScalarDefinition |
+  EnumDefinition |
   InputObjectDefinition
 
 export type TypeDefinition = {
@@ -36,13 +37,6 @@ export type TypeDefinition = {
   fields: Array<FieldDefinition>;
 }
 
-export type InterfaceDefinition = {
-  kind: 'InterfaceDefinition';
-  loc?: ?Location;
-  name: Name;
-  fields: Array<FieldDefinition>;
-}
-
 export type FieldDefinition = {
   kind: 'FieldDefinition';
   loc?: ?Location;
@@ -51,18 +45,31 @@ export type FieldDefinition = {
   arguments: Array<ArgumentDefinition>;
 }
 
-export type InputFieldDefinition = {
-  kind: 'InputFieldDefinition';
+export type ArgumentDefinition = {
+  kind: 'ArgumentDefinition';
   loc?: ?Location;
   name: Name;
   type: Type;
 }
 
-export type ArgumentDefinition = {
-  kind: 'ArgumentDefinition';
+export type InterfaceDefinition = {
+  kind: 'InterfaceDefinition';
+  loc?: ?Location;
+  name: Name;
+  fields: Array<FieldDefinition>;
+}
+
+export type UnionDefinition = {
+  kind: 'UnionDefinition';
+  loc?: ?Location;
+  name: Name;
+  types: Array<NamedType>;
+}
+
+export type ScalarDefinition = {
+  kind: 'ScalarDefinition';
   loc?: ?Location;
   name: Name;
-  type: Type;
 }
 
 export type EnumDefinition = {
@@ -78,15 +85,16 @@ export type EnumValueDefinition = {
   name: Name;
 }
 
-export type ScalarDefinition = {
-  kind: 'ScalarDefinition';
+export type InputObjectDefinition = {
+  kind: 'InputObjectDefinition';
   loc?: ?Location;
   name: Name;
+  fields: Array<InputFieldDefinition>;
 }
 
-export type InputObjectDefinition = {
-  kind: 'InputObjectDefinition';
+export type InputFieldDefinition = {
+  kind: 'InputFieldDefinition';
   loc?: ?Location;
   name: Name;
-  fields: Array<InputFieldDefinition>;
+  type: Type;
 }

src/language/schema/kinds.js

@@ -10,13 +10,13 @@
 // Schema
 
 export const SCHEMA_DOCUMENT = 'SchemaDocument';
-export const FIELD_DEFINITION = 'FieldDefinition';
 export const TYPE_DEFINITION = 'TypeDefinition';
-export const INTERFACE_DEFINITION = 'InterfaceDefinition';
-export const ENUM_DEFINITION = 'EnumDefinition';
-export const ENUM_VALUE_DEFINITION = 'EnumValueDefinition';
+export const FIELD_DEFINITION = 'FieldDefinition';
 export const ARGUMENT_DEFINITION = 'ArgumentDefinition';
+export const INTERFACE_DEFINITION = 'InterfaceDefinition';
 export const UNION_DEFINITION = 'UnionDefinition';
 export const SCALAR_DEFINITION = 'ScalarDefinition';
+export const ENUM_DEFINITION = 'EnumDefinition';
+export const ENUM_VALUE_DEFINITION = 'EnumValueDefinition';
 export const INPUT_OBJECT_DEFINITION = 'InputObjectDefinition';
 export const INPUT_FIELD_DEFINITION = 'InputFieldDefinition';

src/language/schema/parser.js

@@ -8,9 +8,9 @@
  *  of patent rights can be found in the PATENTS file in the same directory.
  */
 
-import { Source } from './../source';
+import { Source } from '../source';
 
-import { TokenKind } from './../lexer';
+import { TokenKind } from '../lexer';
 
 import {
   ParseOptions,
@@ -24,27 +24,29 @@ import {
   unexpected,
   expectKeyword,
   advance,
-} from './../parserCore';
+} from '../parserCore';
 
 import {
   parseName,
-  parseNamedType,
   parseType,
-} from './../parser';
+  parseNamedType,
+} from '../parser';
 
-import { NamedType } from '../ast';
+import type { NamedType } from '../ast';
 
 import type {
   SchemaDocument,
+  SchemaDefinition,
   TypeDefinition,
   FieldDefinition,
+  ArgumentDefinition,
   EnumDefinition,
   EnumValueDefinition,
   InterfaceDefinition,
-  ArgumentDefinition,
-  ScalarDefinition,
+  UnionDefinition,
   InputObjectDefinition,
   InputFieldDefinition,
+  ScalarDefinition,
 } from './ast';
 
 import {
@@ -84,24 +86,23 @@ function parseSchemaDocument(parser): SchemaDocument {
   };
 }
 
-
-function parseSchemaDefinition(parser): any {
+function parseSchemaDefinition(parser): SchemaDefinition {
   if (!peek(parser, TokenKind.NAME)) {
     throw unexpected(parser);
   }
   switch (parser.token.value) {
     case 'type':
       return parseTypeDefinition(parser);
-    case 'enum':
-      return parseEnumDefinition(parser);
     case 'interface':
       return parseInterfaceDefinition(parser);
     case 'union':
       return parseUnionDefinition(parser);
-    case 'input':
-      return parseInputObjectDefinition(parser);
     case 'scalar':
       return parseScalarDefinition(parser);
+    case 'enum':
+      return parseEnumDefinition(parser);
+    case 'input':
+      return parseInputObjectDefinition(parser);
     default:
       throw unexpected(parser);
   }
@@ -126,6 +127,17 @@ function parseTypeDefinition(parser): TypeDefinition {
   };
 }
 
+function parseInterfaces(parser): Array<NamedType> {
+  var types = [];
+  if (parser.token.value === 'implements') {
+    advance(parser);
+    do {
+      types.push(parseNamedType(parser));
+    } while (!peek(parser, TokenKind.BRACE_L));
+  }
+  return types;
+}
+
 function parseFieldDefinition(parser): FieldDefinition {
   var start = parser.token.start;
   var name = parseName(parser);
@@ -168,46 +180,6 @@ function parseArgumentDef(parser): ArgumentDefinition {
   };
 }
 
-function parseInterfaces(parser): Array<NamedType> {
-  var types = [];
-  if (parser.token.value === 'implements') {
-    advance(parser);
-    do {
-      types.push(parseType(parser));
-    } while (!peek(parser, TokenKind.BRACE_L));
-  }
-  return types;
-}
-
-function parseEnumDefinition(parser): EnumDefinition {
-  var start = parser.token.start;
-  expectKeyword(parser, 'enum');
-  var name = parseName(parser);
-  var values = many(
-    parser,
-    TokenKind.BRACE_L,
-    parseEnumValueDefinition,
-    TokenKind.BRACE_R);
-  var location = loc(parser, start);
-  return {
-    kind: ENUM_DEFINITION,
-    name: name,
-    values: values,
-    loc: location,
-  };
-}
-
-function parseEnumValueDefinition(parser) : EnumValueDefinition {
-  var start = parser.token.start;
-  var name = parseName(parser);
-  var location = loc(parser, start);
-  return {
-    kind: ENUM_VALUE_DEFINITION,
-    name: name,
-    loc: location,
-  };
-}
-
 function parseInterfaceDefinition(parser): InterfaceDefinition {
   var start = parser.token.start;
   expectKeyword(parser, 'interface');
@@ -225,7 +197,7 @@ function parseInterfaceDefinition(parser): InterfaceDefinition {
   };
 }
 
-function parseUnionDefinition(parser) {
+function parseUnionDefinition(parser): UnionDefinition {
   var start = parser.token.start;
   expectKeyword(parser, 'union');
   var name = parseName(parser);
@@ -249,6 +221,46 @@ function parseUnionMembers(parser) {
   return members;
 }
 
+function parseScalarDefinition(parser): ScalarDefinition {
+  var start = parser.token.start;
+  expectKeyword(parser, 'scalar');
+  var name = parseName(parser);
+  var location = loc(parser, start);
+  return {
+    kind: SCALAR_DEFINITION,
+    name: name,
+    loc: location,
+  };
+}
+
+function parseEnumDefinition(parser): EnumDefinition {
+  var start = parser.token.start;
+  expectKeyword(parser, 'enum');
+  var name = parseName(parser);
+  var values = many(
+    parser,
+    TokenKind.BRACE_L,
+    parseEnumValueDefinition,
+    TokenKind.BRACE_R);
+  var location = loc(parser, start);
+  return {
+    kind: ENUM_DEFINITION,
+    name: name,
+    values: values,
+    loc: location,
+  };
+}
+
+function parseEnumValueDefinition(parser) : EnumValueDefinition {
+  var start = parser.token.start;
+  var name = parseName(parser);
+  var location = loc(parser, start);
+  return {
+    kind: ENUM_VALUE_DEFINITION,
+    name: name,
+    loc: location,
+  };
+}
 
 function parseInputObjectDefinition(parser): InputObjectDefinition {
   var start = parser.token.start;
@@ -280,15 +292,3 @@ function parseInputFieldDefinition(parser): InputFieldDefinition {
     loc: location,
   };
 }
-
-function parseScalarDefinition(parser): ScalarDefinition {
-  var start = parser.token.start;
-  expectKeyword(parser, 'scalar');
-  var name = parseName(parser);
-  var location = loc(parser, start);
-  return {
-    kind: SCALAR_DEFINITION,
-    name: name,
-    loc: location,
-  };
-}