Merge pull request #506 from graphql/parse-type

Adds parseType()

Author: leebyron

src/index.js

@@ -112,6 +112,7 @@ export {
   // Parse
   parse,
   parseValue,
+  parseType,
 
   // Print
   print,

src/language/__tests__/parser-test.js

@@ -10,7 +10,7 @@
 import * as Kind from '../kinds';
 import { expect } from 'chai';
 import { describe, it } from 'mocha';
-import { parse } from '../parser';
+import { parse, parseValue, parseType } from '../parser';
 import { Source } from '../source';
 import { readFileSync } from 'fs';
 import { join } from 'path';
@@ -293,4 +293,93 @@ fragment ${fragmentName} on Type {
     expect(result.loc.startToken.kind).to.equal('<SOF>');
     expect(result.loc.endToken.kind).to.equal('<EOF>');
   });
+
+  describe('parseValue', () => {
+
+    it('parses list values', () => {
+      expect(parseValue('[123 "abc"]')).to.containSubset({
+        kind: Kind.LIST,
+        loc: { start: 0, end: 11 },
+        values: [
+          { kind: Kind.INT,
+            loc: { start: 1, end: 4},
+            value: '123' },
+          { kind: Kind.STRING,
+            loc: { start: 5, end: 10},
+            value: 'abc' } ]
+      });
+    });
+
+  });
+
+  describe('parseType', () => {
+
+    it('parses well known types', () => {
+      expect(parseType('String')).to.containSubset({
+        kind: Kind.NAMED_TYPE,
+        loc: { start: 0, end: 6 },
+        name: {
+          kind: Kind.NAME,
+          loc: { start: 0, end: 6 },
+          value: 'String' }
+      });
+    });
+
+    it('parses custom types', () => {
+      expect(parseType('MyType')).to.containSubset({
+        kind: Kind.NAMED_TYPE,
+        loc: { start: 0, end: 6 },
+        name: {
+          kind: Kind.NAME,
+          loc: { start: 0, end: 6 },
+          value: 'MyType' }
+      });
+    });
+
+    it('parses list types', () => {
+      expect(parseType('[MyType]')).to.containSubset({
+        kind: Kind.LIST_TYPE,
+        loc: { start: 0, end: 8 },
+        type: {
+          kind: Kind.NAMED_TYPE,
+          loc: { start: 1, end: 7 },
+          name: {
+            kind: Kind.NAME,
+            loc: { start: 1, end: 7 },
+            value: 'MyType' } }
+      });
+    });
+
+    it('parses non-null types', () => {
+      expect(parseType('MyType!')).to.containSubset({
+        kind: Kind.NON_NULL_TYPE,
+        loc: { start: 0, end: 7 },
+        type: {
+          kind: Kind.NAMED_TYPE,
+          loc: { start: 0, end: 6 },
+          name: {
+            kind: Kind.NAME,
+            loc: { start: 0, end: 6 },
+            value: 'MyType' } }
+      });
+    });
+
+    it('parses nested types', () => {
+      expect(parseType('[MyType!]')).to.containSubset({
+        kind: Kind.LIST_TYPE,
+        loc: { start: 0, end: 9 },
+        type: {
+          kind: Kind.NON_NULL_TYPE,
+          loc: { start: 1, end: 8 },
+          type: {
+            kind: Kind.NAMED_TYPE,
+            loc: { start: 1, end: 7 },
+            name: {
+              kind: Kind.NAME,
+              loc: { start: 1, end: 7 },
+              value: 'MyType' } } }
+      });
+    });
+
+  });
 });

src/language/index.js

@@ -12,7 +12,7 @@ export { getLocation } from './location';
 import * as Kind from './kinds';
 export { Kind };
 export { createLexer, TokenKind } from './lexer';
-export { parse, parseValue } from './parser';
+export { parse, parseValue, parseType } from './parser';
 export { print } from './printer';
 export { Source } from './source';
 export { visit, visitInParallel, visitWithTypeInfo, BREAK } from './visitor';

src/language/parser.js

@@ -145,11 +145,14 @@ export function parse(
 }
 
 /**
- * Given a string containing a GraphQL value, parse the AST for that value.
+ * Given a string containing a GraphQL value (ex. `[42]`), parse the AST for
+ * that value.
  * Throws GraphQLError if a syntax error is encountered.
  *
  * This is useful within tools that operate upon GraphQL Values directly and
  * in isolation of complete GraphQL documents.
+ *
+ * Consider providing the results to the utility function: valueFromAST().
  */
 export function parseValue(
   source: string | Source,
@@ -163,6 +166,28 @@ export function parseValue(
   return value;
 }
 
+/**
+ * Given a string containing a GraphQL Type (ex. `[Int!]`), parse the AST for
+ * that type.
+ * Throws GraphQLError if a syntax error is encountered.
+ *
+ * This is useful within tools that operate upon GraphQL Types directly and
+ * in isolation of complete GraphQL documents.
+ *
+ * Consider providing the results to the utility function: typeFromAST().
+ */
+export function parseType(
+  source: string | Source,
+  options?: ParseOptions
+): Type {
+  const sourceObj = typeof source === 'string' ? new Source(source) : source;
+  const lexer = createLexer(sourceObj, options || {});
+  expect(lexer, TokenKind.SOF);
+  const type = parseTypeReference(lexer);
+  expect(lexer, TokenKind.EOF);
+  return type;
+}
+
 /**
  * Converts a name lex token into a name parse node.
  */
@@ -306,7 +331,7 @@ function parseVariableDefinition(lexer: Lexer<*>): VariableDefinition {
   return {
     kind: VARIABLE_DEFINITION,
     variable: parseVariable(lexer),
-    type: (expect(lexer, TokenKind.COLON), parseType(lexer)),
+    type: (expect(lexer, TokenKind.COLON), parseTypeReference(lexer)),
     defaultValue:
       skip(lexer, TokenKind.EQUALS) ? parseValueLiteral(lexer, true) : null,
     loc: loc(lexer, start)
@@ -633,11 +658,11 @@ function parseDirective(lexer: Lexer<*>): Directive {
  *   - ListType
  *   - NonNullType
  */
-export function parseType(lexer: Lexer<*>): Type {
+export function parseTypeReference(lexer: Lexer<*>): Type {
   const start = lexer.token;
   let type;
   if (skip(lexer, TokenKind.BRACKET_L)) {
-    type = parseType(lexer);
+    type = parseTypeReference(lexer);
     expect(lexer, TokenKind.BRACKET_R);
     type = ({
       kind: LIST_TYPE,
@@ -807,7 +832,7 @@ function parseFieldDefinition(lexer: Lexer<*>): FieldDefinition {
   const name = parseName(lexer);
   const args = parseArgumentDefs(lexer);
   expect(lexer, TokenKind.COLON);
-  const type = parseType(lexer);
+  const type = parseTypeReference(lexer);
   const directives = parseDirectives(lexer);
   return {
     kind: FIELD_DEFINITION,
@@ -836,7 +861,7 @@ function parseInputValueDef(lexer: Lexer<*>): InputValueDefinition {
   const start = lexer.token;
   const name = parseName(lexer);
   expect(lexer, TokenKind.COLON);
-  const type = parseType(lexer);
+  const type = parseTypeReference(lexer);
   let defaultValue = null;
   if (skip(lexer, TokenKind.EQUALS)) {
     defaultValue = parseConstValue(lexer);