graphql 0.0.1-test.1

package/validation/rules/custom/NoDeprecatedCustomRule.js

@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.NoDeprecatedCustomRule = NoDeprecatedCustomRule;
+
+var _invariant = require('../../../jsutils/invariant.js');
+
+var _GraphQLError = require('../../../error/GraphQLError.js');
+
+var _definition = require('../../../type/definition.js');
+
+/**
+ * No deprecated
+ *
+ * A GraphQL document is only valid if all selected fields and all used enum values have not been
+ * deprecated.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the GraphQL
+ * Specification. The main purpose of this rule is detection of deprecated usages and not
+ * necessarily to forbid their use when querying a service.
+ */
+function NoDeprecatedCustomRule(context) {
+  return {
+    Field(node) {
+      const fieldDef = context.getFieldDef();
+      const deprecationReason =
+        fieldDef === null || fieldDef === void 0
+          ? void 0
+          : fieldDef.deprecationReason;
+
+      if (fieldDef && deprecationReason != null) {
+        const parentType = context.getParentType();
+        parentType != null || (0, _invariant.invariant)(false);
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `The field ${parentType.name}.${fieldDef.name} is deprecated. ${deprecationReason}`,
+            node,
+          ),
+        );
+      }
+    },
+
+    Argument(node) {
+      const argDef = context.getArgument();
+      const deprecationReason =
+        argDef === null || argDef === void 0
+          ? void 0
+          : argDef.deprecationReason;
+
+      if (argDef && deprecationReason != null) {
+        const directiveDef = context.getDirective();
+
+        if (directiveDef != null) {
+          context.reportError(
+            new _GraphQLError.GraphQLError(
+              `Directive "@${directiveDef.name}" argument "${argDef.name}" is deprecated. ${deprecationReason}`,
+              node,
+            ),
+          );
+        } else {
+          const parentType = context.getParentType();
+          const fieldDef = context.getFieldDef();
+          (parentType != null && fieldDef != null) ||
+            (0, _invariant.invariant)(false);
+          context.reportError(
+            new _GraphQLError.GraphQLError(
+              `Field "${parentType.name}.${fieldDef.name}" argument "${argDef.name}" is deprecated. ${deprecationReason}`,
+              node,
+            ),
+          );
+        }
+      }
+    },
+
+    ObjectField(node) {
+      const inputObjectDef = (0, _definition.getNamedType)(
+        context.getParentInputType(),
+      );
+
+      if ((0, _definition.isInputObjectType)(inputObjectDef)) {
+        const inputFieldDef = inputObjectDef.getFields()[node.name.value];
+        const deprecationReason =
+          inputFieldDef === null || inputFieldDef === void 0
+            ? void 0
+            : inputFieldDef.deprecationReason;
+
+        if (deprecationReason != null) {
+          context.reportError(
+            new _GraphQLError.GraphQLError(
+              `The input field ${inputObjectDef.name}.${inputFieldDef.name} is deprecated. ${deprecationReason}`,
+              node,
+            ),
+          );
+        }
+      }
+    },
+
+    EnumValue(node) {
+      const enumValueDef = context.getEnumValue();
+      const deprecationReason =
+        enumValueDef === null || enumValueDef === void 0
+          ? void 0
+          : enumValueDef.deprecationReason;
+
+      if (enumValueDef && deprecationReason != null) {
+        const enumTypeDef = (0, _definition.getNamedType)(
+          context.getInputType(),
+        );
+        enumTypeDef != null || (0, _invariant.invariant)(false);
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `The enum value "${enumTypeDef.name}.${enumValueDef.name}" is deprecated. ${deprecationReason}`,
+            node,
+          ),
+        );
+      }
+    },
+  };
+}

package/validation/rules/custom/NoDeprecatedCustomRule.mjs

@@ -0,0 +1,107 @@
+import { invariant } from '../../../jsutils/invariant.mjs';
+import { GraphQLError } from '../../../error/GraphQLError.mjs';
+import { getNamedType, isInputObjectType } from '../../../type/definition.mjs';
+
+/**
+ * No deprecated
+ *
+ * A GraphQL document is only valid if all selected fields and all used enum values have not been
+ * deprecated.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the GraphQL
+ * Specification. The main purpose of this rule is detection of deprecated usages and not
+ * necessarily to forbid their use when querying a service.
+ */
+export function NoDeprecatedCustomRule(context) {
+  return {
+    Field(node) {
+      const fieldDef = context.getFieldDef();
+      const deprecationReason =
+        fieldDef === null || fieldDef === void 0
+          ? void 0
+          : fieldDef.deprecationReason;
+
+      if (fieldDef && deprecationReason != null) {
+        const parentType = context.getParentType();
+        parentType != null || invariant(false);
+        context.reportError(
+          new GraphQLError(
+            `The field ${parentType.name}.${fieldDef.name} is deprecated. ${deprecationReason}`,
+            node,
+          ),
+        );
+      }
+    },
+
+    Argument(node) {
+      const argDef = context.getArgument();
+      const deprecationReason =
+        argDef === null || argDef === void 0
+          ? void 0
+          : argDef.deprecationReason;
+
+      if (argDef && deprecationReason != null) {
+        const directiveDef = context.getDirective();
+
+        if (directiveDef != null) {
+          context.reportError(
+            new GraphQLError(
+              `Directive "@${directiveDef.name}" argument "${argDef.name}" is deprecated. ${deprecationReason}`,
+              node,
+            ),
+          );
+        } else {
+          const parentType = context.getParentType();
+          const fieldDef = context.getFieldDef();
+          (parentType != null && fieldDef != null) || invariant(false);
+          context.reportError(
+            new GraphQLError(
+              `Field "${parentType.name}.${fieldDef.name}" argument "${argDef.name}" is deprecated. ${deprecationReason}`,
+              node,
+            ),
+          );
+        }
+      }
+    },
+
+    ObjectField(node) {
+      const inputObjectDef = getNamedType(context.getParentInputType());
+
+      if (isInputObjectType(inputObjectDef)) {
+        const inputFieldDef = inputObjectDef.getFields()[node.name.value];
+        const deprecationReason =
+          inputFieldDef === null || inputFieldDef === void 0
+            ? void 0
+            : inputFieldDef.deprecationReason;
+
+        if (deprecationReason != null) {
+          context.reportError(
+            new GraphQLError(
+              `The input field ${inputObjectDef.name}.${inputFieldDef.name} is deprecated. ${deprecationReason}`,
+              node,
+            ),
+          );
+        }
+      }
+    },
+
+    EnumValue(node) {
+      const enumValueDef = context.getEnumValue();
+      const deprecationReason =
+        enumValueDef === null || enumValueDef === void 0
+          ? void 0
+          : enumValueDef.deprecationReason;
+
+      if (enumValueDef && deprecationReason != null) {
+        const enumTypeDef = getNamedType(context.getInputType());
+        enumTypeDef != null || invariant(false);
+        context.reportError(
+          new GraphQLError(
+            `The enum value "${enumTypeDef.name}.${enumValueDef.name}" is deprecated. ${deprecationReason}`,
+            node,
+          ),
+        );
+      }
+    },
+  };
+}

package/validation/rules/custom/NoSchemaIntrospectionCustomRule.d.ts

@@ -0,0 +1,15 @@
+import type { ASTVisitor } from '../../../language/visitor';
+import type { ValidationContext } from '../../ValidationContext';
+/**
+ * Prohibit introspection queries
+ *
+ * A GraphQL document is only valid if all fields selected are not fields that
+ * return an introspection type.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the
+ * GraphQL Specification. This rule effectively disables introspection, which
+ * does not reflect best practices and should only be done if absolutely necessary.
+ */
+export declare function NoSchemaIntrospectionCustomRule(
+  context: ValidationContext,
+): ASTVisitor;

package/validation/rules/custom/NoSchemaIntrospectionCustomRule.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.NoSchemaIntrospectionCustomRule = NoSchemaIntrospectionCustomRule;
+
+var _GraphQLError = require('../../../error/GraphQLError.js');
+
+var _definition = require('../../../type/definition.js');
+
+var _introspection = require('../../../type/introspection.js');
+
+/**
+ * Prohibit introspection queries
+ *
+ * A GraphQL document is only valid if all fields selected are not fields that
+ * return an introspection type.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the
+ * GraphQL Specification. This rule effectively disables introspection, which
+ * does not reflect best practices and should only be done if absolutely necessary.
+ */
+function NoSchemaIntrospectionCustomRule(context) {
+  return {
+    Field(node) {
+      const type = (0, _definition.getNamedType)(context.getType());
+
+      if (type && (0, _introspection.isIntrospectionType)(type)) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `GraphQL introspection has been disabled, but the requested query contained the field "${node.name.value}".`,
+            node,
+          ),
+        );
+      }
+    },
+  };
+}

package/validation/rules/custom/NoSchemaIntrospectionCustomRule.mjs

@@ -0,0 +1,30 @@
+import { GraphQLError } from '../../../error/GraphQLError.mjs';
+import { getNamedType } from '../../../type/definition.mjs';
+import { isIntrospectionType } from '../../../type/introspection.mjs';
+
+/**
+ * Prohibit introspection queries
+ *
+ * A GraphQL document is only valid if all fields selected are not fields that
+ * return an introspection type.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the
+ * GraphQL Specification. This rule effectively disables introspection, which
+ * does not reflect best practices and should only be done if absolutely necessary.
+ */
+export function NoSchemaIntrospectionCustomRule(context) {
+  return {
+    Field(node) {
+      const type = getNamedType(context.getType());
+
+      if (type && isIntrospectionType(type)) {
+        context.reportError(
+          new GraphQLError(
+            `GraphQL introspection has been disabled, but the requested query contained the field "${node.name.value}".`,
+            node,
+          ),
+        );
+      }
+    },
+  };
+}

package/validation/specifiedRules.d.ts

@@ -0,0 +1,12 @@
+import type { SDLValidationRule, ValidationRule } from './ValidationContext';
+/**
+ * This set includes all validation rules defined by the GraphQL spec.
+ *
+ * The order of the rules in this list has been adjusted to lead to the
+ * most clear output when encountering multiple validation errors.
+ */
+export declare const specifiedRules: ReadonlyArray<ValidationRule>;
+/**
+ * @internal
+ */
+export declare const specifiedSDLRules: ReadonlyArray<SDLValidationRule>;

package/validation/specifiedRules.js

@@ -0,0 +1,160 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.specifiedSDLRules = exports.specifiedRules = void 0;
+
+var _ExecutableDefinitionsRule = require('./rules/ExecutableDefinitionsRule.js');
+
+var _FieldsOnCorrectTypeRule = require('./rules/FieldsOnCorrectTypeRule.js');
+
+var _FragmentsOnCompositeTypesRule = require('./rules/FragmentsOnCompositeTypesRule.js');
+
+var _KnownArgumentNamesRule = require('./rules/KnownArgumentNamesRule.js');
+
+var _KnownDirectivesRule = require('./rules/KnownDirectivesRule.js');
+
+var _KnownFragmentNamesRule = require('./rules/KnownFragmentNamesRule.js');
+
+var _KnownTypeNamesRule = require('./rules/KnownTypeNamesRule.js');
+
+var _LoneAnonymousOperationRule = require('./rules/LoneAnonymousOperationRule.js');
+
+var _LoneSchemaDefinitionRule = require('./rules/LoneSchemaDefinitionRule.js');
+
+var _NoFragmentCyclesRule = require('./rules/NoFragmentCyclesRule.js');
+
+var _NoUndefinedVariablesRule = require('./rules/NoUndefinedVariablesRule.js');
+
+var _NoUnusedFragmentsRule = require('./rules/NoUnusedFragmentsRule.js');
+
+var _NoUnusedVariablesRule = require('./rules/NoUnusedVariablesRule.js');
+
+var _OverlappingFieldsCanBeMergedRule = require('./rules/OverlappingFieldsCanBeMergedRule.js');
+
+var _PossibleFragmentSpreadsRule = require('./rules/PossibleFragmentSpreadsRule.js');
+
+var _PossibleTypeExtensionsRule = require('./rules/PossibleTypeExtensionsRule.js');
+
+var _ProvidedRequiredArgumentsRule = require('./rules/ProvidedRequiredArgumentsRule.js');
+
+var _ScalarLeafsRule = require('./rules/ScalarLeafsRule.js');
+
+var _SingleFieldSubscriptionsRule = require('./rules/SingleFieldSubscriptionsRule.js');
+
+var _UniqueArgumentDefinitionNamesRule = require('./rules/UniqueArgumentDefinitionNamesRule.js');
+
+var _UniqueArgumentNamesRule = require('./rules/UniqueArgumentNamesRule.js');
+
+var _UniqueDirectiveNamesRule = require('./rules/UniqueDirectiveNamesRule.js');
+
+var _UniqueDirectivesPerLocationRule = require('./rules/UniqueDirectivesPerLocationRule.js');
+
+var _UniqueEnumValueNamesRule = require('./rules/UniqueEnumValueNamesRule.js');
+
+var _UniqueFieldDefinitionNamesRule = require('./rules/UniqueFieldDefinitionNamesRule.js');
+
+var _UniqueFragmentNamesRule = require('./rules/UniqueFragmentNamesRule.js');
+
+var _UniqueInputFieldNamesRule = require('./rules/UniqueInputFieldNamesRule.js');
+
+var _UniqueOperationNamesRule = require('./rules/UniqueOperationNamesRule.js');
+
+var _UniqueOperationTypesRule = require('./rules/UniqueOperationTypesRule.js');
+
+var _UniqueTypeNamesRule = require('./rules/UniqueTypeNamesRule.js');
+
+var _UniqueVariableNamesRule = require('./rules/UniqueVariableNamesRule.js');
+
+var _ValuesOfCorrectTypeRule = require('./rules/ValuesOfCorrectTypeRule.js');
+
+var _VariablesAreInputTypesRule = require('./rules/VariablesAreInputTypesRule.js');
+
+var _VariablesInAllowedPositionRule = require('./rules/VariablesInAllowedPositionRule.js');
+
+// Spec Section: "Executable Definitions"
+// Spec Section: "Field Selections on Objects, Interfaces, and Unions Types"
+// Spec Section: "Fragments on Composite Types"
+// Spec Section: "Argument Names"
+// Spec Section: "Directives Are Defined"
+// Spec Section: "Fragment spread target defined"
+// Spec Section: "Fragment Spread Type Existence"
+// Spec Section: "Lone Anonymous Operation"
+// SDL-specific validation rules
+// Spec Section: "Fragments must not form cycles"
+// Spec Section: "All Variable Used Defined"
+// Spec Section: "Fragments must be used"
+// Spec Section: "All Variables Used"
+// Spec Section: "Field Selection Merging"
+// Spec Section: "Fragment spread is possible"
+// Spec Section: "Argument Optionality"
+// Spec Section: "Leaf Field Selections"
+// Spec Section: "Subscriptions with Single Root Field"
+// Spec Section: "Argument Uniqueness"
+// Spec Section: "Directives Are Unique Per Location"
+// Spec Section: "Fragment Name Uniqueness"
+// Spec Section: "Input Object Field Uniqueness"
+// Spec Section: "Operation Name Uniqueness"
+// Spec Section: "Variable Uniqueness"
+// Spec Section: "Value Type Correctness"
+// Spec Section: "Variables are Input Types"
+// Spec Section: "All Variable Usages Are Allowed"
+
+/**
+ * This set includes all validation rules defined by the GraphQL spec.
+ *
+ * The order of the rules in this list has been adjusted to lead to the
+ * most clear output when encountering multiple validation errors.
+ */
+const specifiedRules = Object.freeze([
+  _ExecutableDefinitionsRule.ExecutableDefinitionsRule,
+  _UniqueOperationNamesRule.UniqueOperationNamesRule,
+  _LoneAnonymousOperationRule.LoneAnonymousOperationRule,
+  _SingleFieldSubscriptionsRule.SingleFieldSubscriptionsRule,
+  _KnownTypeNamesRule.KnownTypeNamesRule,
+  _FragmentsOnCompositeTypesRule.FragmentsOnCompositeTypesRule,
+  _VariablesAreInputTypesRule.VariablesAreInputTypesRule,
+  _ScalarLeafsRule.ScalarLeafsRule,
+  _FieldsOnCorrectTypeRule.FieldsOnCorrectTypeRule,
+  _UniqueFragmentNamesRule.UniqueFragmentNamesRule,
+  _KnownFragmentNamesRule.KnownFragmentNamesRule,
+  _NoUnusedFragmentsRule.NoUnusedFragmentsRule,
+  _PossibleFragmentSpreadsRule.PossibleFragmentSpreadsRule,
+  _NoFragmentCyclesRule.NoFragmentCyclesRule,
+  _UniqueVariableNamesRule.UniqueVariableNamesRule,
+  _NoUndefinedVariablesRule.NoUndefinedVariablesRule,
+  _NoUnusedVariablesRule.NoUnusedVariablesRule,
+  _KnownDirectivesRule.KnownDirectivesRule,
+  _UniqueDirectivesPerLocationRule.UniqueDirectivesPerLocationRule,
+  _KnownArgumentNamesRule.KnownArgumentNamesRule,
+  _UniqueArgumentNamesRule.UniqueArgumentNamesRule,
+  _ValuesOfCorrectTypeRule.ValuesOfCorrectTypeRule,
+  _ProvidedRequiredArgumentsRule.ProvidedRequiredArgumentsRule,
+  _VariablesInAllowedPositionRule.VariablesInAllowedPositionRule,
+  _OverlappingFieldsCanBeMergedRule.OverlappingFieldsCanBeMergedRule,
+  _UniqueInputFieldNamesRule.UniqueInputFieldNamesRule,
+]);
+/**
+ * @internal
+ */
+
+exports.specifiedRules = specifiedRules;
+const specifiedSDLRules = Object.freeze([
+  _LoneSchemaDefinitionRule.LoneSchemaDefinitionRule,
+  _UniqueOperationTypesRule.UniqueOperationTypesRule,
+  _UniqueTypeNamesRule.UniqueTypeNamesRule,
+  _UniqueEnumValueNamesRule.UniqueEnumValueNamesRule,
+  _UniqueFieldDefinitionNamesRule.UniqueFieldDefinitionNamesRule,
+  _UniqueArgumentDefinitionNamesRule.UniqueArgumentDefinitionNamesRule,
+  _UniqueDirectiveNamesRule.UniqueDirectiveNamesRule,
+  _KnownTypeNamesRule.KnownTypeNamesRule,
+  _KnownDirectivesRule.KnownDirectivesRule,
+  _UniqueDirectivesPerLocationRule.UniqueDirectivesPerLocationRule,
+  _PossibleTypeExtensionsRule.PossibleTypeExtensionsRule,
+  _KnownArgumentNamesRule.KnownArgumentNamesOnDirectivesRule,
+  _UniqueArgumentNamesRule.UniqueArgumentNamesRule,
+  _UniqueInputFieldNamesRule.UniqueInputFieldNamesRule,
+  _ProvidedRequiredArgumentsRule.ProvidedRequiredArgumentsOnDirectivesRule,
+]);
+exports.specifiedSDLRules = specifiedSDLRules;

package/validation/specifiedRules.mjs

@@ -0,0 +1,123 @@
+// Spec Section: "Executable Definitions"
+import { ExecutableDefinitionsRule } from './rules/ExecutableDefinitionsRule.mjs'; // Spec Section: "Field Selections on Objects, Interfaces, and Unions Types"
+
+import { FieldsOnCorrectTypeRule } from './rules/FieldsOnCorrectTypeRule.mjs'; // Spec Section: "Fragments on Composite Types"
+
+import { FragmentsOnCompositeTypesRule } from './rules/FragmentsOnCompositeTypesRule.mjs'; // Spec Section: "Argument Names"
+
+import {
+  KnownArgumentNamesOnDirectivesRule,
+  KnownArgumentNamesRule,
+} from './rules/KnownArgumentNamesRule.mjs'; // Spec Section: "Directives Are Defined"
+
+import { KnownDirectivesRule } from './rules/KnownDirectivesRule.mjs'; // Spec Section: "Fragment spread target defined"
+
+import { KnownFragmentNamesRule } from './rules/KnownFragmentNamesRule.mjs'; // Spec Section: "Fragment Spread Type Existence"
+
+import { KnownTypeNamesRule } from './rules/KnownTypeNamesRule.mjs'; // Spec Section: "Lone Anonymous Operation"
+
+import { LoneAnonymousOperationRule } from './rules/LoneAnonymousOperationRule.mjs'; // SDL-specific validation rules
+
+import { LoneSchemaDefinitionRule } from './rules/LoneSchemaDefinitionRule.mjs'; // Spec Section: "Fragments must not form cycles"
+
+import { NoFragmentCyclesRule } from './rules/NoFragmentCyclesRule.mjs'; // Spec Section: "All Variable Used Defined"
+
+import { NoUndefinedVariablesRule } from './rules/NoUndefinedVariablesRule.mjs'; // Spec Section: "Fragments must be used"
+
+import { NoUnusedFragmentsRule } from './rules/NoUnusedFragmentsRule.mjs'; // Spec Section: "All Variables Used"
+
+import { NoUnusedVariablesRule } from './rules/NoUnusedVariablesRule.mjs'; // Spec Section: "Field Selection Merging"
+
+import { OverlappingFieldsCanBeMergedRule } from './rules/OverlappingFieldsCanBeMergedRule.mjs'; // Spec Section: "Fragment spread is possible"
+
+import { PossibleFragmentSpreadsRule } from './rules/PossibleFragmentSpreadsRule.mjs';
+import { PossibleTypeExtensionsRule } from './rules/PossibleTypeExtensionsRule.mjs'; // Spec Section: "Argument Optionality"
+
+import {
+  ProvidedRequiredArgumentsOnDirectivesRule,
+  ProvidedRequiredArgumentsRule,
+} from './rules/ProvidedRequiredArgumentsRule.mjs'; // Spec Section: "Leaf Field Selections"
+
+import { ScalarLeafsRule } from './rules/ScalarLeafsRule.mjs'; // Spec Section: "Subscriptions with Single Root Field"
+
+import { SingleFieldSubscriptionsRule } from './rules/SingleFieldSubscriptionsRule.mjs';
+import { UniqueArgumentDefinitionNamesRule } from './rules/UniqueArgumentDefinitionNamesRule.mjs'; // Spec Section: "Argument Uniqueness"
+
+import { UniqueArgumentNamesRule } from './rules/UniqueArgumentNamesRule.mjs';
+import { UniqueDirectiveNamesRule } from './rules/UniqueDirectiveNamesRule.mjs'; // Spec Section: "Directives Are Unique Per Location"
+
+import { UniqueDirectivesPerLocationRule } from './rules/UniqueDirectivesPerLocationRule.mjs';
+import { UniqueEnumValueNamesRule } from './rules/UniqueEnumValueNamesRule.mjs';
+import { UniqueFieldDefinitionNamesRule } from './rules/UniqueFieldDefinitionNamesRule.mjs'; // Spec Section: "Fragment Name Uniqueness"
+
+import { UniqueFragmentNamesRule } from './rules/UniqueFragmentNamesRule.mjs'; // Spec Section: "Input Object Field Uniqueness"
+
+import { UniqueInputFieldNamesRule } from './rules/UniqueInputFieldNamesRule.mjs'; // Spec Section: "Operation Name Uniqueness"
+
+import { UniqueOperationNamesRule } from './rules/UniqueOperationNamesRule.mjs';
+import { UniqueOperationTypesRule } from './rules/UniqueOperationTypesRule.mjs';
+import { UniqueTypeNamesRule } from './rules/UniqueTypeNamesRule.mjs'; // Spec Section: "Variable Uniqueness"
+
+import { UniqueVariableNamesRule } from './rules/UniqueVariableNamesRule.mjs'; // Spec Section: "Value Type Correctness"
+
+import { ValuesOfCorrectTypeRule } from './rules/ValuesOfCorrectTypeRule.mjs'; // Spec Section: "Variables are Input Types"
+
+import { VariablesAreInputTypesRule } from './rules/VariablesAreInputTypesRule.mjs'; // Spec Section: "All Variable Usages Are Allowed"
+
+import { VariablesInAllowedPositionRule } from './rules/VariablesInAllowedPositionRule.mjs';
+
+/**
+ * This set includes all validation rules defined by the GraphQL spec.
+ *
+ * The order of the rules in this list has been adjusted to lead to the
+ * most clear output when encountering multiple validation errors.
+ */
+export const specifiedRules = Object.freeze([
+  ExecutableDefinitionsRule,
+  UniqueOperationNamesRule,
+  LoneAnonymousOperationRule,
+  SingleFieldSubscriptionsRule,
+  KnownTypeNamesRule,
+  FragmentsOnCompositeTypesRule,
+  VariablesAreInputTypesRule,
+  ScalarLeafsRule,
+  FieldsOnCorrectTypeRule,
+  UniqueFragmentNamesRule,
+  KnownFragmentNamesRule,
+  NoUnusedFragmentsRule,
+  PossibleFragmentSpreadsRule,
+  NoFragmentCyclesRule,
+  UniqueVariableNamesRule,
+  NoUndefinedVariablesRule,
+  NoUnusedVariablesRule,
+  KnownDirectivesRule,
+  UniqueDirectivesPerLocationRule,
+  KnownArgumentNamesRule,
+  UniqueArgumentNamesRule,
+  ValuesOfCorrectTypeRule,
+  ProvidedRequiredArgumentsRule,
+  VariablesInAllowedPositionRule,
+  OverlappingFieldsCanBeMergedRule,
+  UniqueInputFieldNamesRule,
+]);
+/**
+ * @internal
+ */
+
+export const specifiedSDLRules = Object.freeze([
+  LoneSchemaDefinitionRule,
+  UniqueOperationTypesRule,
+  UniqueTypeNamesRule,
+  UniqueEnumValueNamesRule,
+  UniqueFieldDefinitionNamesRule,
+  UniqueArgumentDefinitionNamesRule,
+  UniqueDirectiveNamesRule,
+  KnownTypeNamesRule,
+  KnownDirectivesRule,
+  UniqueDirectivesPerLocationRule,
+  PossibleTypeExtensionsRule,
+  KnownArgumentNamesOnDirectivesRule,
+  UniqueArgumentNamesRule,
+  UniqueInputFieldNamesRule,
+  ProvidedRequiredArgumentsOnDirectivesRule,
+]);

package/validation/validate.d.ts

@@ -0,0 +1,61 @@
+import type { Maybe } from '../jsutils/Maybe';
+import { GraphQLError } from '../error/GraphQLError';
+import type { DocumentNode } from '../language/ast';
+import type { GraphQLSchema } from '../type/schema';
+import { TypeInfo } from '../utilities/TypeInfo';
+import type { SDLValidationRule, ValidationRule } from './ValidationContext';
+/**
+ * Implements the "Validation" section of the spec.
+ *
+ * Validation runs synchronously, returning an array of encountered errors, or
+ * an empty array if no errors were encountered and the document is valid.
+ *
+ * A list of specific validation rules may be provided. If not provided, the
+ * default list of rules defined by the GraphQL specification will be used.
+ *
+ * Each validation rules is a function which returns a visitor
+ * (see the language/visitor API). Visitor methods are expected to return
+ * GraphQLErrors, or Arrays of GraphQLErrors when invalid.
+ *
+ * Validate will stop validation after a `maxErrors` limit has been reached.
+ * Attackers can send pathologically invalid queries to induce a DoS attack,
+ * so by default `maxErrors` set to 100 errors.
+ *
+ * Optionally a custom TypeInfo instance may be provided. If not provided, one
+ * will be created from the provided schema.
+ */
+export declare function validate(
+  schema: GraphQLSchema,
+  documentAST: DocumentNode,
+  rules?: ReadonlyArray<ValidationRule>,
+  options?: {
+    maxErrors?: number;
+  },
+  /** @deprecated will be removed in 17.0.0 */
+  typeInfo?: TypeInfo,
+): ReadonlyArray<GraphQLError>;
+/**
+ * @internal
+ */
+export declare function validateSDL(
+  documentAST: DocumentNode,
+  schemaToExtend?: Maybe<GraphQLSchema>,
+  rules?: ReadonlyArray<SDLValidationRule>,
+): ReadonlyArray<GraphQLError>;
+/**
+ * Utility function which asserts a SDL document is valid by throwing an error
+ * if it is invalid.
+ *
+ * @internal
+ */
+export declare function assertValidSDL(documentAST: DocumentNode): void;
+/**
+ * Utility function which asserts a SDL document is valid by throwing an error
+ * if it is invalid.
+ *
+ * @internal
+ */
+export declare function assertValidSDLExtension(
+  documentAST: DocumentNode,
+  schema: GraphQLSchema,
+): void;