Allows buildASTSchema to throw errors with source locations.

Author: tcr

src/error/syntaxError.js

@@ -11,6 +11,29 @@
 import { getLocation } from '../language/location';
 import type { Source } from '../language/source';
 import { GraphQLError } from './GraphQLError';
+import type { ASTNode } from '../language/ast';
+
+/**
+ * Produces a string for formatting a syntax or validation error with an
+ * embedded location.
+ */
+export function formatError(
+  source: Source,
+  position: number,
+  message: string,
+  description?: string,
+): GraphQLError {
+  const location = getLocation(source, position);
+  const body = `${message} (${location.line}:${location.column})` +
+    (description ? ' ' + description : '') +
+    '\n\n' + highlightSourceAtLocation(source, location);
+  return new GraphQLError(
+    body,
+    undefined,
+    source,
+    [ position ]
+  );
+}
 
 /**
  * Produces a GraphQLError representing a syntax error, containing useful
@@ -21,15 +44,29 @@ export function syntaxError(
   position: number,
   description: string
 ): GraphQLError {
-  const location = getLocation(source, position);
-  const error = new GraphQLError(
-    `Syntax Error ${source.name} (${location.line}:${location.column}) ` +
-    description + '\n\n' + highlightSourceAtLocation(source, location),
-    undefined,
+  return formatError(
     source,
-    [ position ]
+    position,
+    `Syntax Error ${source.name}`,
+    description,
   );
-  return error;
+}
+
+/**
+ * Produces a GraphQLError for the invariant(...) function that renders the
+ * location where a validation error occurred. If no source is passed in, it
+ * returns an error containing the message, without context.
+ */
+export function validationError(
+  message: string,
+  node: ASTNode,
+  source: ?Source
+): GraphQLError {
+  const position = node.loc ? node.loc.start : null;
+  if (position == null || source == null) {
+    return new GraphQLError(message);
+  }
+  return formatError(source, position, `Validation Error: ${message}`);
 }
 
 /**

src/jsutils/invariant.js

@@ -8,8 +8,11 @@
  *  of patent rights can be found in the PATENTS file in the same directory.
  */
 
-export default function invariant(condition: mixed, message: string) {
+export default function invariant(condition: mixed, message: string | Error) {
   if (!condition) {
+    if (message instanceof Error) {
+      throw message;
+    }
     throw new Error(message);
   }
 }

src/utilities/__tests__/buildASTSchema-test.js

@@ -17,6 +17,7 @@ import {
   GraphQLSkipDirective,
   GraphQLIncludeDirective,
   GraphQLDeprecatedDirective,
+  Source,
 } from '../../';
 
 /**
@@ -802,4 +803,30 @@ fragment Foo on Type { field }
       .to.throw('Specified query type "Foo" not found in document.');
   });
 
+
+  it('warns with a location where validation errors occur', () => {
+    const body = new Source(`type OutputType {
+      value: String
+    }
+
+    input InputType {
+      value: String
+    }
+
+    type Query {
+      output: [OutputType]
+    }
+
+    type Mutation {
+      signup (password: OutputType): OutputType
+    }`);
+    const doc = parse(body);
+    expect(() => buildASTSchema(doc, body))
+      .to.throw(`GraphQLError: Validation Error: Expected Input type (14:25)
+
+13:     type Mutation {
+14:       signup (password: OutputType): OutputType
+                            ^
+15:     }`);
+  });
 });

src/utilities/buildASTSchema.js

@@ -14,8 +14,9 @@ import keyValMap from '../jsutils/keyValMap';
 import { valueFromAST } from './valueFromAST';
 import { TokenKind } from '../language/lexer';
 import { parse } from '../language/parser';
-import type { Source } from '../language/source';
+import { Source } from '../language/source';
 import { getArgumentValues } from '../execution/values';
+import { validationError } from '../error/syntaxError';
 
 import {
   LIST_TYPE,
@@ -135,7 +136,10 @@ function getNamedTypeNode(typeNode: TypeNode): NamedTypeNode {
  * Given that AST it constructs a GraphQLSchema. The resulting schema
  * has no resolve methods, so execution will use default resolvers.
  */
-export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
+export function buildASTSchema(
+  ast: DocumentNode,
+  source?: Source
+): GraphQLSchema {
   if (!ast || ast.kind !== DOCUMENT) {
     throw new Error('Must provide a document ast.');
   }
@@ -300,25 +304,29 @@ export function buildASTSchema(ast: DocumentNode): GraphQLSchema {
 
   function produceInputType(typeNode: TypeNode): GraphQLInputType {
     const type = produceType(typeNode);
-    invariant(isInputType(type), 'Expected Input type.');
+    invariant(isInputType(type),
+      validationError('Expected Input type', typeNode, source));
     return (type: any);
   }
 
   function produceOutputType(typeNode: TypeNode): GraphQLOutputType {
     const type = produceType(typeNode);
-    invariant(isOutputType(type), 'Expected Output type.');
+    invariant(isOutputType(type),
+      validationError('Expected Output type', typeNode, source));
     return (type: any);
   }
 
   function produceObjectType(typeNode: TypeNode): GraphQLObjectType {
     const type = produceType(typeNode);
-    invariant(type instanceof GraphQLObjectType, 'Expected Object type.');
+    invariant(type instanceof GraphQLObjectType,
+      validationError('Expected Object type', typeNode, source));
     return type;
   }
 
   function produceInterfaceType(typeNode: TypeNode): GraphQLInterfaceType {
     const type = produceType(typeNode);
-    invariant(type instanceof GraphQLInterfaceType, 'Expected Interface type.');
+    invariant(type instanceof GraphQLInterfaceType,
+      validationError('Expected Interface type', typeNode, source));
     return type;
   }
 
@@ -524,7 +532,8 @@ export function getDescription(node: { loc?: Location }): ?string {
  * document.
  */
 export function buildSchema(source: string | Source): GraphQLSchema {
-  return buildASTSchema(parse(source));
+  const sourceObj = typeof source === 'string' ? new Source(source) : source;
+  return buildASTSchema(parse(sourceObj), sourceObj);
 }
 
 // Count the number of spaces on the starting side of a string.