Add 'Rule' suffix to all validation rules (#2402)

Long awaited change, see this disscussion:
#808 (comment)

Technically it's not a breaking change since only stuff exported from
`graphql` and `graphql/validation` are part of public API.
However, many tools/libraries depended on this "internal" imports to
blacklist certain rules so in #2399 I added missing exports so now
you can import them like so:
```
import { ExecutableDefinitionsRule } from 'graphql/validation';
```

Also I backported missing exports to `14.6.0` release.
If this change broke your code please try to migrate it as shown above
and please feel free to open an issue if you need assistance with migration.

src/execution/values.js

@@ -220,7 +220,7 @@ export function getArgumentValues(
 
     const coercedValue = valueFromAST(valueNode, argType, variableValues);
     if (coercedValue === undefined) {
-      // Note: ValuesOfCorrectType validation should catch this before
+      // Note: ValuesOfCorrectTypeRule validation should catch this before
       // execution. This is a runtime check to ensure execution does not
       // continue with an invalid argument value.
       throw new GraphQLError(

src/index.d.ts

@@ -327,12 +327,12 @@ export {
   VariablesAreInputTypesRule,
   VariablesInAllowedPositionRule,
   // SDL-specific validation rules
-  LoneSchemaDefinitionRule,
-  UniqueOperationTypesRule,
-  UniqueTypeNamesRule,
-  UniqueEnumValueNamesRule,
+  LoneSchemaDefinitionRuleRule,
+  UniqueOperationTypesRuleRule,
+  UniqueTypeNamesRuleRule,
+  UniqueEnumValueNamesRuleRule,
   UniqueFieldDefinitionNamesRule,
-  UniqueDirectiveNamesRule,
+  UniqueDirectiveNamesRuleRule,
   PossibleTypeExtensionsRule,
   ValidationRule,
 } from './validation/index';

src/index.js

@@ -325,12 +325,12 @@ export {
   VariablesAreInputTypesRule,
   VariablesInAllowedPositionRule,
   // SDL-specific validation rules
-  LoneSchemaDefinitionRule,
-  UniqueOperationTypesRule,
-  UniqueTypeNamesRule,
-  UniqueEnumValueNamesRule,
+  LoneSchemaDefinitionRuleRule,
+  UniqueOperationTypesRuleRule,
+  UniqueTypeNamesRuleRule,
+  UniqueEnumValueNamesRuleRule,
   UniqueFieldDefinitionNamesRule,
-  UniqueDirectiveNamesRule,
+  UniqueDirectiveNamesRuleRule,
   PossibleTypeExtensionsRule,
 } from './validation/index';
 

src/validation/__tests__/ExecutableDefinitions-test.js → src/validation/__tests__/ExecutableDefinitionsRule-test.js

@@ -2,12 +2,12 @@
 
 import { describe, it } from 'mocha';
 
-import { ExecutableDefinitions } from '../rules/ExecutableDefinitions';
+import { ExecutableDefinitionsRule } from '../rules/ExecutableDefinitionsRule';
 
 import { expectValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(ExecutableDefinitions, queryStr);
+  return expectValidationErrors(ExecutableDefinitionsRule, queryStr);
 }
 
 function expectValid(queryStr) {

src/validation/__tests__/FieldsOnCorrectType-test.js → src/validation/__tests__/FieldsOnCorrectTypeRule-test.js

@@ -8,12 +8,12 @@ import { parse } from '../../language/parser';
 import { buildSchema } from '../../utilities/buildASTSchema';
 
 import { validate } from '../validate';
-import { FieldsOnCorrectType } from '../rules/FieldsOnCorrectType';
+import { FieldsOnCorrectTypeRule } from '../rules/FieldsOnCorrectTypeRule';
 
 import { expectValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(FieldsOnCorrectType, queryStr);
+  return expectValidationErrors(FieldsOnCorrectTypeRule, queryStr);
 }
 
 function expectValid(queryStr) {
@@ -258,7 +258,9 @@ describe('Validate: Fields on correct type', () => {
 
   describe('Fields on correct type error message', () => {
     function expectErrorMessage(schema, queryStr) {
-      const errors = validate(schema, parse(queryStr), [FieldsOnCorrectType]);
+      const errors = validate(schema, parse(queryStr), [
+        FieldsOnCorrectTypeRule,
+      ]);
       expect(errors.length).to.equal(1);
       return expect(errors[0].message);
     }

src/validation/__tests__/FragmentsOnCompositeTypes-test.js → src/validation/__tests__/FragmentsOnCompositeTypesRule-test.js

@@ -2,12 +2,12 @@
 
 import { describe, it } from 'mocha';
 
-import { FragmentsOnCompositeTypes } from '../rules/FragmentsOnCompositeTypes';
+import { FragmentsOnCompositeTypesRule } from '../rules/FragmentsOnCompositeTypesRule';
 
 import { expectValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(FragmentsOnCompositeTypes, queryStr);
+  return expectValidationErrors(FragmentsOnCompositeTypesRule, queryStr);
 }
 
 function expectValid(queryStr) {

src/validation/__tests__/KnownArgumentNames-test.js → src/validation/__tests__/KnownArgumentNamesRule-test.js

@@ -5,14 +5,14 @@ import { describe, it } from 'mocha';
 import { buildSchema } from '../../utilities/buildASTSchema';
 
 import {
-  KnownArgumentNames,
+  KnownArgumentNamesRule,
   KnownArgumentNamesOnDirectives,
-} from '../rules/KnownArgumentNames';
+} from '../rules/KnownArgumentNamesRule';
 
 import { expectValidationErrors, expectSDLValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(KnownArgumentNames, queryStr);
+  return expectValidationErrors(KnownArgumentNamesRule, queryStr);
 }
 
 function expectValid(queryStr) {

src/validation/__tests__/KnownDirectives-test.js → src/validation/__tests__/KnownDirectivesRule-test.js

@@ -4,20 +4,20 @@ import { describe, it } from 'mocha';
 
 import { buildSchema } from '../../utilities/buildASTSchema';
 
-import { KnownDirectives } from '../rules/KnownDirectives';
+import { KnownDirectivesRule } from '../rules/KnownDirectivesRule';
 
 import { expectValidationErrors, expectSDLValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(KnownDirectives, queryStr);
+  return expectValidationErrors(KnownDirectivesRule, queryStr);
 }
 
 function expectValid(queryStr) {
   expectErrors(queryStr).to.deep.equal([]);
 }
 
 function expectSDLErrors(sdlStr, schema) {
-  return expectSDLValidationErrors(schema, KnownDirectives, sdlStr);
+  return expectSDLValidationErrors(schema, KnownDirectivesRule, sdlStr);
 }
 
 function expectValidSDL(sdlStr, schema) {

src/validation/__tests__/KnownFragmentNames-test.js → src/validation/__tests__/KnownFragmentNamesRule-test.js

@@ -2,12 +2,12 @@
 
 import { describe, it } from 'mocha';
 
-import { KnownFragmentNames } from '../rules/KnownFragmentNames';
+import { KnownFragmentNamesRule } from '../rules/KnownFragmentNamesRule';
 
 import { expectValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(KnownFragmentNames, queryStr);
+  return expectValidationErrors(KnownFragmentNamesRule, queryStr);
 }
 
 function expectValid(queryStr) {

src/validation/__tests__/KnownTypeNames-test.js → src/validation/__tests__/KnownTypeNamesRule-test.js

@@ -4,7 +4,7 @@ import { describe, it } from 'mocha';
 
 import { buildSchema } from '../../utilities/buildASTSchema';
 
-import { KnownTypeNames } from '../rules/KnownTypeNames';
+import { KnownTypeNamesRule } from '../rules/KnownTypeNamesRule';
 
 import {
   expectValidationErrors,
@@ -13,19 +13,19 @@ import {
 } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(KnownTypeNames, queryStr);
+  return expectValidationErrors(KnownTypeNamesRule, queryStr);
 }
 
 function expectErrorsWithSchema(schema, queryStr) {
-  return expectValidationErrorsWithSchema(schema, KnownTypeNames, queryStr);
+  return expectValidationErrorsWithSchema(schema, KnownTypeNamesRule, queryStr);
 }
 
 function expectValid(queryStr) {
   expectErrors(queryStr).to.deep.equal([]);
 }
 
 function expectSDLErrors(sdlStr, schema) {
-  return expectSDLValidationErrors(schema, KnownTypeNames, sdlStr);
+  return expectSDLValidationErrors(schema, KnownTypeNamesRule, sdlStr);
 }
 
 function expectValidSDL(sdlStr, schema) {

src/validation/__tests__/LoneAnonymousOperation-test.js → src/validation/__tests__/LoneAnonymousOperationRule-test.js

@@ -2,12 +2,12 @@
 
 import { describe, it } from 'mocha';
 
-import { LoneAnonymousOperation } from '../rules/LoneAnonymousOperation';
+import { LoneAnonymousOperationRule } from '../rules/LoneAnonymousOperationRule';
 
 import { expectValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(LoneAnonymousOperation, queryStr);
+  return expectValidationErrors(LoneAnonymousOperationRule, queryStr);
 }
 
 function expectValid(queryStr) {

src/validation/__tests__/LoneSchemaDefinition-test.js → src/validation/__tests__/LoneSchemaDefinitionRule-test.js

@@ -4,12 +4,16 @@ import { describe, it } from 'mocha';
 
 import { buildSchema } from '../../utilities/buildASTSchema';
 
-import { LoneSchemaDefinition } from '../rules/LoneSchemaDefinition';
+import { LoneSchemaDefinitionRuleRule } from '../rules/LoneSchemaDefinitionRule';
 
 import { expectSDLValidationErrors } from './harness';
 
 function expectSDLErrors(sdlStr, schema) {
-  return expectSDLValidationErrors(schema, LoneSchemaDefinition, sdlStr);
+  return expectSDLValidationErrors(
+    schema,
+    LoneSchemaDefinitionRuleRule,
+    sdlStr,
+  );
 }
 
 function expectValidSDL(sdlStr, schema) {

src/validation/__tests__/NoFragmentCycles-test.js → src/validation/__tests__/NoFragmentCyclesRule-test.js

@@ -2,12 +2,12 @@
 
 import { describe, it } from 'mocha';
 
-import { NoFragmentCycles } from '../rules/NoFragmentCycles';
+import { NoFragmentCyclesRule } from '../rules/NoFragmentCyclesRule';
 
 import { expectValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(NoFragmentCycles, queryStr);
+  return expectValidationErrors(NoFragmentCyclesRule, queryStr);
 }
 
 function expectValid(queryStr) {

src/validation/__tests__/NoUndefinedVariables-test.js → src/validation/__tests__/NoUndefinedVariablesRule-test.js

@@ -2,12 +2,12 @@
 
 import { describe, it } from 'mocha';
 
-import { NoUndefinedVariables } from '../rules/NoUndefinedVariables';
+import { NoUndefinedVariablesRule } from '../rules/NoUndefinedVariablesRule';
 
 import { expectValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(NoUndefinedVariables, queryStr);
+  return expectValidationErrors(NoUndefinedVariablesRule, queryStr);
 }
 
 function expectValid(queryStr) {

src/validation/__tests__/NoUnusedFragments-test.js → src/validation/__tests__/NoUnusedFragmentsRule-test.js

@@ -2,12 +2,12 @@
 
 import { describe, it } from 'mocha';
 
-import { NoUnusedFragments } from '../rules/NoUnusedFragments';
+import { NoUnusedFragmentsRule } from '../rules/NoUnusedFragmentsRule';
 
 import { expectValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(NoUnusedFragments, queryStr);
+  return expectValidationErrors(NoUnusedFragmentsRule, queryStr);
 }
 
 function expectValid(queryStr) {

src/validation/__tests__/NoUnusedVariables-test.js → src/validation/__tests__/NoUnusedVariablesRule-test.js

@@ -2,12 +2,12 @@
 
 import { describe, it } from 'mocha';
 
-import { NoUnusedVariables } from '../rules/NoUnusedVariables';
+import { NoUnusedVariablesRule } from '../rules/NoUnusedVariablesRule';
 
 import { expectValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(NoUnusedVariables, queryStr);
+  return expectValidationErrors(NoUnusedVariablesRule, queryStr);
 }
 
 function expectValid(queryStr) {

src/validation/__tests__/OverlappingFieldsCanBeMerged-test.js → src/validation/__tests__/OverlappingFieldsCanBeMergedRule-test.js

@@ -4,15 +4,15 @@ import { describe, it } from 'mocha';
 
 import { buildSchema } from '../../utilities/buildASTSchema';
 
-import { OverlappingFieldsCanBeMerged } from '../rules/OverlappingFieldsCanBeMerged';
+import { OverlappingFieldsCanBeMergedRule } from '../rules/OverlappingFieldsCanBeMergedRule';
 
 import {
   expectValidationErrors,
   expectValidationErrorsWithSchema,
 } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(OverlappingFieldsCanBeMerged, queryStr);
+  return expectValidationErrors(OverlappingFieldsCanBeMergedRule, queryStr);
 }
 
 function expectValid(queryStr) {
@@ -22,7 +22,7 @@ function expectValid(queryStr) {
 function expectErrorsWithSchema(schema, queryStr) {
   return expectValidationErrorsWithSchema(
     schema,
-    OverlappingFieldsCanBeMerged,
+    OverlappingFieldsCanBeMergedRule,
     queryStr,
   );
 }

src/validation/__tests__/PossibleFragmentSpreads-test.js → src/validation/__tests__/PossibleFragmentSpreadsRule-test.js

@@ -2,12 +2,12 @@
 
 import { describe, it } from 'mocha';
 
-import { PossibleFragmentSpreads } from '../rules/PossibleFragmentSpreads';
+import { PossibleFragmentSpreadsRule } from '../rules/PossibleFragmentSpreadsRule';
 
 import { expectValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(PossibleFragmentSpreads, queryStr);
+  return expectValidationErrors(PossibleFragmentSpreadsRule, queryStr);
 }
 
 function expectValid(queryStr) {
@@ -90,14 +90,14 @@ describe('Validate: Possible fragment spreads', () => {
     `);
   });
 
-  it('ignores incorrect type (caught by FragmentsOnCompositeTypes)', () => {
+  it('ignores incorrect type (caught by FragmentsOnCompositeTypesRule)', () => {
     expectValid(`
       fragment petFragment on Pet { ...badInADifferentWay }
       fragment badInADifferentWay on String { name }
     `);
   });
 
-  it('ignores unknown fragments (caught by KnownFragmentNames)', () => {
+  it('ignores unknown fragments (caught by KnownFragmentNamesRule)', () => {
     expectValid(`
       fragment petFragment on Pet { ...UnknownFragment }
     `);

src/validation/__tests__/PossibleTypeExtensions-test.js → src/validation/__tests__/PossibleTypeExtensionsRule-test.js

@@ -4,12 +4,12 @@ import { describe, it } from 'mocha';
 
 import { buildSchema } from '../../utilities/buildASTSchema';
 
-import { PossibleTypeExtensions } from '../rules/PossibleTypeExtensions';
+import { PossibleTypeExtensionsRule } from '../rules/PossibleTypeExtensionsRule';
 
 import { expectSDLValidationErrors } from './harness';
 
 function expectSDLErrors(sdlStr, schema) {
-  return expectSDLValidationErrors(schema, PossibleTypeExtensions, sdlStr);
+  return expectSDLValidationErrors(schema, PossibleTypeExtensionsRule, sdlStr);
 }
 
 function expectValidSDL(sdlStr, schema) {

src/validation/__tests__/ProvidedRequiredArguments-test.js → src/validation/__tests__/ProvidedRequiredArgumentsRule-test.js

@@ -5,14 +5,14 @@ import { describe, it } from 'mocha';
 import { buildSchema } from '../../utilities/buildASTSchema';
 
 import {
-  ProvidedRequiredArguments,
+  ProvidedRequiredArgumentsRule,
   ProvidedRequiredArgumentsOnDirectives,
-} from '../rules/ProvidedRequiredArguments';
+} from '../rules/ProvidedRequiredArgumentsRule';
 
 import { expectValidationErrors, expectSDLValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(ProvidedRequiredArguments, queryStr);
+  return expectValidationErrors(ProvidedRequiredArgumentsRule, queryStr);
 }
 
 function expectValid(queryStr) {

src/validation/__tests__/ScalarLeafs-test.js → src/validation/__tests__/ScalarLeafsRule-test.js

@@ -2,12 +2,12 @@
 
 import { describe, it } from 'mocha';
 
-import { ScalarLeafs } from '../rules/ScalarLeafs';
+import { ScalarLeafsRule } from '../rules/ScalarLeafsRule';
 
 import { expectValidationErrors } from './harness';
 
 function expectErrors(queryStr) {
-  return expectValidationErrors(ScalarLeafs, queryStr);
+  return expectValidationErrors(ScalarLeafsRule, queryStr);
 }
 
 function expectValid(queryStr) {