graphql - npm Package Compare versions

Comparing version 0.4.2 to 0.4.3

execution/execute.js

@@ -142,2 +142,4 @@
         break;
+      default:
+        throw new _error.GraphQLError('GraphQL cannot execute a request containing a ' + statement.kind + '.', statement);
     }
@@ -144,0 +146,0 @@ });

language/ast.js

@@ -31,6 +31,10 @@
 
-// Types
+// Type Reference
 
+// Type Definition
+
 Object.defineProperty(exports, '__esModule', {
   value: true
-});
+});
+
+// Note: subscription is an experimental non-spec addition.

language/kinds.js

@@ -77,2 +77,25 @@ /**
 var NON_NULL_TYPE = 'NonNullType';
-exports.NON_NULL_TYPE = NON_NULL_TYPE;
+
+exports.NON_NULL_TYPE = NON_NULL_TYPE;
+// Type Definitions
+
+var OBJECT_TYPE_DEFINITION = 'ObjectTypeDefinition';
+exports.OBJECT_TYPE_DEFINITION = OBJECT_TYPE_DEFINITION;
+var FIELD_DEFINITION = 'FieldDefinition';
+exports.FIELD_DEFINITION = FIELD_DEFINITION;
+var INPUT_VALUE_DEFINITION = 'InputValueDefinition';
+exports.INPUT_VALUE_DEFINITION = INPUT_VALUE_DEFINITION;
+var INTERFACE_TYPE_DEFINITION = 'InterfaceTypeDefinition';
+exports.INTERFACE_TYPE_DEFINITION = INTERFACE_TYPE_DEFINITION;
+var UNION_TYPE_DEFINITION = 'UnionTypeDefinition';
+exports.UNION_TYPE_DEFINITION = UNION_TYPE_DEFINITION;
+var SCALAR_TYPE_DEFINITION = 'ScalarTypeDefinition';
+exports.SCALAR_TYPE_DEFINITION = SCALAR_TYPE_DEFINITION;
+var ENUM_TYPE_DEFINITION = 'EnumTypeDefinition';
+exports.ENUM_TYPE_DEFINITION = ENUM_TYPE_DEFINITION;
+var ENUM_VALUE_DEFINITION = 'EnumValueDefinition';
+exports.ENUM_VALUE_DEFINITION = ENUM_VALUE_DEFINITION;
+var INPUT_OBJECT_TYPE_DEFINITION = 'InputObjectTypeDefinition';
+exports.INPUT_OBJECT_TYPE_DEFINITION = INPUT_OBJECT_TYPE_DEFINITION;
+var TYPE_EXTENSION_DEFINITION = 'TypeExtensionDefinition';
+exports.TYPE_EXTENSION_DEFINITION = TYPE_EXTENSION_DEFINITION;

language/lexer.js

@@ -263,10 +263,9 @@ /*  /
     code = charCodeAt.call(body, ++position);
-  } else if (code >= 49 && code <= 57) {
-    // 1 - 9
-    do {
-      code = charCodeAt.call(body, ++position);
-    } while (code >= 48 && code <= 57); // 0 - 9
+    if (code >= 48 && code <= 57) {
+      throw (0, _error.syntaxError)(source, position, 'Invalid number, unexpected digit after 0: "' + fromCharCode(code) + '".');
+    }
   } else {
-      throw (0, _error.syntaxError)(source, position, 'Invalid number.');
-    }
+    position = readDigits(source, position, code);
+    code = charCodeAt.call(body, position);
+  }
 
@@ -278,10 +277,4 @@ if (code === 46) {
     code = charCodeAt.call(body, ++position);
-    if (code >= 48 && code <= 57) {
-      // 0 - 9
-      do {
-        code = charCodeAt.call(body, ++position);
-      } while (code >= 48 && code <= 57); // 0 - 9
-    } else {
-        throw (0, _error.syntaxError)(source, position, 'Invalid number.');
-      }
+    position = readDigits(source, position, code);
+    code = charCodeAt.call(body, position);
   }
@@ -298,10 +291,3 @@
     }
-    if (code >= 48 && code <= 57) {
-      // 0 - 9
-      do {
-        code = charCodeAt.call(body, ++position);
-      } while (code >= 48 && code <= 57); // 0 - 9
-    } else {
-        throw (0, _error.syntaxError)(source, position, 'Invalid number.');
-      }
+    position = readDigits(source, position, code);
   }
@@ -313,2 +299,19 @@
 /**
+ * Returns the new position in the source after reading digits.
+ */
+function readDigits(source, start, firstCode) {
+  var body = source.body;
+  var position = start;
+  var code = firstCode;
+  if (code >= 48 && code <= 57) {
+    // 0 - 9
+    do {
+      code = charCodeAt.call(body, ++position);
+    } while (code >= 48 && code <= 57); // 0 - 9
+    return position;
+  }
+  throw (0, _error.syntaxError)(source, position, 'Invalid number, expected digit but got: ' + (code ? '"' + fromCharCode(code) + '"' : 'EOF') + '.');
+}
+
+/**
  * Reads a string token from the source file.
@@ -315,0 +318,0 @@ *

language/parser.js

@@ -12,2 +12,5 @@ /**
 
+/**
+ * Configuration options to control parser behavior
+ */
 Object.defineProperty(exports, '__esModule', {
@@ -18,3 +21,2 @@ value: true
 exports.parseValue = parseValue;
-exports.parseName = parseName;
 exports.parseConstValue = parseConstValue;
@@ -32,4 +34,2 @@ exports.parseType = parseType;
 
-var _parserCore = require('./parserCore');
-
 /**
@@ -42,3 +42,3 @@ * Given a GraphQL source, parses it into a Document.
   var sourceObj = source instanceof _source.Source ? source : new _source.Source(source);
-  var parser = (0, _parserCore.makeParser)(sourceObj, options || {});
+  var parser = makeParser(sourceObj, options || {});
   return parseDocument(parser);
@@ -57,3 +57,3 @@ }
   var sourceObj = source instanceof _source.Source ? source : new _source.Source(source);
-  var parser = (0, _parserCore.makeParser)(sourceObj, options || {});
+  var parser = makeParser(sourceObj, options || {});
   return parseValueLiteral(parser);
@@ -65,9 +65,8 @@ }
  */
-
 function parseName(parser) {
-  var token = (0, _parserCore.expect)(parser, _lexer.TokenKind.NAME);
+  var token = expect(parser, _lexer.TokenKind.NAME);
   return {
     kind: _kinds.NAME,
     value: token.value,
-    loc: (0, _parserCore.loc)(parser, token.start)
+    loc: loc(parser, token.start)
   };
@@ -78,32 +77,68 @@ }
 
+/**
+ * Document : Definition+
+ */
 function parseDocument(parser) {
   var start = parser.token.start;
+
   var definitions = [];
   do {
-    if ((0, _parserCore.peek)(parser, _lexer.TokenKind.BRACE_L)) {
-      definitions.push(parseOperationDefinition(parser));
-    } else if ((0, _parserCore.peek)(parser, _lexer.TokenKind.NAME)) {
-      if (parser.token.value === 'query' || parser.token.value === 'mutation') {
-        definitions.push(parseOperationDefinition(parser));
-      } else if (parser.token.value === 'fragment') {
-        definitions.push(parseFragmentDefinition(parser));
-      } else {
-        throw (0, _parserCore.unexpected)(parser);
-      }
-    } else {
-      throw (0, _parserCore.unexpected)(parser);
-    }
-  } while (!(0, _parserCore.skip)(parser, _lexer.TokenKind.EOF));
+    definitions.push(parseDefinition(parser));
+  } while (!skip(parser, _lexer.TokenKind.EOF));
+
   return {
     kind: _kinds.DOCUMENT,
     definitions: definitions,
-    loc: (0, _parserCore.loc)(parser, start)
+    loc: loc(parser, start)
   };
 }
 
+/**
+ * Definition :
+ *   - OperationDefinition
+ *   - FragmentDefinition
+ *   - TypeDefinition
+ */
+function parseDefinition(parser) {
+  if (peek(parser, _lexer.TokenKind.BRACE_L)) {
+    return parseOperationDefinition(parser);
+  }
+
+  if (peek(parser, _lexer.TokenKind.NAME)) {
+    switch (parser.token.value) {
+      case 'query':
+      case 'mutation':
+      // Note: subscription is an experimental non-spec addition.
+      case 'subscription':
+        return parseOperationDefinition(parser);
+
+      case 'fragment':
+        return parseFragmentDefinition(parser);
+
+      case 'type':
+      case 'interface':
+      case 'union':
+      case 'scalar':
+      case 'enum':
+      case 'input':
+      case 'extend':
+        return parseTypeDefinition(parser);
+    }
+  }
+
+  throw unexpected(parser);
+}
+
 // Implements the parsing rules in the Operations section.
 
+/**
+ * OperationDefinition :
+ *  - SelectionSet
+ *  - OperationType Name VariableDefinitions? Directives? SelectionSet
+ *
+ * OperationType : one of query mutation
+ */
 function parseOperationDefinition(parser) {
   var start = parser.token.start;
-  if ((0, _parserCore.peek)(parser, _lexer.TokenKind.BRACE_L)) {
+  if (peek(parser, _lexer.TokenKind.BRACE_L)) {
     return {
@@ -116,6 +151,6 @@ kind: _kinds.OPERATION_DEFINITION,
       selectionSet: parseSelectionSet(parser),
-      loc: (0, _parserCore.loc)(parser, start)
+      loc: loc(parser, start)
     };
   }
-  var operationToken = (0, _parserCore.expect)(parser, _lexer.TokenKind.NAME);
+  var operationToken = expect(parser, _lexer.TokenKind.NAME);
   var operation = operationToken.value;
@@ -129,10 +164,16 @@ return {
     selectionSet: parseSelectionSet(parser),
-    loc: (0, _parserCore.loc)(parser, start)
+    loc: loc(parser, start)
   };
 }
 
+/**
+ * VariableDefinitions : ( VariableDefinition+ )
+ */
 function parseVariableDefinitions(parser) {
-  return (0, _parserCore.peek)(parser, _lexer.TokenKind.PAREN_L) ? (0, _parserCore.many)(parser, _lexer.TokenKind.PAREN_L, parseVariableDefinition, _lexer.TokenKind.PAREN_R) : [];
+  return peek(parser, _lexer.TokenKind.PAREN_L) ? many(parser, _lexer.TokenKind.PAREN_L, parseVariableDefinition, _lexer.TokenKind.PAREN_R) : [];
 }
 
+/**
+ * VariableDefinition : Variable : Type DefaultValue?
+ */
 function parseVariableDefinition(parser) {
@@ -143,18 +184,24 @@ var start = parser.token.start;
     variable: parseVariable(parser),
-    type: ((0, _parserCore.expect)(parser, _lexer.TokenKind.COLON), parseType(parser)),
-    defaultValue: (0, _parserCore.skip)(parser, _lexer.TokenKind.EQUALS) ? parseValueLiteral(parser, true) : null,
-    loc: (0, _parserCore.loc)(parser, start)
+    type: (expect(parser, _lexer.TokenKind.COLON), parseType(parser)),
+    defaultValue: skip(parser, _lexer.TokenKind.EQUALS) ? parseValueLiteral(parser, true) : null,
+    loc: loc(parser, start)
   };
 }
 
+/**
+ * Variable : $ Name
+ */
 function parseVariable(parser) {
   var start = parser.token.start;
-  (0, _parserCore.expect)(parser, _lexer.TokenKind.DOLLAR);
+  expect(parser, _lexer.TokenKind.DOLLAR);
   return {
     kind: _kinds.VARIABLE,
     name: parseName(parser),
-    loc: (0, _parserCore.loc)(parser, start)
+    loc: loc(parser, start)
   };
 }
 
+/**
+ * SelectionSet : { Selection+ }
+ */
 function parseSelectionSet(parser) {
@@ -164,13 +211,21 @@ var start = parser.token.start;
     kind: _kinds.SELECTION_SET,
-    selections: (0, _parserCore.many)(parser, _lexer.TokenKind.BRACE_L, parseSelection, _lexer.TokenKind.BRACE_R),
-    loc: (0, _parserCore.loc)(parser, start)
+    selections: many(parser, _lexer.TokenKind.BRACE_L, parseSelection, _lexer.TokenKind.BRACE_R),
+    loc: loc(parser, start)
   };
 }
 
+/**
+ * Selection :
+ *   - Field
+ *   - FragmentSpread
+ *   - InlineFragment
+ */
 function parseSelection(parser) {
-  return (0, _parserCore.peek)(parser, _lexer.TokenKind.SPREAD) ? parseFragment(parser) : parseField(parser);
+  return peek(parser, _lexer.TokenKind.SPREAD) ? parseFragment(parser) : parseField(parser);
 }
 
 /**
- * Corresponds to both Field and Alias in the spec
+ * Field : Alias? Name Arguments? Directives? SelectionSet?
+ *
+ * Alias : Name :
  */
@@ -183,3 +238,3 @@ function parseField(parser) {
   var name;
-  if ((0, _parserCore.skip)(parser, _lexer.TokenKind.COLON)) {
+  if (skip(parser, _lexer.TokenKind.COLON)) {
     alias = nameOrAlias;
@@ -198,11 +253,17 @@ name = parseName(parser);
     directives: parseDirectives(parser),
-    selectionSet: (0, _parserCore.peek)(parser, _lexer.TokenKind.BRACE_L) ? parseSelectionSet(parser) : null,
-    loc: (0, _parserCore.loc)(parser, start)
+    selectionSet: peek(parser, _lexer.TokenKind.BRACE_L) ? parseSelectionSet(parser) : null,
+    loc: loc(parser, start)
   };
 }
 
+/**
+ * Arguments : ( Argument+ )
+ */
 function parseArguments(parser) {
-  return (0, _parserCore.peek)(parser, _lexer.TokenKind.PAREN_L) ? (0, _parserCore.many)(parser, _lexer.TokenKind.PAREN_L, parseArgument, _lexer.TokenKind.PAREN_R) : [];
+  return peek(parser, _lexer.TokenKind.PAREN_L) ? many(parser, _lexer.TokenKind.PAREN_L, parseArgument, _lexer.TokenKind.PAREN_R) : [];
 }
 
+/**
+ * Argument : Name : Value
+ */
 function parseArgument(parser) {
@@ -213,4 +274,4 @@ var start = parser.token.start;
     name: parseName(parser),
-    value: ((0, _parserCore.expect)(parser, _lexer.TokenKind.COLON), parseValueLiteral(parser, false)),
-    loc: (0, _parserCore.loc)(parser, start)
+    value: (expect(parser, _lexer.TokenKind.COLON), parseValueLiteral(parser, false)),
+    loc: loc(parser, start)
   };
@@ -222,9 +283,13 @@ }
 /**
- * Corresponds to both FragmentSpread and InlineFragment in the spec
+ * Corresponds to both FragmentSpread and InlineFragment in the spec.
+ *
+ * FragmentSpread : ... FragmentName Directives?
+ *
+ * InlineFragment : ... on TypeCondition Directives? SelectionSet
  */
 function parseFragment(parser) {
   var start = parser.token.start;
-  (0, _parserCore.expect)(parser, _lexer.TokenKind.SPREAD);
+  expect(parser, _lexer.TokenKind.SPREAD);
   if (parser.token.value === 'on') {
-    (0, _parserCore.advance)(parser);
+    advance(parser);
     return {
@@ -235,3 +300,3 @@ kind: _kinds.INLINE_FRAGMENT,
       selectionSet: parseSelectionSet(parser),
-      loc: (0, _parserCore.loc)(parser, start)
+      loc: loc(parser, start)
     };
@@ -243,36 +308,52 @@ }
     directives: parseDirectives(parser),
-    loc: (0, _parserCore.loc)(parser, start)
+    loc: loc(parser, start)
   };
 }
 
-function parseFragmentName(parser) {
-  if (parser.token.value === 'on') {
-    throw (0, _parserCore.unexpected)(parser);
-  }
-  return parseName(parser);
-}
-
+/**
+ * FragmentDefinition :
+ *   - fragment FragmentName on TypeCondition Directives? SelectionSet
+ *
+ * TypeCondition : NamedType
+ */
 function parseFragmentDefinition(parser) {
   var start = parser.token.start;
-  (0, _parserCore.expectKeyword)(parser, 'fragment');
+  expectKeyword(parser, 'fragment');
   return {
     kind: _kinds.FRAGMENT_DEFINITION,
     name: parseFragmentName(parser),
-    typeCondition: ((0, _parserCore.expectKeyword)(parser, 'on'), parseNamedType(parser)),
+    typeCondition: (expectKeyword(parser, 'on'), parseNamedType(parser)),
     directives: parseDirectives(parser),
     selectionSet: parseSelectionSet(parser),
-    loc: (0, _parserCore.loc)(parser, start)
+    loc: loc(parser, start)
   };
 }
 
-// Implements the parsing rules in the Values section.
-
-function parseConstValue(parser) {
-  return parseValueLiteral(parser, true);
+/**
+ * FragmentName : Name but not `on`
+ */
+function parseFragmentName(parser) {
+  if (parser.token.value === 'on') {
+    throw unexpected(parser);
+  }
+  return parseName(parser);
 }
 
-function parseValueValue(parser) {
-  return parseValueLiteral(parser, false);
-}
+// Implements the parsing rules in the Values section.
 
+/**
+ * Value[Const] :
+ *   - [~Const] Variable
+ *   - IntValue
+ *   - FloatValue
+ *   - StringValue
+ *   - BooleanValue
+ *   - EnumValue
+ *   - ListValue[?Const]
+ *   - ObjectValue[?Const]
+ *
+ * BooleanValue : one of `true` `false`
+ *
+ * EnumValue : Name but not `true`, `false` or `null`
+ */
 function parseValueLiteral(parser, isConst) {
@@ -286,36 +367,36 @@ var token = parser.token;
     case _lexer.TokenKind.INT:
-      (0, _parserCore.advance)(parser);
+      advance(parser);
       return {
         kind: _kinds.INT,
         value: token.value,
-        loc: (0, _parserCore.loc)(parser, token.start)
+        loc: loc(parser, token.start)
       };
     case _lexer.TokenKind.FLOAT:
-      (0, _parserCore.advance)(parser);
+      advance(parser);
       return {
         kind: _kinds.FLOAT,
         value: token.value,
-        loc: (0, _parserCore.loc)(parser, token.start)
+        loc: loc(parser, token.start)
       };
     case _lexer.TokenKind.STRING:
-      (0, _parserCore.advance)(parser);
+      advance(parser);
       return {
         kind: _kinds.STRING,
         value: token.value,
-        loc: (0, _parserCore.loc)(parser, token.start)
+        loc: loc(parser, token.start)
       };
     case _lexer.TokenKind.NAME:
       if (token.value === 'true' || token.value === 'false') {
-        (0, _parserCore.advance)(parser);
+        advance(parser);
         return {
           kind: _kinds.BOOLEAN,
           value: token.value === 'true',
-          loc: (0, _parserCore.loc)(parser, token.start)
+          loc: loc(parser, token.start)
         };
       } else if (token.value !== 'null') {
-        (0, _parserCore.advance)(parser);
+        advance(parser);
         return {
           kind: _kinds.ENUM,
           value: token.value,
-          loc: (0, _parserCore.loc)(parser, token.start)
+          loc: loc(parser, token.start)
         };
@@ -330,5 +411,18 @@ }
   }
-  throw (0, _parserCore.unexpected)(parser);
+  throw unexpected(parser);
 }
 
+function parseConstValue(parser) {
+  return parseValueLiteral(parser, true);
+}
+
+function parseValueValue(parser) {
+  return parseValueLiteral(parser, false);
+}
+
+/**
+ * ListValue[Const] :
+ *   - [ ]
+ *   - [ Value[?Const]+ ]
+ */
 function parseList(parser, isConst) {
@@ -339,13 +433,18 @@ var start = parser.token.start;
     kind: _kinds.LIST,
-    values: (0, _parserCore.any)(parser, _lexer.TokenKind.BRACKET_L, item, _lexer.TokenKind.BRACKET_R),
-    loc: (0, _parserCore.loc)(parser, start)
+    values: any(parser, _lexer.TokenKind.BRACKET_L, item, _lexer.TokenKind.BRACKET_R),
+    loc: loc(parser, start)
   };
 }
 
+/**
+ * ObjectValue[Const] :
+ *   - { }
+ *   - { ObjectField[?Const]+ }
+ */
 function parseObject(parser, isConst) {
   var start = parser.token.start;
-  (0, _parserCore.expect)(parser, _lexer.TokenKind.BRACE_L);
+  expect(parser, _lexer.TokenKind.BRACE_L);
   var fieldNames = {};
   var fields = [];
-  while (!(0, _parserCore.skip)(parser, _lexer.TokenKind.BRACE_R)) {
+  while (!skip(parser, _lexer.TokenKind.BRACE_R)) {
     fields.push(parseObjectField(parser, isConst, fieldNames));
@@ -356,6 +455,9 @@ }
     fields: fields,
-    loc: (0, _parserCore.loc)(parser, start)
+    loc: loc(parser, start)
   };
 }
 
+/**
+ * ObjectField[Const] : Name : Value[?Const]
+ */
 function parseObjectField(parser, isConst, fieldNames) {
@@ -371,4 +473,4 @@ var start = parser.token.start;
     name: name,
-    value: ((0, _parserCore.expect)(parser, _lexer.TokenKind.COLON), parseValueLiteral(parser, isConst)),
-    loc: (0, _parserCore.loc)(parser, start)
+    value: (expect(parser, _lexer.TokenKind.COLON), parseValueLiteral(parser, isConst)),
+    loc: loc(parser, start)
   };
@@ -379,5 +481,8 @@ }
 
+/**
+ * Directives : Directive+
+ */
 function parseDirectives(parser) {
   var directives = [];
-  while ((0, _parserCore.peek)(parser, _lexer.TokenKind.AT)) {
+  while (peek(parser, _lexer.TokenKind.AT)) {
     directives.push(parseDirective(parser));
@@ -388,5 +493,8 @@ }
 
+/**
+ * Directive : @ Name Arguments?
+ */
 function parseDirective(parser) {
   var start = parser.token.start;
-  (0, _parserCore.expect)(parser, _lexer.TokenKind.AT);
+  expect(parser, _lexer.TokenKind.AT);
   return {
@@ -396,3 +504,3 @@ kind: _kinds.DIRECTIVE,
     arguments: parseArguments(parser),
-    loc: (0, _parserCore.loc)(parser, start)
+    loc: loc(parser, start)
   };
@@ -404,3 +512,6 @@ }
 /**
- * Handles the Type: NamedType, ListType, and NonNullType parsing rules.
+ * Type :
+ *   - NamedType
+ *   - ListType
+ *   - NonNullType
  */
@@ -411,9 +522,9 @@
   var type;
-  if ((0, _parserCore.skip)(parser, _lexer.TokenKind.BRACKET_L)) {
+  if (skip(parser, _lexer.TokenKind.BRACKET_L)) {
     type = parseType(parser);
-    (0, _parserCore.expect)(parser, _lexer.TokenKind.BRACKET_R);
+    expect(parser, _lexer.TokenKind.BRACKET_R);
     type = {
       kind: _kinds.LIST_TYPE,
       type: type,
-      loc: (0, _parserCore.loc)(parser, start)
+      loc: loc(parser, start)
     };
@@ -423,7 +534,7 @@ } else {
   }
-  if ((0, _parserCore.skip)(parser, _lexer.TokenKind.BANG)) {
+  if (skip(parser, _lexer.TokenKind.BANG)) {
     return {
       kind: _kinds.NON_NULL_TYPE,
       type: type,
-      loc: (0, _parserCore.loc)(parser, start)
+      loc: loc(parser, start)
     };
@@ -434,2 +545,6 @@ }
 
+/**
+ * NamedType : Name
+ */
+
 function parseNamedType(parser) {
@@ -440,4 +555,379 @@ var start = parser.token.start;
     name: parseName(parser),
-    loc: (0, _parserCore.loc)(parser, start)
+    loc: loc(parser, start)
   };
-}
+}
+
+// Implements the parsing rules in the Type Definition section.
+
+/**
+ * TypeDefinition :
+ *   - ObjectTypeDefinition
+ *   - InterfaceTypeDefinition
+ *   - UnionTypeDefinition
+ *   - ScalarTypeDefinition
+ *   - EnumTypeDefinition
+ *   - InputObjectTypeDefinition
+ *   - TypeExtensionDefinition
+ */
+function parseTypeDefinition(parser) {
+  if (!peek(parser, _lexer.TokenKind.NAME)) {
+    throw unexpected(parser);
+  }
+  switch (parser.token.value) {
+    case 'type':
+      return parseObjectTypeDefinition(parser);
+    case 'interface':
+      return parseInterfaceTypeDefinition(parser);
+    case 'union':
+      return parseUnionTypeDefinition(parser);
+    case 'scalar':
+      return parseScalarTypeDefinition(parser);
+    case 'enum':
+      return parseEnumTypeDefinition(parser);
+    case 'input':
+      return parseInputObjectTypeDefinition(parser);
+    case 'extend':
+      return parseTypeExtensionDefinition(parser);
+    default:
+      throw unexpected(parser);
+  }
+}
+
+/**
+ * ObjectTypeDefinition : type Name ImplementsInterfaces? { FieldDefinition+ }
+ */
+function parseObjectTypeDefinition(parser) {
+  var start = parser.token.start;
+  expectKeyword(parser, 'type');
+  var name = parseName(parser);
+  var interfaces = parseImplementsInterfaces(parser);
+  var fields = any(parser, _lexer.TokenKind.BRACE_L, parseFieldDefinition, _lexer.TokenKind.BRACE_R);
+  return {
+    kind: _kinds.OBJECT_TYPE_DEFINITION,
+    name: name,
+    interfaces: interfaces,
+    fields: fields,
+    loc: loc(parser, start)
+  };
+}
+
+/**
+ * ImplementsInterfaces : implements NamedType+
+ */
+function parseImplementsInterfaces(parser) {
+  var types = [];
+  if (parser.token.value === 'implements') {
+    advance(parser);
+    do {
+      types.push(parseNamedType(parser));
+    } while (!peek(parser, _lexer.TokenKind.BRACE_L));
+  }
+  return types;
+}
+
+/**
+ * FieldDefinition : Name ArgumentsDefinition? : Type
+ */
+function parseFieldDefinition(parser) {
+  var start = parser.token.start;
+  var name = parseName(parser);
+  var args = parseArgumentDefs(parser);
+  expect(parser, _lexer.TokenKind.COLON);
+  var type = parseType(parser);
+  return {
+    kind: _kinds.FIELD_DEFINITION,
+    name: name,
+    arguments: args,
+    type: type,
+    loc: loc(parser, start)
+  };
+}
+
+/**
+ * ArgumentsDefinition : ( InputValueDefinition+ )
+ */
+function parseArgumentDefs(parser) {
+  if (!peek(parser, _lexer.TokenKind.PAREN_L)) {
+    return [];
+  }
+  return many(parser, _lexer.TokenKind.PAREN_L, parseInputValueDef, _lexer.TokenKind.PAREN_R);
+}
+
+/**
+ * InputValueDefinition : Name : Type DefaultValue?
+ */
+function parseInputValueDef(parser) {
+  var start = parser.token.start;
+  var name = parseName(parser);
+  expect(parser, _lexer.TokenKind.COLON);
+  var type = parseType(parser, false);
+  var defaultValue = null;
+  if (skip(parser, _lexer.TokenKind.EQUALS)) {
+    defaultValue = parseConstValue(parser);
+  }
+  return {
+    kind: _kinds.INPUT_VALUE_DEFINITION,
+    name: name,
+    type: type,
+    defaultValue: defaultValue,
+    loc: loc(parser, start)
+  };
+}
+
+/**
+ * InterfaceTypeDefinition : interface Name { FieldDefinition+ }
+ */
+function parseInterfaceTypeDefinition(parser) {
+  var start = parser.token.start;
+  expectKeyword(parser, 'interface');
+  var name = parseName(parser);
+  var fields = any(parser, _lexer.TokenKind.BRACE_L, parseFieldDefinition, _lexer.TokenKind.BRACE_R);
+  return {
+    kind: _kinds.INTERFACE_TYPE_DEFINITION,
+    name: name,
+    fields: fields,
+    loc: loc(parser, start)
+  };
+}
+
+/**
+ * UnionTypeDefinition : union Name = UnionMembers
+ */
+function parseUnionTypeDefinition(parser) {
+  var start = parser.token.start;
+  expectKeyword(parser, 'union');
+  var name = parseName(parser);
+  expect(parser, _lexer.TokenKind.EQUALS);
+  var types = parseUnionMembers(parser);
+  return {
+    kind: _kinds.UNION_TYPE_DEFINITION,
+    name: name,
+    types: types,
+    loc: loc(parser, start)
+  };
+}
+
+/**
+ * UnionMembers :
+ *   - NamedType
+ *   - UnionMembers | NamedType
+ */
+function parseUnionMembers(parser) {
+  var members = [];
+  do {
+    members.push(parseNamedType(parser));
+  } while (skip(parser, _lexer.TokenKind.PIPE));
+  return members;
+}
+
+/**
+ * ScalarTypeDefinition : scalar Name
+ */
+function parseScalarTypeDefinition(parser) {
+  var start = parser.token.start;
+  expectKeyword(parser, 'scalar');
+  var name = parseName(parser);
+  return {
+    kind: _kinds.SCALAR_TYPE_DEFINITION,
+    name: name,
+    loc: loc(parser, start)
+  };
+}
+
+/**
+ * EnumTypeDefinition : enum Name { EnumValueDefinition+ }
+ */
+function parseEnumTypeDefinition(parser) {
+  var start = parser.token.start;
+  expectKeyword(parser, 'enum');
+  var name = parseName(parser);
+  var values = many(parser, _lexer.TokenKind.BRACE_L, parseEnumValueDefinition, _lexer.TokenKind.BRACE_R);
+  return {
+    kind: _kinds.ENUM_TYPE_DEFINITION,
+    name: name,
+    values: values,
+    loc: loc(parser, start)
+  };
+}
+
+/**
+ * EnumValueDefinition : EnumValue
+ *
+ * EnumValue : Name
+ */
+function parseEnumValueDefinition(parser) {
+  var start = parser.token.start;
+  var name = parseName(parser);
+  return {
+    kind: _kinds.ENUM_VALUE_DEFINITION,
+    name: name,
+    loc: loc(parser, start)
+  };
+}
+
+/**
+ * InputObjectTypeDefinition : input Name { InputValueDefinition+ }
+ */
+function parseInputObjectTypeDefinition(parser) {
+  var start = parser.token.start;
+  expectKeyword(parser, 'input');
+  var name = parseName(parser);
+  var fields = any(parser, _lexer.TokenKind.BRACE_L, parseInputValueDef, _lexer.TokenKind.BRACE_R);
+  return {
+    kind: _kinds.INPUT_OBJECT_TYPE_DEFINITION,
+    name: name,
+    fields: fields,
+    loc: loc(parser, start)
+  };
+}
+
+/**
+ * TypeExtensionDefinition : extend ObjectTypeDefinition
+ */
+function parseTypeExtensionDefinition(parser) {
+  var start = parser.token.start;
+  expectKeyword(parser, 'extend');
+  var definition = parseObjectTypeDefinition(parser);
+  return {
+    kind: _kinds.TYPE_EXTENTION_DEFINITION,
+    definition: definition,
+    loc: loc(parser, start)
+  };
+}
+
+// Core parsing utility functions
+
+/**
+ * Returns the parser object that is used to store state throughout the
+ * process of parsing.
+ */
+function makeParser(source, options) {
+  var _lexToken = (0, _lexer.lex)(source);
+  return {
+    _lexToken: _lexToken,
+    source: source,
+    options: options,
+    prevEnd: 0,
+    token: _lexToken()
+  };
+}
+
+/**
+ * Returns a location object, used to identify the place in
+ * the source that created a given parsed object.
+ */
+function loc(parser, start) {
+  if (parser.options.noLocation) {
+    return null;
+  }
+  if (parser.options.noSource) {
+    return { start: start, end: parser.prevEnd };
+  }
+  return { start: start, end: parser.prevEnd, source: parser.source };
+}
+
+/**
+ * Moves the internal parser object to the next lexed token.
+ */
+function advance(parser) {
+  var prevEnd = parser.token.end;
+  parser.prevEnd = prevEnd;
+  parser.token = parser._lexToken(prevEnd);
+}
+
+/**
+ * Determines if the next token is of a given kind
+ */
+function peek(parser, kind) {
+  return parser.token.kind === kind;
+}
+
+/**
+ * If the next token is of the given kind, return true after advancing
+ * the parser. Otherwise, do not change the parser state and return false.
+ */
+function skip(parser, kind) {
+  var match = parser.token.kind === kind;
+  if (match) {
+    advance(parser);
+  }
+  return match;
+}
+
+/**
+ * If the next token is of the given kind, return that token after advancing
+ * the parser. Otherwise, do not change the parser state and return false.
+ */
+function expect(parser, kind) {
+  var token = parser.token;
+  if (token.kind === kind) {
+    advance(parser);
+    return token;
+  }
+  throw (0, _error.syntaxError)(parser.source, token.start, 'Expected ' + (0, _lexer.getTokenKindDesc)(kind) + ', found ' + (0, _lexer.getTokenDesc)(token));
+}
+
+/**
+ * If the next token is a keyword with the given value, return that token after
+ * advancing the parser. Otherwise, do not change the parser state and return
+ * false.
+ */
+function expectKeyword(parser, value) {
+  var token = parser.token;
+  if (token.kind === _lexer.TokenKind.NAME && token.value === value) {
+    advance(parser);
+    return token;
+  }
+  throw (0, _error.syntaxError)(parser.source, token.start, 'Expected "' + value + '", found ' + (0, _lexer.getTokenDesc)(token));
+}
+
+/**
+ * Helper function for creating an error when an unexpected lexed token
+ * is encountered.
+ */
+function unexpected(parser, atToken) {
+  var token = atToken || parser.token;
+  return (0, _error.syntaxError)(parser.source, token.start, 'Unexpected ' + (0, _lexer.getTokenDesc)(token));
+}
+
+/**
+ * Returns a possibly empty list of parse nodes, determined by
+ * the parseFn. This list begins with a lex token of openKind
+ * and ends with a lex token of closeKind. Advances the parser
+ * to the next lex token after the closing token.
+ */
+function any(parser, openKind, parseFn, closeKind) {
+  expect(parser, openKind);
+  var nodes = [];
+  while (!skip(parser, closeKind)) {
+    nodes.push(parseFn(parser));
+  }
+  return nodes;
+}
+
+/**
+ * Returns a non-empty list of parse nodes, determined by
+ * the parseFn. This list begins with a lex token of openKind
+ * and ends with a lex token of closeKind. Advances the parser
+ * to the next lex token after the closing token.
+ */
+function many(parser, openKind, parseFn, closeKind) {
+  expect(parser, openKind);
+  var nodes = [parseFn(parser)];
+  while (!skip(parser, closeKind)) {
+    nodes.push(parseFn(parser));
+  }
+  return nodes;
+}
+
+/**
+ * By default, the parser creates AST nodes that know the location
+ * in the source that they correspond to. This configuration flag
+ * disables that behavior for performance or testing.
+ */
+
+/**
+ * By default, the parser creates AST nodes that contain a reference
+ * to the source that they were created from. This configuration flag
+ * disables that behavior for performance or testing.
+ */

language/printer.js

@@ -16,5 +16,2 @@ /**
 exports.print = print;
-exports.join = join;
-exports.block = block;
-exports.wrap = wrap;
 
@@ -162,6 +159,67 @@ var _visitor = require('./visitor');
     return type + '!';
+  },
+
+  // Type Definitions
+
+  ObjectTypeDefinition: function ObjectTypeDefinition(_ref20) {
+    var name = _ref20.name;
+    var interfaces = _ref20.interfaces;
+    var fields = _ref20.fields;
+    return 'type ' + name + ' ' + wrap('implements ', join(interfaces, ', '), ' ') + block(fields);
+  },
+
+  FieldDefinition: function FieldDefinition(_ref21) {
+    var name = _ref21.name;
+    var args = _ref21.arguments;
+    var type = _ref21.type;
+    return name + wrap('(', join(args, ', '), ')') + ': ' + type;
+  },
+
+  InputValueDefinition: function InputValueDefinition(_ref22) {
+    var name = _ref22.name;
+    var type = _ref22.type;
+    var defaultValue = _ref22.defaultValue;
+    return name + ': ' + type + wrap(' = ', defaultValue);
+  },
+
+  InterfaceTypeDefinition: function InterfaceTypeDefinition(_ref23) {
+    var name = _ref23.name;
+    var fields = _ref23.fields;
+    return 'interface ' + name + ' ' + block(fields);
+  },
+
+  UnionTypeDefinition: function UnionTypeDefinition(_ref24) {
+    var name = _ref24.name;
+    var types = _ref24.types;
+    return 'union ' + name + ' = ' + join(types, ' | ');
+  },
+
+  ScalarTypeDefinition: function ScalarTypeDefinition(_ref25) {
+    var name = _ref25.name;
+    return 'scalar ' + name;
+  },
+
+  EnumTypeDefinition: function EnumTypeDefinition(_ref26) {
+    var name = _ref26.name;
+    var values = _ref26.values;
+    return 'enum ' + name + ' ' + block(values);
+  },
+
+  EnumValueDefinition: function EnumValueDefinition(_ref27) {
+    var name = _ref27.name;
+    return name;
+  },
+
+  InputObjectTypeDefinition: function InputObjectTypeDefinition(_ref28) {
+    var name = _ref28.name;
+    var fields = _ref28.fields;
+    return 'input ' + name + ' ' + block(fields);
+  },
+
+  TypeExtensionDefinition: function TypeExtensionDefinition(_ref29) {
+    var definition = _ref29.definition;
+    return 'extend ' + definition;
   }
 };
 
-exports.printDocASTReducer = printDocASTReducer;
 /**
@@ -171,3 +229,2 @@ * Given maybeArray, print an empty string if it is null or empty, otherwise
  */
-
 function join(maybeArray, separator) {
@@ -183,3 +240,2 @@ return maybeArray ? maybeArray.filter(function (x) {
  */
-
 function block(maybeArray) {
@@ -193,3 +249,2 @@ return length(maybeArray) ? indent('{\n' + join(maybeArray, '\n')) + '\n}' : '';
  */
-
 function wrap(start, maybeString, end) {
@@ -196,0 +251,0 @@ return maybeString ? start + maybeString + (end || '') : '';

language/visitor.js

@@ -47,3 +47,14 @@ /**
   ListType: ['type'],
-  NonNullType: ['type']
+  NonNullType: ['type'],
+
+  ObjectTypeDefinition: ['name', 'interfaces', 'fields'],
+  FieldDefinition: ['name', 'arguments', 'type'],
+  InputValueDefinition: ['name', 'type', 'defaultValue'],
+  InterfaceTypeDefinition: ['name', 'fields'],
+  UnionTypeDefinition: ['name', 'types'],
+  ScalarTypeDefinition: ['name'],
+  EnumTypeDefinition: ['name', 'values'],
+  EnumValueDefinition: ['name'],
+  InputObjectTypeDefinition: ['name', 'fields'],
+  TypeExtensionDefinition: ['definition']
 };
@@ -50,0 +61,0 @@

package.json

 {
   "name": "graphql",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "A Query Language and Runtime which can target any service.",
@@ -46,3 +46,3 @@ "contributors": [
     "babel-core": "5.8.22",
-    "babel-eslint": "4.0.5",
+    "babel-eslint": "4.0.10",
     "bluebird": "2.9.34",
@@ -53,2 +53,3 @@ "chai": "3.2.0",
     "eslint": "1.1.0",
+    "eslint-plugin-babel": "^2.1.1",
     "flow-bin": "0.14.0",
@@ -55,0 +56,0 @@ "isparta": "3.0.3",

README.md

@@ -53,3 +53,3 @@ # GraphQL.js
 ```sh
-npm install graphql
+npm install --save graphql
 ```
@@ -56,0 +56,0 @@

type/definition.js

@@ -22,2 +22,4 @@
 
+var _extends = require('babel-runtime/helpers/extends')['default'];
+
 var _Object$keys = require('babel-runtime/core-js/object/keys')['default'];
@@ -148,2 +150,3 @@
     (0, _jsutilsInvariant2['default'])(config.name, 'Type must be named.');
+    assertValidName(config.name);
     this.name = config.name;
@@ -232,2 +235,3 @@ this.description = config.description;
     (0, _jsutilsInvariant2['default'])(config.name, 'Type must be named.');
+    assertValidName(config.name);
     this.name = config.name;
@@ -287,7 +291,12 @@ this.description = config.description;
   (0, _jsutilsInvariant2['default'])(isPlainObj(fieldMap), type + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
+
   var fieldNames = _Object$keys(fieldMap);
   (0, _jsutilsInvariant2['default'])(fieldNames.length > 0, type + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
+
+  var resultFieldMap = {};
   fieldNames.forEach(function (fieldName) {
-    var field = fieldMap[fieldName];
-    field.name = fieldName;
+    assertValidName(fieldName);
+    var field = _extends({}, fieldMap[fieldName], {
+      name: fieldName
+    });
     (0, _jsutilsInvariant2['default'])(isOutputType(field.type), type + '.' + fieldName + ' field type must be Output Type but ' + ('got: ' + field.type + '.'));
@@ -299,2 +308,3 @@ if (!field.args) {
       field.args = _Object$keys(field.args).map(function (argName) {
+        assertValidName(argName);
         var arg = field.args[argName];
@@ -310,4 +320,5 @@ (0, _jsutilsInvariant2['default'])(isInputType(arg.type), type + '.' + fieldName + '(' + argName + ':) argument type must be ' + ('Input Type but got: ' + arg.type + '.'));
     }
+    resultFieldMap[fieldName] = field;
   });
-  return fieldMap;
+  return resultFieldMap;
 }
@@ -355,2 +366,3 @@
     (0, _jsutilsInvariant2['default'])(config.name, 'Type must be named.');
+    assertValidName(config.name);
     this.name = config.name;
@@ -443,2 +455,3 @@ this.description = config.description;
     (0, _jsutilsInvariant2['default'])(config.name, 'Type must be named.');
+    assertValidName(config.name);
     this.name = config.name;
@@ -522,2 +535,3 @@ this.description = config.description;
     this.name = config.name;
+    assertValidName(config.name);
     this.description = config.description;
@@ -599,2 +613,3 @@ this._values = defineEnumValues(this, config.values);
   return valueNames.map(function (valueName) {
+    assertValidName(valueName);
     var value = valueMap[valueName];
@@ -638,2 +653,3 @@ (0, _jsutilsInvariant2['default'])(isPlainObj(value), type + '.' + valueName + ' must refer to an object with a "value" key ' + ('representing an internal value but got: ' + value + '.'));
     (0, _jsutilsInvariant2['default'])(config.name, 'Type must be named.');
+    assertValidName(config.name);
     this.name = config.name;
@@ -658,8 +674,12 @@ this.description = config.description;
       (0, _jsutilsInvariant2['default'])(fieldNames.length > 0, this + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
+      var resultFieldMap = {};
       fieldNames.forEach(function (fieldName) {
-        var field = fieldMap[fieldName];
-        field.name = fieldName;
+        assertValidName(fieldName);
+        var field = _extends({}, fieldMap[fieldName], {
+          name: fieldName
+        });
         (0, _jsutilsInvariant2['default'])(isInputType(field.type), _this2 + '.' + fieldName + ' field type must be Input Type but ' + ('got: ' + field.type + '.'));
+        resultFieldMap[fieldName] = field;
       });
-      return fieldMap;
+      return resultFieldMap;
     }
@@ -719,3 +739,3 @@ }, {
    *       fields: () => ({
-   *         id: { type: new GraphQLNonNull(String) },
+   *         id: { type: new GraphQLNonNull(GraphQLString) },
    *       })
@@ -758,6 +778,13 @@ *     })
 exports.GraphQLNonNull = GraphQLNonNull;
+
+var NAME_RX = /^[_a-zA-Z][_a-zA-Z0-9]*$/;
+
+// Helper to assert that provided names are valid.
+function assertValidName(name) {
+  (0, _jsutilsInvariant2['default'])(NAME_RX.test(name), 'Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "' + name + '" does not.');
+}
 /* <T> */ /* T */ /* T */
 /**
  * Optionally provide a custom type resolver function. If one is not provided,
- * the default implemenation will call `isTypeOf` on each implementing
+ * the default implementation will call `isTypeOf` on each implementing
  * Object type.
@@ -768,5 +795,5 @@ */
  * Optionally provide a custom type resolver function. If one is not provided,
- * the default implemenation will call `isTypeOf` on each implementing
+ * the default implementation will call `isTypeOf` on each implementing
  * Object type.
  */
 /* <T> */ /* <T> */ /* T */ /* T */ /* <T> */ /* <T> */ /* <T> */ /* <T> */ /* T */ /* <T> */ /* T */

type/schema.js

@@ -157,2 +157,3 @@
         var field = fieldMap[fieldName];
+
         if (field.args) {
@@ -159,0 +160,0 @@ var fieldArgTypes = field.args.map(function (arg) {

utilities/buildASTSchema.js

@@ -35,6 +35,4 @@ /**
 
-var _languageSchemaKinds = require('../language/schema/kinds');
+var _languageAst = require('../language/ast');
 
-var _languageSchemaAst = require('../language/schema/ast');
-
 var _type = require('../type');
@@ -86,3 +84,15 @@
 
-  var astMap = (0, _jsutilsKeyMap2['default'])(ast.definitions, function (d) {
+  var typeDefs = ast.definitions.filter(function (d) {
+    switch (d.kind) {
+      case _languageKinds.OBJECT_TYPE_DEFINITION:
+      case _languageKinds.INTERFACE_TYPE_DEFINITION:
+      case _languageKinds.ENUM_TYPE_DEFINITION:
+      case _languageKinds.UNION_TYPE_DEFINITION:
+      case _languageKinds.SCALAR_TYPE_DEFINITION:
+      case _languageKinds.INPUT_OBJECT_TYPE_DEFINITION:
+        return true;
+    }
+  });
+
+  var astMap = (0, _jsutilsKeyMap2['default'])(typeDefs, function (d) {
     return d.name.value;
@@ -156,13 +166,13 @@ });
     switch (def.kind) {
-      case _languageSchemaKinds.TYPE_DEFINITION:
+      case _languageKinds.OBJECT_TYPE_DEFINITION:
         return makeTypeDef(def);
-      case _languageSchemaKinds.INTERFACE_DEFINITION:
+      case _languageKinds.INTERFACE_TYPE_DEFINITION:
         return makeInterfaceDef(def);
-      case _languageSchemaKinds.ENUM_DEFINITION:
+      case _languageKinds.ENUM_TYPE_DEFINITION:
         return makeEnumDef(def);
-      case _languageSchemaKinds.UNION_DEFINITION:
+      case _languageKinds.UNION_TYPE_DEFINITION:
         return makeUnionDef(def);
-      case _languageSchemaKinds.SCALAR_DEFINITION:
+      case _languageKinds.SCALAR_TYPE_DEFINITION:
         return makeScalarDef(def);
-      case _languageSchemaKinds.INPUT_OBJECT_DEFINITION:
+      case _languageKinds.INPUT_OBJECT_TYPE_DEFINITION:
         return makeInputObjectDef(def);
@@ -169,0 +179,0 @@ default:

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

284610

decreased by-1.55%

Dev dependency count

14

increased by7.69%

Number of package files

71

decreased by-8.97%

Lines of code

7602

decreased by-0.47%

No dependency changes