[Validation] Report errors rather than return them

This replaces the mechanism of returning errors or lists of errors from a validator step to instead report those errors via calling a function on the context.

This simplifies the implementation of the visitor mechanism, but also opens the doors for future rules being specified as warnings instead of errors.

Author: leebyron

src/validation/__tests__/FieldsOnCorrectType.js

@@ -75,6 +75,20 @@ describe('Validate: Fields on correct type', () => {
     `);
   });
 
+  it('reports errors when type is known again', () => {
+    expectFailsRule(FieldsOnCorrectType, `
+      fragment typeKnownAgain on Pet {
+        unknown_pet_field {
+          ... on Cat {
+            unknown_cat_field
+          }
+        }
+      }`,
+      [ undefinedField('unknown_pet_field', 'Pet', 3, 9),
+        undefinedField('unknown_cat_field', 'Cat', 5, 13) ]
+    );
+  });
+
   it('Field not defined on fragment', () => {
     expectFailsRule(FieldsOnCorrectType, `
       fragment fieldNotDefined on Dog {
@@ -84,7 +98,7 @@ describe('Validate: Fields on correct type', () => {
     );
   });
 
-  it('Field not defined deeply, only reports first', () => {
+  it('Ignores deeply unknown field', () => {
     expectFailsRule(FieldsOnCorrectType, `
       fragment deepFieldNotDefined on Dog {
         unknown_field {

src/validation/__tests__/validation.js

@@ -65,7 +65,9 @@ describe('Validate: Supports full validation', () => {
     );
 
     expect(errors).to.deep.equal([
-      { message: 'Cannot query field "catOrDog" on "QueryRoot".' }
+      { message: 'Cannot query field "catOrDog" on "QueryRoot".' },
+      { message: 'Cannot query field "furColor" on "Cat".' },
+      { message: 'Cannot query field "isHousetrained" on "Dog".' }
     ]);
   });
 

src/validation/rules/ArgumentsOfCorrectType.js

@@ -29,14 +29,14 @@ export function ArgumentsOfCorrectType(context: ValidationContext): any {
     Argument(argAST) {
       var argDef = context.getArgument();
       if (argDef && !isValidLiteralValue(argDef.type, argAST.value)) {
-        return new GraphQLError(
+        context.reportError(new GraphQLError(
           badValueMessage(
             argAST.name.value,
             argDef.type,
             print(argAST.value)
           ),
           [ argAST.value ]
-        );
+        ));
       }
       return false;
     }

src/validation/rules/DefaultValuesOfCorrectType.js

@@ -46,16 +46,16 @@ export function DefaultValuesOfCorrectType(context: ValidationContext): any {
       var defaultValue = varDefAST.defaultValue;
       var type = context.getInputType();
       if (type instanceof GraphQLNonNull && defaultValue) {
-        return new GraphQLError(
+        context.reportError(new GraphQLError(
           defaultForNonNullArgMessage(name, type, type.ofType),
           [ defaultValue ]
-        );
+        ));
       }
       if (type && defaultValue && !isValidLiteralValue(type, defaultValue)) {
-        return new GraphQLError(
+        context.reportError(new GraphQLError(
           badValueForDefaultArgMessage(name, type, print(defaultValue)),
           [ defaultValue ]
-        );
+        ));
       }
       return false;
     },

src/validation/rules/FieldsOnCorrectType.js

@@ -30,10 +30,10 @@ export function FieldsOnCorrectType(context: ValidationContext): any {
       if (type) {
         var fieldDef = context.getFieldDef();
         if (!fieldDef) {
-          return new GraphQLError(
+          context.reportError(new GraphQLError(
             undefinedFieldMessage(node.name.value, type.name),
             [ node ]
-          );
+          ));
         }
       }
     }

src/validation/rules/FragmentsOnCompositeTypes.js

@@ -40,22 +40,22 @@ export function FragmentsOnCompositeTypes(context: ValidationContext): any {
     InlineFragment(node) {
       var type = context.getType();
       if (node.typeCondition && type && !isCompositeType(type)) {
-        return new GraphQLError(
+        context.reportError(new GraphQLError(
           inlineFragmentOnNonCompositeErrorMessage(print(node.typeCondition)),
           [ node.typeCondition ]
-        );
+        ));
       }
     },
     FragmentDefinition(node) {
       var type = context.getType();
       if (type && !isCompositeType(type)) {
-        return new GraphQLError(
+        context.reportError(new GraphQLError(
           fragmentOnNonCompositeErrorMessage(
             node.name.value,
             print(node.typeCondition)
           ),
           [ node.typeCondition ]
-        );
+        ));
       }
     }
   };

src/validation/rules/KnownArgumentNames.js

@@ -54,14 +54,14 @@ export function KnownArgumentNames(context: ValidationContext): any {
           if (!fieldArgDef) {
             var parentType = context.getParentType();
             invariant(parentType);
-            return new GraphQLError(
+            context.reportError(new GraphQLError(
               unknownArgMessage(
                 node.name.value,
                 fieldDef.name,
                 parentType.name
               ),
               [ node ]
-            );
+            ));
           }
         }
       } else if (argumentOf.kind === DIRECTIVE) {
@@ -72,10 +72,10 @@ export function KnownArgumentNames(context: ValidationContext): any {
             arg => arg.name === node.name.value
           );
           if (!directiveArgDef) {
-            return new GraphQLError(
+            context.reportError(new GraphQLError(
               unknownDirectiveArgMessage(node.name.value, directive.name),
               [ node ]
-            );
+            ));
           }
         }
       }

src/validation/rules/KnownDirectives.js

@@ -45,33 +45,40 @@ export function KnownDirectives(context: ValidationContext): any {
         def => def.name === node.name.value
       );
       if (!directiveDef) {
-        return new GraphQLError(
+        context.reportError(new GraphQLError(
           unknownDirectiveMessage(node.name.value),
           [ node ]
-        );
+        ));
+        return;
       }
-      var appliedTo = ancestors[ancestors.length - 1];
-      if (appliedTo.kind === OPERATION_DEFINITION &&
-          !directiveDef.onOperation) {
-        return new GraphQLError(
-          misplacedDirectiveMessage(node.name.value, 'operation'),
-          [ node ]
-        );
-      }
-      if (appliedTo.kind === FIELD && !directiveDef.onField) {
-        return new GraphQLError(
-          misplacedDirectiveMessage(node.name.value, 'field'),
-          [ node ]
-        );
-      }
-      if ((appliedTo.kind === FRAGMENT_SPREAD ||
-           appliedTo.kind === INLINE_FRAGMENT ||
-           appliedTo.kind === FRAGMENT_DEFINITION) &&
-          !directiveDef.onFragment) {
-        return new GraphQLError(
-          misplacedDirectiveMessage(node.name.value, 'fragment'),
-          [ node ]
-        );
+      const appliedTo = ancestors[ancestors.length - 1];
+      switch (appliedTo.kind) {
+        case OPERATION_DEFINITION:
+          if (!directiveDef.onOperation) {
+            context.reportError(new GraphQLError(
+              misplacedDirectiveMessage(node.name.value, 'operation'),
+              [ node ]
+            ));
+          }
+          break;
+        case FIELD:
+          if (!directiveDef.onField) {
+            context.reportError(new GraphQLError(
+              misplacedDirectiveMessage(node.name.value, 'field'),
+              [ node ]
+            ));
+          }
+          break;
+        case FRAGMENT_SPREAD:
+        case INLINE_FRAGMENT:
+        case FRAGMENT_DEFINITION:
+          if (!directiveDef.onFragment) {
+            context.reportError(new GraphQLError(
+              misplacedDirectiveMessage(node.name.value, 'fragment'),
+              [ node ]
+            ));
+          }
+          break;
       }
     }
   };

src/validation/rules/KnownFragmentNames.js

@@ -28,10 +28,10 @@ export function KnownFragmentNames(context: ValidationContext): any {
       var fragmentName = node.name.value;
       var fragment = context.getFragment(fragmentName);
       if (!fragment) {
-        return new GraphQLError(
+        context.reportError(new GraphQLError(
           unknownFragmentMessage(fragmentName),
           [ node.name ]
-        );
+        ));
       }
     }
   };

src/validation/rules/KnownTypeNames.js

@@ -28,7 +28,9 @@ export function KnownTypeNames(context: ValidationContext): any {
       var typeName = node.name.value;
       var type = context.getSchema().getType(typeName);
       if (!type) {
-        return new GraphQLError(unknownTypeMessage(typeName), [ node ]);
+        context.reportError(
+          new GraphQLError(unknownTypeMessage(typeName), [ node ])
+        );
       }
     }
   };