graphql 15.1.0 → 15.4.0

package/language/parser.js

@@ -6,26 +6,21 @@ Object.defineProperty(exports, "__esModule", {
 exports.parse = parse;
 exports.parseValue = parseValue;
 exports.parseType = parseType;
+exports.Parser = void 0;
 
-var _inspect = _interopRequireDefault(require("../jsutils/inspect"));
+var _syntaxError = require("../error/syntaxError.js");
 
-var _devAssert = _interopRequireDefault(require("../jsutils/devAssert"));
+var _kinds = require("./kinds.js");
 
-var _syntaxError = require("../error/syntaxError");
+var _ast = require("./ast.js");
 
-var _kinds = require("./kinds");
+var _tokenKind = require("./tokenKind.js");
 
-var _source = require("./source");
+var _source = require("./source.js");
 
-var _directiveLocation = require("./directiveLocation");
+var _directiveLocation = require("./directiveLocation.js");
 
-var _tokenKind = require("./tokenKind");
-
-var _lexer = require("./lexer");
-
-var _ast = require("./ast");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _lexer = require("./lexer.js");
 
 /**
  * Given a GraphQL source, parses it into a Document.
@@ -73,11 +68,22 @@ function parseType(source, options) {
   parser.expectToken(_tokenKind.TokenKind.EOF);
   return type;
 }
+/**
+ * This class is exported only to assist people in implementing their own parsers
+ * without duplicating too much code and should be used only as last resort for cases
+ * such as experimental syntax or if certain features could not be contributed upstream.
+ *
+ * It is still part of the internal API and is versioned, so any changes to it are never
+ * considered breaking changes. If you still need to support multiple versions of the
+ * library, please use the `versionInfo` variable for version detection.
+ *
+ * @internal
+ */
+
 
 var Parser = /*#__PURE__*/function () {
   function Parser(source, options) {
-    var sourceObj = typeof source === 'string' ? new _source.Source(source) : source;
-    sourceObj instanceof _source.Source || (0, _devAssert.default)(0, "Must provide Source. Received: ".concat((0, _inspect.default)(sourceObj), "."));
+    var sourceObj = (0, _source.isSource)(source) ? source : new _source.Source(source);
     this._lexer = new _lexer.Lexer(sourceObj);
     this._options = options;
   }
@@ -822,21 +828,25 @@ var Parser = /*#__PURE__*/function () {
   ;
 
   _proto.parseImplementsInterfaces = function parseImplementsInterfaces() {
-    var types = [];
+    var _this$_options2;
+
+    if (!this.expectOptionalKeyword('implements')) {
+      return [];
+    }
+
+    if (((_this$_options2 = this._options) === null || _this$_options2 === void 0 ? void 0 : _this$_options2.allowLegacySDLImplementsInterfaces) === true) {
+      var types = []; // Optional leading ampersand
 
-    if (this.expectOptionalKeyword('implements')) {
-      // Optional leading ampersand
       this.expectOptionalToken(_tokenKind.TokenKind.AMP);
 
       do {
-        var _this$_options2;
-
         types.push(this.parseNamedType());
-      } while (this.expectOptionalToken(_tokenKind.TokenKind.AMP) || // Legacy support for the SDL?
-      ((_this$_options2 = this._options) === null || _this$_options2 === void 0 ? void 0 : _this$_options2.allowLegacySDLImplementsInterfaces) === true && this.peek(_tokenKind.TokenKind.NAME));
+      } while (this.expectOptionalToken(_tokenKind.TokenKind.AMP) || this.peek(_tokenKind.TokenKind.NAME));
+
+      return types;
     }
 
-    return types;
+    return this.delimitedMany(_tokenKind.TokenKind.AMP, this.parseNamedType);
   }
   /**
    * FieldsDefinition : { FieldDefinition+ }
@@ -972,18 +982,7 @@ var Parser = /*#__PURE__*/function () {
   ;
 
   _proto.parseUnionMemberTypes = function parseUnionMemberTypes() {
-    var types = [];
-
-    if (this.expectOptionalToken(_tokenKind.TokenKind.EQUALS)) {
-      // Optional leading pipe
-      this.expectOptionalToken(_tokenKind.TokenKind.PIPE);
-
-      do {
-        types.push(this.parseNamedType());
-      } while (this.expectOptionalToken(_tokenKind.TokenKind.PIPE));
-    }
-
-    return types;
+    return this.expectOptionalToken(_tokenKind.TokenKind.EQUALS) ? this.delimitedMany(_tokenKind.TokenKind.PIPE, this.parseNamedType) : [];
   }
   /**
    * EnumTypeDefinition :
@@ -1334,15 +1333,7 @@ var Parser = /*#__PURE__*/function () {
   ;
 
   _proto.parseDirectiveLocations = function parseDirectiveLocations() {
-    // Optional leading pipe
-    this.expectOptionalToken(_tokenKind.TokenKind.PIPE);
-    var locations = [];
-
-    do {
-      locations.push(this.parseDirectiveLocation());
-    } while (this.expectOptionalToken(_tokenKind.TokenKind.PIPE));
-
-    return locations;
+    return this.delimitedMany(_tokenKind.TokenKind.PIPE, this.parseDirectiveLocation);
   }
   /*
    * DirectiveLocation :
@@ -1385,8 +1376,7 @@ var Parser = /*#__PURE__*/function () {
   } // Core parsing utility functions
 
   /**
-   * Returns a location object, used to identify the place in
-   * the source that created a given parsed object.
+   * Returns a location object, used to identify the place in the source that created a given parsed object.
    */
   ;
 
@@ -1406,8 +1396,8 @@ var Parser = /*#__PURE__*/function () {
     return this._lexer.token.kind === kind;
   }
   /**
-   * If the next token is of the given kind, return that token after advancing
-   * the lexer. Otherwise, do not change the parser state and throw an error.
+   * If the next token is of the given kind, return that token after advancing the lexer.
+   * Otherwise, do not change the parser state and throw an error.
    */
   ;
 
@@ -1423,8 +1413,8 @@ var Parser = /*#__PURE__*/function () {
     throw (0, _syntaxError.syntaxError)(this._lexer.source, token.start, "Expected ".concat(getTokenKindDesc(kind), ", found ").concat(getTokenDesc(token), "."));
   }
   /**
-   * If the next token is of the given kind, return that token after advancing
-   * the lexer. Otherwise, do not change the parser state and return undefined.
+   * If the next token is of the given kind, return that token after advancing the lexer.
+   * Otherwise, do not change the parser state and return undefined.
    */
   ;
 
@@ -1455,8 +1445,8 @@ var Parser = /*#__PURE__*/function () {
     }
   }
   /**
-   * If the next token is a given keyword, return "true" after advancing
-   * the lexer. Otherwise, do not change the parser state and return "false".
+   * If the next token is a given keyword, return "true" after advancing the lexer.
+   * Otherwise, do not change the parser state and return "false".
    */
   ;
 
@@ -1472,8 +1462,7 @@ var Parser = /*#__PURE__*/function () {
     return false;
   }
   /**
-   * Helper function for creating an error when an unexpected lexed token
-   * is encountered.
+   * Helper function for creating an error when an unexpected lexed token is encountered.
    */
   ;
 
@@ -1482,10 +1471,9 @@ var Parser = /*#__PURE__*/function () {
     return (0, _syntaxError.syntaxError)(this._lexer.source, token.start, "Unexpected ".concat(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.
+   * 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.
    */
   ;
 
@@ -1501,10 +1489,9 @@ var Parser = /*#__PURE__*/function () {
   }
   /**
    * Returns a list of parse nodes, determined by the parseFn.
-   * It can be empty only if open token is missing otherwise it will always
-   * return non-empty list that 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.
+   * It can be empty only if open token is missing otherwise it will always return non-empty list
+   * that 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.
    */
   ;
 
@@ -1522,10 +1509,9 @@ var Parser = /*#__PURE__*/function () {
     return [];
   }
   /**
-   * 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.
+   * 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.
    */
   ;
 
@@ -1537,22 +1523,41 @@ var Parser = /*#__PURE__*/function () {
       nodes.push(parseFn.call(this));
     } while (!this.expectOptionalToken(closeKind));
 
+    return nodes;
+  }
+  /**
+   * Returns a non-empty list of parse nodes, determined by the parseFn.
+   * This list may begin with a lex token of delimiterKind followed by items separated by lex tokens of tokenKind.
+   * Advances the parser to the next lex token after last item in the list.
+   */
+  ;
+
+  _proto.delimitedMany = function delimitedMany(delimiterKind, parseFn) {
+    this.expectOptionalToken(delimiterKind);
+    var nodes = [];
+
+    do {
+      nodes.push(parseFn.call(this));
+    } while (this.expectOptionalToken(delimiterKind));
+
     return nodes;
   };
 
   return Parser;
 }();
 /**
- * A helper function to describe a token as a string for debugging
+ * A helper function to describe a token as a string for debugging.
  */
 
 
+exports.Parser = Parser;
+
 function getTokenDesc(token) {
   var value = token.value;
   return getTokenKindDesc(token.kind) + (value != null ? " \"".concat(value, "\"") : '');
 }
 /**
- * A helper function to describe a token kind as a string for debugging
+ * A helper function to describe a token kind as a string for debugging.
  */
 
 

package/language/parser.js.flow

@@ -1,63 +1,60 @@
 // @flow strict
-
-import inspect from '../jsutils/inspect';
-import devAssert from '../jsutils/devAssert';
-
+import type { GraphQLError } from '../error/GraphQLError';
 import { syntaxError } from '../error/syntaxError';
-import { type GraphQLError } from '../error/GraphQLError';
 
+import type { TokenKindEnum } from './tokenKind';
+import type {
+  Token,
+  NameNode,
+  VariableNode,
+  DocumentNode,
+  DefinitionNode,
+  OperationDefinitionNode,
+  OperationTypeNode,
+  VariableDefinitionNode,
+  SelectionSetNode,
+  SelectionNode,
+  FieldNode,
+  ArgumentNode,
+  FragmentSpreadNode,
+  InlineFragmentNode,
+  FragmentDefinitionNode,
+  ValueNode,
+  StringValueNode,
+  ListValueNode,
+  ObjectValueNode,
+  ObjectFieldNode,
+  DirectiveNode,
+  TypeNode,
+  NamedTypeNode,
+  TypeSystemDefinitionNode,
+  SchemaDefinitionNode,
+  OperationTypeDefinitionNode,
+  ScalarTypeDefinitionNode,
+  ObjectTypeDefinitionNode,
+  FieldDefinitionNode,
+  InputValueDefinitionNode,
+  InterfaceTypeDefinitionNode,
+  UnionTypeDefinitionNode,
+  EnumTypeDefinitionNode,
+  EnumValueDefinitionNode,
+  InputObjectTypeDefinitionNode,
+  DirectiveDefinitionNode,
+  TypeSystemExtensionNode,
+  SchemaExtensionNode,
+  ScalarTypeExtensionNode,
+  ObjectTypeExtensionNode,
+  InterfaceTypeExtensionNode,
+  UnionTypeExtensionNode,
+  EnumTypeExtensionNode,
+  InputObjectTypeExtensionNode,
+} from './ast';
 import { Kind } from './kinds';
-import { Source } from './source';
+import { Location } from './ast';
+import { TokenKind } from './tokenKind';
+import { Source, isSource } from './source';
 import { DirectiveLocation } from './directiveLocation';
-import { type TokenKindEnum, TokenKind } from './tokenKind';
 import { Lexer, isPunctuatorTokenKind } from './lexer';
-import {
-  Location,
-  type Token,
-  type NameNode,
-  type VariableNode,
-  type DocumentNode,
-  type DefinitionNode,
-  type OperationDefinitionNode,
-  type OperationTypeNode,
-  type VariableDefinitionNode,
-  type SelectionSetNode,
-  type SelectionNode,
-  type FieldNode,
-  type ArgumentNode,
-  type FragmentSpreadNode,
-  type InlineFragmentNode,
-  type FragmentDefinitionNode,
-  type ValueNode,
-  type StringValueNode,
-  type ListValueNode,
-  type ObjectValueNode,
-  type ObjectFieldNode,
-  type DirectiveNode,
-  type TypeNode,
-  type NamedTypeNode,
-  type TypeSystemDefinitionNode,
-  type SchemaDefinitionNode,
-  type OperationTypeDefinitionNode,
-  type ScalarTypeDefinitionNode,
-  type ObjectTypeDefinitionNode,
-  type FieldDefinitionNode,
-  type InputValueDefinitionNode,
-  type InterfaceTypeDefinitionNode,
-  type UnionTypeDefinitionNode,
-  type EnumTypeDefinitionNode,
-  type EnumValueDefinitionNode,
-  type InputObjectTypeDefinitionNode,
-  type DirectiveDefinitionNode,
-  type TypeSystemExtensionNode,
-  type SchemaExtensionNode,
-  type ScalarTypeExtensionNode,
-  type ObjectTypeExtensionNode,
-  type InterfaceTypeExtensionNode,
-  type UnionTypeExtensionNode,
-  type EnumTypeExtensionNode,
-  type InputObjectTypeExtensionNode,
-} from './ast';
 
 /**
  * Configuration options to control parser behavior
@@ -163,16 +160,23 @@ export function parseType(
   return type;
 }
 
-class Parser {
+/**
+ * This class is exported only to assist people in implementing their own parsers
+ * without duplicating too much code and should be used only as last resort for cases
+ * such as experimental syntax or if certain features could not be contributed upstream.
+ *
+ * It is still part of the internal API and is versioned, so any changes to it are never
+ * considered breaking changes. If you still need to support multiple versions of the
+ * library, please use the `versionInfo` variable for version detection.
+ *
+ * @internal
+ */
+export class Parser {
   _options: ?ParseOptions;
   _lexer: Lexer;
 
   constructor(source: string | Source, options?: ParseOptions) {
-    const sourceObj = typeof source === 'string' ? new Source(source) : source;
-    devAssert(
-      sourceObj instanceof Source,
-      `Must provide Source. Received: ${inspect(sourceObj)}.`,
-    );
+    const sourceObj = isSource(source) ? source : new Source(source);
 
     this._lexer = new Lexer(sourceObj);
     this._options = options;
@@ -852,20 +856,24 @@ class Parser {
    *   - ImplementsInterfaces & NamedType
    */
   parseImplementsInterfaces(): Array<NamedTypeNode> {
-    const types = [];
-    if (this.expectOptionalKeyword('implements')) {
+    if (!this.expectOptionalKeyword('implements')) {
+      return [];
+    }
+
+    if (this._options?.allowLegacySDLImplementsInterfaces === true) {
+      const types = [];
       // Optional leading ampersand
       this.expectOptionalToken(TokenKind.AMP);
       do {
         types.push(this.parseNamedType());
       } while (
         this.expectOptionalToken(TokenKind.AMP) ||
-        // Legacy support for the SDL?
-        (this._options?.allowLegacySDLImplementsInterfaces === true &&
-          this.peek(TokenKind.NAME))
+        this.peek(TokenKind.NAME)
       );
+      return types;
     }
-    return types;
+
+    return this.delimitedMany(TokenKind.AMP, this.parseNamedType);
   }
 
   /**
@@ -999,15 +1007,9 @@ class Parser {
    *   - UnionMemberTypes | NamedType
    */
   parseUnionMemberTypes(): Array<NamedTypeNode> {
-    const types = [];
-    if (this.expectOptionalToken(TokenKind.EQUALS)) {
-      // Optional leading pipe
-      this.expectOptionalToken(TokenKind.PIPE);
-      do {
-        types.push(this.parseNamedType());
-      } while (this.expectOptionalToken(TokenKind.PIPE));
-    }
-    return types;
+    return this.expectOptionalToken(TokenKind.EQUALS)
+      ? this.delimitedMany(TokenKind.PIPE, this.parseNamedType)
+      : [];
   }
 
   /**
@@ -1343,13 +1345,7 @@ class Parser {
    *   - DirectiveLocations | DirectiveLocation
    */
   parseDirectiveLocations(): Array<NameNode> {
-    // Optional leading pipe
-    this.expectOptionalToken(TokenKind.PIPE);
-    const locations = [];
-    do {
-      locations.push(this.parseDirectiveLocation());
-    } while (this.expectOptionalToken(TokenKind.PIPE));
-    return locations;
+    return this.delimitedMany(TokenKind.PIPE, this.parseDirectiveLocation);
   }
 
   /*
@@ -1391,8 +1387,7 @@ class Parser {
   // Core parsing utility functions
 
   /**
-   * Returns a location object, used to identify the place in
-   * the source that created a given parsed object.
+   * Returns a location object, used to identify the place in the source that created a given parsed object.
    */
   loc(startToken: Token): Location | void {
     if (this._options?.noLocation !== true) {
@@ -1412,8 +1407,8 @@ class Parser {
   }
 
   /**
-   * If the next token is of the given kind, return that token after advancing
-   * the lexer. Otherwise, do not change the parser state and throw an error.
+   * If the next token is of the given kind, return that token after advancing the lexer.
+   * Otherwise, do not change the parser state and throw an error.
    */
   expectToken(kind: TokenKindEnum): Token {
     const token = this._lexer.token;
@@ -1430,8 +1425,8 @@ class Parser {
   }
 
   /**
-   * If the next token is of the given kind, return that token after advancing
-   * the lexer. Otherwise, do not change the parser state and return undefined.
+   * If the next token is of the given kind, return that token after advancing the lexer.
+   * Otherwise, do not change the parser state and return undefined.
    */
   expectOptionalToken(kind: TokenKindEnum): ?Token {
     const token = this._lexer.token;
@@ -1460,8 +1455,8 @@ class Parser {
   }
 
   /**
-   * If the next token is a given keyword, return "true" after advancing
-   * the lexer. Otherwise, do not change the parser state and return "false".
+   * If the next token is a given keyword, return "true" after advancing the lexer.
+   * Otherwise, do not change the parser state and return "false".
    */
   expectOptionalKeyword(value: string): boolean {
     const token = this._lexer.token;
@@ -1473,8 +1468,7 @@ class Parser {
   }
 
   /**
-   * Helper function for creating an error when an unexpected lexed token
-   * is encountered.
+   * Helper function for creating an error when an unexpected lexed token is encountered.
    */
   unexpected(atToken?: ?Token): GraphQLError {
     const token = atToken ?? this._lexer.token;
@@ -1486,10 +1480,9 @@ class Parser {
   }
 
   /**
-   * 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.
+   * 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.
    */
   any<T>(
     openKind: TokenKindEnum,
@@ -1506,10 +1499,9 @@ class Parser {
 
   /**
    * Returns a list of parse nodes, determined by the parseFn.
-   * It can be empty only if open token is missing otherwise it will always
-   * return non-empty list that 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.
+   * It can be empty only if open token is missing otherwise it will always return non-empty list
+   * that 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.
    */
   optionalMany<T>(
     openKind: TokenKindEnum,
@@ -1527,10 +1519,9 @@ class Parser {
   }
 
   /**
-   * 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.
+   * 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.
    */
   many<T>(
     openKind: TokenKindEnum,
@@ -1544,10 +1535,25 @@ class Parser {
     } while (!this.expectOptionalToken(closeKind));
     return nodes;
   }
+
+  /**
+   * Returns a non-empty list of parse nodes, determined by the parseFn.
+   * This list may begin with a lex token of delimiterKind followed by items separated by lex tokens of tokenKind.
+   * Advances the parser to the next lex token after last item in the list.
+   */
+  delimitedMany<T>(delimiterKind: TokenKindEnum, parseFn: () => T): Array<T> {
+    this.expectOptionalToken(delimiterKind);
+
+    const nodes = [];
+    do {
+      nodes.push(parseFn.call(this));
+    } while (this.expectOptionalToken(delimiterKind));
+    return nodes;
+  }
 }
 
 /**
- * A helper function to describe a token as a string for debugging
+ * A helper function to describe a token as a string for debugging.
  */
 function getTokenDesc(token: Token): string {
   const value = token.value;
@@ -1555,7 +1561,7 @@ function getTokenDesc(token: Token): string {
 }
 
 /**
- * A helper function to describe a token kind as a string for debugging
+ * A helper function to describe a token kind as a string for debugging.
  */
 function getTokenKindDesc(kind: TokenKindEnum): string {
   return isPunctuatorTokenKind(kind) ? `"${kind}"` : kind;