[validation] Add "bail" option to allow for bailing early when valida…

…ting a document

src/validation/ValidationContext.js

@@ -34,13 +34,16 @@ type VariableUsage = {|
   +defaultValue: ?mixed,
 |};
 
+export class ValidationBailEarlyError extends Error {}
+
 /**
  * An instance of this class is passed as the "this" context to all validators,
  * allowing access to commonly useful contextual information from within a
  * validation rule.
  */
 export class ASTValidationContext {
   _ast: DocumentNode;
+  _bail: boolean;
   _errors: Array<GraphQLError>;
   _fragments: ?ObjMap<FragmentDefinitionNode>;
   _fragmentSpreads: Map<SelectionSetNode, $ReadOnlyArray<FragmentSpreadNode>>;
@@ -49,8 +52,9 @@ export class ASTValidationContext {
     $ReadOnlyArray<FragmentDefinitionNode>,
   >;
 
-  constructor(ast: DocumentNode): void {
+  constructor(ast: DocumentNode, bail: boolean = false): void {
     this._ast = ast;
+    this._bail = bail;
     this._errors = [];
     this._fragments = undefined;
     this._fragmentSpreads = new Map();
@@ -59,6 +63,9 @@ export class ASTValidationContext {
 
   reportError(error: GraphQLError): void {
     this._errors.push(error);
+    if (this._bail) {
+      throw new ValidationBailEarlyError();
+    }
   }
 
   getErrors(): $ReadOnlyArray<GraphQLError> {
@@ -165,8 +172,9 @@ export class ValidationContext extends ASTValidationContext {
     schema: GraphQLSchema,
     ast: DocumentNode,
     typeInfo: TypeInfo,
+    bail: boolean = false,
   ): void {
-    super(ast);
+    super(ast, bail);
     this._schema = schema;
     this._typeInfo = typeInfo;
     this._variableUsages = new Map();

src/validation/__tests__/validation-test.js

@@ -74,4 +74,36 @@ describe('Validate: Supports full validation', () => {
       'Cannot query field "isHousetrained" on type "Dog". Did you mean "isHousetrained"?',
     ]);
   });
+
+  it('exits validation early when bail option is set', () => {
+    const doc = parse(`
+      query {
+        cat {
+          name
+          someNonExistentField
+        }
+        dog {
+          name
+          anotherNonExistentField
+        }
+      }
+    `);
+
+    // Ensure that the number of errors without the bail option is 2
+    const errors = validate(testSchema, doc, specifiedRules);
+    expect(errors).to.be.length(2);
+
+    const bailedErrors = validate(
+      testSchema,
+      doc,
+      specifiedRules,
+      undefined,
+      true,
+    );
+    expect(bailedErrors).to.be.length(1);
+    const errorMessages = errors.map(err => err.message);
+    expect(errorMessages[0]).to.equal(
+      'Cannot query field "someNonExistentField" on type "Cat".',
+    );
+  });
 });

src/validation/validate.js

@@ -18,6 +18,7 @@ import {
   type ValidationRule,
   SDLValidationContext,
   ValidationContext,
+  ValidationBailEarlyError,
 } from './ValidationContext';
 
 /**
@@ -41,17 +42,26 @@ export function validate(
   documentAST: DocumentNode,
   rules?: $ReadOnlyArray<ValidationRule> = specifiedRules,
   typeInfo?: TypeInfo = new TypeInfo(schema),
+  bail?: boolean = false,
 ): $ReadOnlyArray<GraphQLError> {
   devAssert(documentAST, 'Must provide document');
   // If the schema used for validation is invalid, throw an error.
   assertValidSchema(schema);
 
-  const context = new ValidationContext(schema, documentAST, typeInfo);
+  const context = new ValidationContext(schema, documentAST, typeInfo, bail);
   // This uses a specialized visitor which runs multiple visitors in parallel,
   // while maintaining the visitor skip and break API.
   const visitor = visitInParallel(rules.map(rule => rule(context)));
-  // Visit the whole document with each instance of all provided rules.
-  visit(documentAST, visitWithTypeInfo(typeInfo, visitor));
+  try {
+    // Visit the whole document with each instance of all provided rules.
+    visit(documentAST, visitWithTypeInfo(typeInfo, visitor));
+  } catch (e) {
+    // If the caught error is not a `ValidationBailEarlyError`, rethrow as the
+    // error is fatal
+    if (!(e instanceof ValidationBailEarlyError)) {
+      throw e;
+    }
+  }
   return context.getErrors();
 }