graphql 14.4.2 → 14.5.3

package/validation/ValidationContext.d.ts

@@ -0,0 +1,96 @@
+import Maybe from '../tsutils/Maybe';
+import { GraphQLError } from '../error';
+import { ASTVisitor } from '../language/visitor';
+import {
+  DocumentNode,
+  OperationDefinitionNode,
+  VariableNode,
+  SelectionSetNode,
+  FragmentSpreadNode,
+  FragmentDefinitionNode,
+} from '../language/ast';
+import { GraphQLSchema } from '../type/schema';
+import { GraphQLDirective } from '../type/directives';
+import {
+  GraphQLInputType,
+  GraphQLOutputType,
+  GraphQLCompositeType,
+  GraphQLField,
+  GraphQLArgument,
+} from '../type/definition';
+import { TypeInfo } from '../utilities/TypeInfo';
+
+type NodeWithSelectionSet = OperationDefinitionNode | FragmentDefinitionNode;
+type VariableUsage = {
+  readonly node: VariableNode;
+  readonly type: Maybe<GraphQLInputType>;
+  readonly defaultValue: Maybe<any>;
+};
+
+/**
+ * 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 {
+  constructor(ast: DocumentNode);
+
+  reportError(error: GraphQLError): undefined;
+
+  getErrors(): ReadonlyArray<GraphQLError>;
+
+  getDocument(): DocumentNode;
+
+  getFragment(name: string): Maybe<FragmentDefinitionNode>;
+
+  getFragmentSpreads(node: SelectionSetNode): ReadonlyArray<FragmentSpreadNode>;
+
+  getRecursivelyReferencedFragments(
+    operation: OperationDefinitionNode,
+  ): ReadonlyArray<FragmentDefinitionNode>;
+}
+
+export class SDLValidationContext extends ASTValidationContext {
+  constructor(
+    ast: DocumentNode,
+    schema: Maybe<GraphQLSchema>,
+    onError?: (err: GraphQLError) => void,
+  );
+
+  getSchema(): Maybe<GraphQLSchema>;
+}
+
+export type SDLValidationRule = (context: SDLValidationContext) => ASTVisitor;
+
+export class ValidationContext extends ASTValidationContext {
+  constructor(
+    schema: GraphQLSchema,
+    ast: DocumentNode,
+    typeInfo: TypeInfo,
+    onError?: (err: GraphQLError) => void,
+  );
+
+  getSchema(): GraphQLSchema;
+
+  getVariableUsages(node: NodeWithSelectionSet): ReadonlyArray<VariableUsage>;
+
+  getRecursivelyReferencedFragments(
+    operation: OperationDefinitionNode,
+  ): ReadonlyArray<FragmentDefinitionNode>;
+
+  getType(): Maybe<GraphQLOutputType>;
+
+  getParentType(): Maybe<GraphQLCompositeType>;
+
+  getInputType(): Maybe<GraphQLInputType>;
+
+  getParentInputType(): Maybe<GraphQLInputType>;
+
+  getFieldDef(): Maybe<GraphQLField<any, any>>;
+
+  getDirective(): Maybe<GraphQLDirective>;
+
+  getArgument(): Maybe<GraphQLArgument>;
+}
+
+export type ValidationRule = (context: ValidationContext) => ASTVisitor;

package/validation/ValidationContext.js

@@ -5,10 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ValidationContext = exports.SDLValidationContext = exports.ASTValidationContext = void 0;
 
-var _visitor = require("../language/visitor");
-
 var _kinds = require("../language/kinds");
 
+var _visitor = require("../language/visitor");
+
 var _TypeInfo = require("../utilities/TypeInfo");
 
 function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
@@ -21,19 +21,25 @@ function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.crea
 var ASTValidationContext =
 /*#__PURE__*/
 function () {
-  function ASTValidationContext(ast) {
+  function ASTValidationContext(ast, onError) {
     this._ast = ast;
     this._errors = [];
     this._fragments = undefined;
     this._fragmentSpreads = new Map();
     this._recursivelyReferencedFragments = new Map();
+    this._onError = onError;
   }
 
   var _proto = ASTValidationContext.prototype;
 
   _proto.reportError = function reportError(error) {
     this._errors.push(error);
-  };
+
+    if (this._onError) {
+      this._onError(error);
+    }
+  } // @deprecated: use onError callback instead - will be removed in v15.
+  ;
 
   _proto.getErrors = function getErrors() {
     return this._errors;
@@ -68,32 +74,14 @@ function () {
 
       while (setsToVisit.length !== 0) {
         var set = setsToVisit.pop();
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = undefined;
-
-        try {
-          for (var _iterator = set.selections[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-            var selection = _step.value;
-
-            if (selection.kind === _kinds.Kind.FRAGMENT_SPREAD) {
-              spreads.push(selection);
-            } else if (selection.selectionSet) {
-              setsToVisit.push(selection.selectionSet);
-            }
-          }
-        } catch (err) {
-          _didIteratorError = true;
-          _iteratorError = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-              _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
+
+        for (var _i2 = 0, _set$selections2 = set.selections; _i2 < _set$selections2.length; _i2++) {
+          var selection = _set$selections2[_i2];
+
+          if (selection.kind === _kinds.Kind.FRAGMENT_SPREAD) {
+            spreads.push(selection);
+          } else if (selection.selectionSet) {
+            setsToVisit.push(selection.selectionSet);
           }
         }
       }
@@ -114,36 +102,18 @@ function () {
 
       while (nodesToVisit.length !== 0) {
         var node = nodesToVisit.pop();
-        var _iteratorNormalCompletion2 = true;
-        var _didIteratorError2 = false;
-        var _iteratorError2 = undefined;
-
-        try {
-          for (var _iterator2 = this.getFragmentSpreads(node)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-            var spread = _step2.value;
-            var fragName = spread.name.value;
-
-            if (collectedNames[fragName] !== true) {
-              collectedNames[fragName] = true;
-              var fragment = this.getFragment(fragName);
-
-              if (fragment) {
-                fragments.push(fragment);
-                nodesToVisit.push(fragment.selectionSet);
-              }
-            }
-          }
-        } catch (err) {
-          _didIteratorError2 = true;
-          _iteratorError2 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-              _iterator2.return();
-            }
-          } finally {
-            if (_didIteratorError2) {
-              throw _iteratorError2;
+
+        for (var _i4 = 0, _this$getFragmentSpre2 = this.getFragmentSpreads(node); _i4 < _this$getFragmentSpre2.length; _i4++) {
+          var spread = _this$getFragmentSpre2[_i4];
+          var fragName = spread.name.value;
+
+          if (collectedNames[fragName] !== true) {
+            collectedNames[fragName] = true;
+            var fragment = this.getFragment(fragName);
+
+            if (fragment) {
+              fragments.push(fragment);
+              nodesToVisit.push(fragment.selectionSet);
             }
           }
         }
@@ -165,10 +135,10 @@ var SDLValidationContext =
 function (_ASTValidationContext) {
   _inheritsLoose(SDLValidationContext, _ASTValidationContext);
 
-  function SDLValidationContext(ast, schema) {
+  function SDLValidationContext(ast, schema, onError) {
     var _this;
 
-    _this = _ASTValidationContext.call(this, ast) || this;
+    _this = _ASTValidationContext.call(this, ast, onError) || this;
     _this._schema = schema;
     return _this;
   }
@@ -189,10 +159,10 @@ var ValidationContext =
 function (_ASTValidationContext2) {
   _inheritsLoose(ValidationContext, _ASTValidationContext2);
 
-  function ValidationContext(schema, ast, typeInfo) {
+  function ValidationContext(schema, ast, typeInfo, onError) {
     var _this2;
 
-    _this2 = _ASTValidationContext2.call(this, ast) || this;
+    _this2 = _ASTValidationContext2.call(this, ast, onError) || this;
     _this2._schema = schema;
     _this2._typeInfo = typeInfo;
     _this2._variableUsages = new Map();
@@ -237,28 +207,10 @@ function (_ASTValidationContext2) {
 
     if (!usages) {
       usages = this.getVariableUsages(operation);
-      var _iteratorNormalCompletion3 = true;
-      var _didIteratorError3 = false;
-      var _iteratorError3 = undefined;
-
-      try {
-        for (var _iterator3 = this.getRecursivelyReferencedFragments(operation)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-          var frag = _step3.value;
-          usages = usages.concat(this.getVariableUsages(frag));
-        }
-      } catch (err) {
-        _didIteratorError3 = true;
-        _iteratorError3 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-            _iterator3.return();
-          }
-        } finally {
-          if (_didIteratorError3) {
-            throw _iteratorError3;
-          }
-        }
+
+      for (var _i6 = 0, _this$getRecursivelyR2 = this.getRecursivelyReferencedFragments(operation); _i6 < _this$getRecursivelyR2.length; _i6++) {
+        var frag = _this$getRecursivelyR2[_i6];
+        usages = usages.concat(this.getVariableUsages(frag));
       }
 
       this._recursiveVariableUsages.set(operation, usages);

package/validation/ValidationContext.js.flow

@@ -1,9 +1,11 @@
 // @flow strict
 
 import { type ObjMap } from '../jsutils/ObjMap';
+
 import { type GraphQLError } from '../error/GraphQLError';
-import { type ASTVisitor, visit, visitWithTypeInfo } from '../language/visitor';
+
 import { Kind } from '../language/kinds';
+import { type ASTVisitor, visit, visitWithTypeInfo } from '../language/visitor';
 import {
   type DocumentNode,
   type OperationDefinitionNode,
@@ -12,7 +14,9 @@ import {
   type FragmentSpreadNode,
   type FragmentDefinitionNode,
 } from '../language/ast';
+
 import { type GraphQLSchema } from '../type/schema';
+import { type GraphQLDirective } from '../type/directives';
 import {
   type GraphQLInputType,
   type GraphQLOutputType,
@@ -20,7 +24,7 @@ import {
   type GraphQLField,
   type GraphQLArgument,
 } from '../type/definition';
-import { type GraphQLDirective } from '../type/directives';
+
 import { TypeInfo } from '../utilities/TypeInfo';
 
 type NodeWithSelectionSet = OperationDefinitionNode | FragmentDefinitionNode;
@@ -37,6 +41,7 @@ type VariableUsage = {|
  */
 export class ASTValidationContext {
   _ast: DocumentNode;
+  _onError: ?(err: GraphQLError) => void;
   _errors: Array<GraphQLError>;
   _fragments: ?ObjMap<FragmentDefinitionNode>;
   _fragmentSpreads: Map<SelectionSetNode, $ReadOnlyArray<FragmentSpreadNode>>;
@@ -45,18 +50,23 @@ export class ASTValidationContext {
     $ReadOnlyArray<FragmentDefinitionNode>,
   >;
 
-  constructor(ast: DocumentNode): void {
+  constructor(ast: DocumentNode, onError?: (err: GraphQLError) => void): void {
     this._ast = ast;
     this._errors = [];
     this._fragments = undefined;
     this._fragmentSpreads = new Map();
     this._recursivelyReferencedFragments = new Map();
+    this._onError = onError;
   }
 
   reportError(error: GraphQLError): void {
     this._errors.push(error);
+    if (this._onError) {
+      this._onError(error);
+    }
   }
 
+  // @deprecated: use onError callback instead - will be removed in v15.
   getErrors(): $ReadOnlyArray<GraphQLError> {
     return this._errors;
   }
@@ -136,8 +146,12 @@ export type ASTValidationRule = ASTValidationContext => ASTVisitor;
 export class SDLValidationContext extends ASTValidationContext {
   _schema: ?GraphQLSchema;
 
-  constructor(ast: DocumentNode, schema?: ?GraphQLSchema): void {
-    super(ast);
+  constructor(
+    ast: DocumentNode,
+    schema: ?GraphQLSchema,
+    onError: (err: GraphQLError) => void,
+  ): void {
+    super(ast, onError);
     this._schema = schema;
   }
 
@@ -161,8 +175,9 @@ export class ValidationContext extends ASTValidationContext {
     schema: GraphQLSchema,
     ast: DocumentNode,
     typeInfo: TypeInfo,
+    onError?: (err: GraphQLError) => void,
   ): void {
-    super(ast);
+    super(ast, onError);
     this._schema = schema;
     this._typeInfo = typeInfo;
     this._variableUsages = new Map();
@@ -227,7 +242,7 @@ export class ValidationContext extends ASTValidationContext {
     return this._typeInfo.getParentInputType();
   }
 
-  getFieldDef(): ?GraphQLField<*, *> {
+  getFieldDef(): ?GraphQLField<mixed, mixed> {
     return this._typeInfo.getFieldDef();
   }
 

package/validation/ValidationContext.mjs

@@ -1,7 +1,7 @@
 function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
 
-import { visit, visitWithTypeInfo } from '../language/visitor';
 import { Kind } from '../language/kinds';
+import { visit, visitWithTypeInfo } from '../language/visitor';
 import { TypeInfo } from '../utilities/TypeInfo';
 
 /**
@@ -12,19 +12,25 @@ import { TypeInfo } from '../utilities/TypeInfo';
 export var ASTValidationContext =
 /*#__PURE__*/
 function () {
-  function ASTValidationContext(ast) {
+  function ASTValidationContext(ast, onError) {
     this._ast = ast;
     this._errors = [];
     this._fragments = undefined;
     this._fragmentSpreads = new Map();
     this._recursivelyReferencedFragments = new Map();
+    this._onError = onError;
   }
 
   var _proto = ASTValidationContext.prototype;
 
   _proto.reportError = function reportError(error) {
     this._errors.push(error);
-  };
+
+    if (this._onError) {
+      this._onError(error);
+    }
+  } // @deprecated: use onError callback instead - will be removed in v15.
+  ;
 
   _proto.getErrors = function getErrors() {
     return this._errors;
@@ -59,32 +65,14 @@ function () {
 
       while (setsToVisit.length !== 0) {
         var set = setsToVisit.pop();
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = undefined;
-
-        try {
-          for (var _iterator = set.selections[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-            var selection = _step.value;
-
-            if (selection.kind === Kind.FRAGMENT_SPREAD) {
-              spreads.push(selection);
-            } else if (selection.selectionSet) {
-              setsToVisit.push(selection.selectionSet);
-            }
-          }
-        } catch (err) {
-          _didIteratorError = true;
-          _iteratorError = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-              _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
+
+        for (var _i2 = 0, _set$selections2 = set.selections; _i2 < _set$selections2.length; _i2++) {
+          var selection = _set$selections2[_i2];
+
+          if (selection.kind === Kind.FRAGMENT_SPREAD) {
+            spreads.push(selection);
+          } else if (selection.selectionSet) {
+            setsToVisit.push(selection.selectionSet);
           }
         }
       }
@@ -105,36 +93,18 @@ function () {
 
       while (nodesToVisit.length !== 0) {
         var node = nodesToVisit.pop();
-        var _iteratorNormalCompletion2 = true;
-        var _didIteratorError2 = false;
-        var _iteratorError2 = undefined;
-
-        try {
-          for (var _iterator2 = this.getFragmentSpreads(node)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-            var spread = _step2.value;
-            var fragName = spread.name.value;
-
-            if (collectedNames[fragName] !== true) {
-              collectedNames[fragName] = true;
-              var fragment = this.getFragment(fragName);
-
-              if (fragment) {
-                fragments.push(fragment);
-                nodesToVisit.push(fragment.selectionSet);
-              }
-            }
-          }
-        } catch (err) {
-          _didIteratorError2 = true;
-          _iteratorError2 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-              _iterator2.return();
-            }
-          } finally {
-            if (_didIteratorError2) {
-              throw _iteratorError2;
+
+        for (var _i4 = 0, _this$getFragmentSpre2 = this.getFragmentSpreads(node); _i4 < _this$getFragmentSpre2.length; _i4++) {
+          var spread = _this$getFragmentSpre2[_i4];
+          var fragName = spread.name.value;
+
+          if (collectedNames[fragName] !== true) {
+            collectedNames[fragName] = true;
+            var fragment = this.getFragment(fragName);
+
+            if (fragment) {
+              fragments.push(fragment);
+              nodesToVisit.push(fragment.selectionSet);
             }
           }
         }
@@ -153,10 +123,10 @@ export var SDLValidationContext =
 function (_ASTValidationContext) {
   _inheritsLoose(SDLValidationContext, _ASTValidationContext);
 
-  function SDLValidationContext(ast, schema) {
+  function SDLValidationContext(ast, schema, onError) {
     var _this;
 
-    _this = _ASTValidationContext.call(this, ast) || this;
+    _this = _ASTValidationContext.call(this, ast, onError) || this;
     _this._schema = schema;
     return _this;
   }
@@ -174,10 +144,10 @@ export var ValidationContext =
 function (_ASTValidationContext2) {
   _inheritsLoose(ValidationContext, _ASTValidationContext2);
 
-  function ValidationContext(schema, ast, typeInfo) {
+  function ValidationContext(schema, ast, typeInfo, onError) {
     var _this2;
 
-    _this2 = _ASTValidationContext2.call(this, ast) || this;
+    _this2 = _ASTValidationContext2.call(this, ast, onError) || this;
     _this2._schema = schema;
     _this2._typeInfo = typeInfo;
     _this2._variableUsages = new Map();
@@ -222,28 +192,10 @@ function (_ASTValidationContext2) {
 
     if (!usages) {
       usages = this.getVariableUsages(operation);
-      var _iteratorNormalCompletion3 = true;
-      var _didIteratorError3 = false;
-      var _iteratorError3 = undefined;
-
-      try {
-        for (var _iterator3 = this.getRecursivelyReferencedFragments(operation)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-          var frag = _step3.value;
-          usages = usages.concat(this.getVariableUsages(frag));
-        }
-      } catch (err) {
-        _didIteratorError3 = true;
-        _iteratorError3 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-            _iterator3.return();
-          }
-        } finally {
-          if (_didIteratorError3) {
-            throw _iteratorError3;
-          }
-        }
+
+      for (var _i6 = 0, _this$getRecursivelyR2 = this.getRecursivelyReferencedFragments(operation); _i6 < _this$getRecursivelyR2.length; _i6++) {
+        var frag = _this$getRecursivelyR2[_i6];
+        usages = usages.concat(this.getVariableUsages(frag));
       }
 
       this._recursiveVariableUsages.set(operation, usages);

package/validation/index.d.ts

@@ -0,0 +1,126 @@
+export { validate } from './validate';
+
+export { ValidationContext, ValidationRule } from './ValidationContext';
+
+export { specifiedRules } from './specifiedRules';
+
+// Spec Section: "Field Selections on Objects, Interfaces, and Unions Types"
+export {
+  FieldsOnCorrectType as FieldsOnCorrectTypeRule,
+} from './rules/FieldsOnCorrectType';
+
+// Spec Section: "Fragments on Composite Types"
+export {
+  FragmentsOnCompositeTypes as FragmentsOnCompositeTypesRule,
+} from './rules/FragmentsOnCompositeTypes';
+
+// Spec Section: "Argument Names"
+export {
+  KnownArgumentNames as KnownArgumentNamesRule,
+} from './rules/KnownArgumentNames';
+
+// Spec Section: "Directives Are Defined"
+export {
+  KnownDirectives as KnownDirectivesRule,
+} from './rules/KnownDirectives';
+
+// Spec Section: "Fragment spread target defined"
+export {
+  KnownFragmentNames as KnownFragmentNamesRule,
+} from './rules/KnownFragmentNames';
+
+// Spec Section: "Fragment Spread Type Existence"
+export { KnownTypeNames as KnownTypeNamesRule } from './rules/KnownTypeNames';
+
+// Spec Section: "Lone Anonymous Operation"
+export {
+  LoneAnonymousOperation as LoneAnonymousOperationRule,
+} from './rules/LoneAnonymousOperation';
+
+// Spec Section: "Fragments must not form cycles"
+export {
+  NoFragmentCycles as NoFragmentCyclesRule,
+} from './rules/NoFragmentCycles';
+
+// Spec Section: "All Variable Used Defined"
+export {
+  NoUndefinedVariables as NoUndefinedVariablesRule,
+} from './rules/NoUndefinedVariables';
+
+// Spec Section: "Fragments must be used"
+export {
+  NoUnusedFragments as NoUnusedFragmentsRule,
+} from './rules/NoUnusedFragments';
+
+// Spec Section: "All Variables Used"
+export {
+  NoUnusedVariables as NoUnusedVariablesRule,
+} from './rules/NoUnusedVariables';
+
+// Spec Section: "Field Selection Merging"
+export {
+  OverlappingFieldsCanBeMerged as OverlappingFieldsCanBeMergedRule,
+} from './rules/OverlappingFieldsCanBeMerged';
+
+// Spec Section: "Fragment spread is possible"
+export {
+  PossibleFragmentSpreads as PossibleFragmentSpreadsRule,
+} from './rules/PossibleFragmentSpreads';
+
+// Spec Section: "Argument Optionality"
+export {
+  ProvidedRequiredArguments as ProvidedRequiredArgumentsRule,
+} from './rules/ProvidedRequiredArguments';
+
+// Spec Section: "Leaf Field Selections"
+export { ScalarLeafs as ScalarLeafsRule } from './rules/ScalarLeafs';
+
+// Spec Section: "Subscriptions with Single Root Field"
+export {
+  SingleFieldSubscriptions as SingleFieldSubscriptionsRule,
+} from './rules/SingleFieldSubscriptions';
+
+// Spec Section: "Argument Uniqueness"
+export {
+  UniqueArgumentNames as UniqueArgumentNamesRule,
+} from './rules/UniqueArgumentNames';
+
+// Spec Section: "Directives Are Unique Per Location"
+export {
+  UniqueDirectivesPerLocation as UniqueDirectivesPerLocationRule,
+} from './rules/UniqueDirectivesPerLocation';
+
+// Spec Section: "Fragment Name Uniqueness"
+export {
+  UniqueFragmentNames as UniqueFragmentNamesRule,
+} from './rules/UniqueFragmentNames';
+
+// Spec Section: "Input Object Field Uniqueness"
+export {
+  UniqueInputFieldNames as UniqueInputFieldNamesRule,
+} from './rules/UniqueInputFieldNames';
+
+// Spec Section: "Operation Name Uniqueness"
+export {
+  UniqueOperationNames as UniqueOperationNamesRule,
+} from './rules/UniqueOperationNames';
+
+// Spec Section: "Variable Uniqueness"
+export {
+  UniqueVariableNames as UniqueVariableNamesRule,
+} from './rules/UniqueVariableNames';
+
+// Spec Section: "Values Type Correctness"
+export {
+  ValuesOfCorrectType as ValuesOfCorrectTypeRule,
+} from './rules/ValuesOfCorrectType';
+
+// Spec Section: "Variables are Input Types"
+export {
+  VariablesAreInputTypes as VariablesAreInputTypesRule,
+} from './rules/VariablesAreInputTypes';
+
+// Spec Section: "All Variable Usages Are Allowed"
+export {
+  VariablesInAllowedPosition as VariablesInAllowedPositionRule,
+} from './rules/VariablesInAllowedPosition';