Add GraphQLValidationError as a subclass of GraphQLError

Also deprecated `ValidationContext.reportError` in favor of new `report`
function with named argument.

Motivation: subclassing allows you to distinguish between errors produced by `graphql-js`.
Idea is to subclass all errors into different types e.g. GraphQLValidationError, GraphQLSyntaxError, etc.
That way clients can be sure what type of error it is.

```js
const { data, errors, extensions } = graphql({ /* ... */ });

const response = {
  data,
  errors.map((error) => {
    if (error instanceof GraphQLValidationError) {
      // do a special handling of validation errors
    } else if (error instanceof GraphQLSyntaxError) {
      // do a special handling of syntax errors
    }
  }),
  extensions,
};
```

Without this change, you can't distinguish one type of error from other types of errors.
Subclassing errors for that purpose is a standard approach in JS (e.g. `TypeError` is a subclass of `Error`) and other OOP languages.

Author: IvanGoncharov

src/error/GraphQLError.ts

@@ -237,3 +237,21 @@ export interface GraphQLFormattedError {
    */
   readonly extensions?: { [key: string]: unknown };
 }
+
+export interface GraphQLValidationErrorOptions {
+  nodes: ReadonlyArray<ASTNode> | ASTNode;
+  originalError?: Error | undefined;
+  extensions?: GraphQLErrorExtensions | undefined;
+}
+
+export class GraphQLValidationError extends GraphQLError {
+  constructor(message: string, options: GraphQLValidationErrorOptions) {
+    super(message, options);
+
+    this.name = 'GraphQLValidationError';
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'GraphQLValidationError';
+  }
+}

src/error/index.ts

@@ -1,6 +1,7 @@
-export { GraphQLError } from './GraphQLError';
+export { GraphQLError, GraphQLValidationError } from './GraphQLError';
 export type {
   GraphQLErrorOptions,
+  GraphQLValidationErrorOptions,
   GraphQLFormattedError,
   GraphQLErrorExtensions,
 } from './GraphQLError';

src/index.ts

@@ -377,10 +377,16 @@ export {
 export type { ValidationRule } from './validation/index';
 
 // Create, format, and print GraphQL errors.
-export { GraphQLError, syntaxError, locatedError } from './error/index';
+export {
+  GraphQLError,
+  GraphQLValidationError,
+  syntaxError,
+  locatedError,
+} from './error/index';
 
 export type {
   GraphQLErrorOptions,
+  GraphQLValidationErrorOptions,
   GraphQLFormattedError,
   GraphQLErrorExtensions,
 } from './error/index';

src/validation/ValidationContext.ts

@@ -1,9 +1,14 @@
 import type { Maybe } from '../jsutils/Maybe';
 import type { ObjMap } from '../jsutils/ObjMap';
 
-import type { GraphQLError } from '../error/GraphQLError';
+import type {
+  GraphQLError,
+  GraphQLErrorExtensions,
+} from '../error/GraphQLError';
+import { GraphQLValidationError } from '../error/GraphQLError';
 
 import type {
+  ASTNode,
   DocumentNode,
   FragmentDefinitionNode,
   FragmentSpreadNode,
@@ -35,6 +40,13 @@ interface VariableUsage {
   readonly defaultValue: Maybe<unknown>;
 }
 
+interface ValidationReportOptions {
+  message: string;
+  nodes: ReadonlyArray<ASTNode> | ASTNode;
+  originalError?: Error | undefined;
+  extensions?: GraphQLErrorExtensions | undefined;
+}
+
 /**
  * An instance of this class is passed as the "this" context to all validators,
  * allowing access to commonly useful contextual information from within a
@@ -62,10 +74,22 @@ export class ASTValidationContext {
     return 'ASTValidationContext';
   }
 
+  // TODO: when remove change `onError` to use GraphQLValidationError type instead
+  /* c8 ignore next 4 */
+  /** @deprecated Use `report` instead, will be removed in v18 */
   reportError(error: GraphQLError): void {
     this._onError(error);
   }
 
+  report(options: ValidationReportOptions): void {
+    const error = new GraphQLValidationError(options.message, {
+      nodes: options.nodes,
+      originalError: options.originalError,
+      extensions: options.extensions,
+    });
+    this._onError(error);
+  }
+
   getDocument(): DocumentNode {
     return this._ast;
   }

src/validation/__tests__/validation-test.ts

@@ -3,8 +3,6 @@ import { describe, it } from 'mocha';
 
 import { expectJSON } from '../../__testUtils__/expectJSON';
 
-import { GraphQLError } from '../../error/GraphQLError';
-
 import type { DirectiveNode } from '../../language/ast';
 import { parse } from '../../language/parser';
 
@@ -76,11 +74,10 @@ describe('Validate: Supports full validation', () => {
       return {
         Directive(node: DirectiveNode) {
           const directiveDef = context.getDirective();
-          const error = new GraphQLError(
-            'Reporting directive: ' + String(directiveDef),
-            { nodes: node },
-          );
-          context.reportError(error);
+          context.report({
+            message: 'Reporting directive: ' + String(directiveDef),
+            nodes: node,
+          });
         },
       };
     }

src/validation/rules/ExecutableDefinitionsRule.ts

@@ -1,5 +1,3 @@
-import { GraphQLError } from '../../error/GraphQLError';
-
 import { Kind } from '../../language/kinds';
 import { isExecutableDefinitionNode } from '../../language/predicates';
 import type { ASTVisitor } from '../../language/visitor';
@@ -26,11 +24,10 @@ export function ExecutableDefinitionsRule(
             definition.kind === Kind.SCHEMA_EXTENSION
               ? 'schema'
               : '"' + definition.name.value + '"';
-          context.reportError(
-            new GraphQLError(`The ${defName} definition is not executable.`, {
-              nodes: definition,
-            }),
-          );
+          context.report({
+            message: `The ${defName} definition is not executable.`,
+            nodes: definition,
+          });
         }
       }
       return false;

src/validation/rules/FieldsOnCorrectTypeRule.ts

@@ -2,8 +2,6 @@ import { didYouMean } from '../../jsutils/didYouMean';
 import { naturalCompare } from '../../jsutils/naturalCompare';
 import { suggestionList } from '../../jsutils/suggestionList';
 
-import { GraphQLError } from '../../error/GraphQLError';
-
 import type { FieldNode } from '../../language/ast';
 import type { ASTVisitor } from '../../language/visitor';
 
@@ -54,13 +52,12 @@ export function FieldsOnCorrectTypeRule(
           }
 
           // Report an error, including helpful suggestions.
-          context.reportError(
-            new GraphQLError(
+          context.report({
+            message:
               `Cannot query field "${fieldName}" on type "${type.name}".` +
-                suggestion,
-              { nodes: node },
-            ),
-          );
+              suggestion,
+            nodes: node,
+          });
         }
       }
     },

src/validation/rules/FragmentsOnCompositeTypesRule.ts

@@ -1,5 +1,3 @@
-import { GraphQLError } from '../../error/GraphQLError';
-
 import { print } from '../../language/printer';
 import type { ASTVisitor } from '../../language/visitor';
 
@@ -28,25 +26,21 @@ export function FragmentsOnCompositeTypesRule(
         const type = typeFromAST(context.getSchema(), typeCondition);
         if (type && !isCompositeType(type)) {
           const typeStr = print(typeCondition);
-          context.reportError(
-            new GraphQLError(
-              `Fragment cannot condition on non composite type "${typeStr}".`,
-              { nodes: typeCondition },
-            ),
-          );
+          context.report({
+            message: `Fragment cannot condition on non composite type "${typeStr}".`,
+            nodes: typeCondition,
+          });
         }
       }
     },
     FragmentDefinition(node) {
       const type = typeFromAST(context.getSchema(), node.typeCondition);
       if (type && !isCompositeType(type)) {
         const typeStr = print(node.typeCondition);
-        context.reportError(
-          new GraphQLError(
-            `Fragment "${node.name.value}" cannot condition on non composite type "${typeStr}".`,
-            { nodes: node.typeCondition },
-          ),
-        );
+        context.report({
+          message: `Fragment "${node.name.value}" cannot condition on non composite type "${typeStr}".`,
+          nodes: node.typeCondition,
+        });
       }
     },
   };

src/validation/rules/KnownArgumentNamesRule.ts

@@ -1,8 +1,6 @@
 import { didYouMean } from '../../jsutils/didYouMean';
 import { suggestionList } from '../../jsutils/suggestionList';
 
-import { GraphQLError } from '../../error/GraphQLError';
-
 import { Kind } from '../../language/kinds';
 import type { ASTVisitor } from '../../language/visitor';
 
@@ -35,13 +33,12 @@ export function KnownArgumentNamesRule(context: ValidationContext): ASTVisitor {
         const argName = argNode.name.value;
         const knownArgsNames = fieldDef.args.map((arg) => arg.name);
         const suggestions = suggestionList(argName, knownArgsNames);
-        context.reportError(
-          new GraphQLError(
+        context.report({
+          message:
             `Unknown argument "${argName}" on field "${parentType.name}.${fieldDef.name}".` +
-              didYouMean(suggestions),
-            { nodes: argNode },
-          ),
-        );
+            didYouMean(suggestions),
+          nodes: argNode,
+        });
       }
     },
   };
@@ -84,13 +81,12 @@ export function KnownArgumentNamesOnDirectivesRule(
           const argName = argNode.name.value;
           if (!knownArgs.includes(argName)) {
             const suggestions = suggestionList(argName, knownArgs);
-            context.reportError(
-              new GraphQLError(
+            context.report({
+              message:
                 `Unknown argument "${argName}" on directive "@${directiveName}".` +
-                  didYouMean(suggestions),
-                { nodes: argNode },
-              ),
-            );
+                didYouMean(suggestions),
+              nodes: argNode,
+            });
           }
         }
       }

src/validation/rules/KnownDirectivesRule.ts

@@ -1,8 +1,6 @@
 import { inspect } from '../../jsutils/inspect';
 import { invariant } from '../../jsutils/invariant';
 
-import { GraphQLError } from '../../error/GraphQLError';
-
 import type { ASTNode } from '../../language/ast';
 import { OperationTypeNode } from '../../language/ast';
 import { DirectiveLocation } from '../../language/directiveLocation';
@@ -50,20 +48,19 @@ export function KnownDirectivesRule(
       const locations = locationsMap[name];
 
       if (!locations) {
-        context.reportError(
-          new GraphQLError(`Unknown directive "@${name}".`, { nodes: node }),
-        );
+        context.report({
+          message: `Unknown directive "@${name}".`,
+          nodes: node,
+        });
         return;
       }
 
       const candidateLocation = getDirectiveLocationForASTPath(ancestors);
       if (candidateLocation && !locations.includes(candidateLocation)) {
-        context.reportError(
-          new GraphQLError(
-            `Directive "@${name}" may not be used on ${candidateLocation}.`,
-            { nodes: node },
-          ),
-        );
+        context.report({
+          message: `Directive "@${name}" may not be used on ${candidateLocation}.`,
+          nodes: node,
+        });
       }
     },
   };

src/validation/rules/KnownFragmentNamesRule.ts

@@ -1,5 +1,3 @@
-import { GraphQLError } from '../../error/GraphQLError';
-
 import type { ASTVisitor } from '../../language/visitor';
 
 import type { ValidationContext } from '../ValidationContext';
@@ -18,11 +16,10 @@ export function KnownFragmentNamesRule(context: ValidationContext): ASTVisitor {
       const fragmentName = node.name.value;
       const fragment = context.getFragment(fragmentName);
       if (!fragment) {
-        context.reportError(
-          new GraphQLError(`Unknown fragment "${fragmentName}".`, {
-            nodes: node.name,
-          }),
-        );
+        context.report({
+          message: `Unknown fragment "${fragmentName}".`,
+          nodes: node.name,
+        });
       }
     },
   };

src/validation/rules/KnownTypeNamesRule.ts

@@ -1,8 +1,6 @@
 import { didYouMean } from '../../jsutils/didYouMean';
 import { suggestionList } from '../../jsutils/suggestionList';
 
-import { GraphQLError } from '../../error/GraphQLError';
-
 import type { ASTNode } from '../../language/ast';
 import {
   isTypeDefinitionNode,
@@ -59,12 +57,10 @@ export function KnownTypeNamesRule(
           typeName,
           isSDL ? standardTypeNames.concat(typeNames) : typeNames,
         );
-        context.reportError(
-          new GraphQLError(
-            `Unknown type "${typeName}".` + didYouMean(suggestedTypes),
-            { nodes: node },
-          ),
-        );
+        context.report({
+          message: `Unknown type "${typeName}".` + didYouMean(suggestedTypes),
+          nodes: node,
+        });
       }
     },
   };

src/validation/rules/LoneAnonymousOperationRule.ts

@@ -1,5 +1,3 @@
-import { GraphQLError } from '../../error/GraphQLError';
-
 import { Kind } from '../../language/kinds';
 import type { ASTVisitor } from '../../language/visitor';
 
@@ -25,12 +23,11 @@ export function LoneAnonymousOperationRule(
     },
     OperationDefinition(node) {
       if (!node.name && operationCount > 1) {
-        context.reportError(
-          new GraphQLError(
+        context.report({
+          message:
             'This anonymous operation must be the only defined operation.',
-            { nodes: node },
-          ),
-        );
+          nodes: node,
+        });
       }
     },
   };