@graphql-eslint/eslint-plugin 4.0.0-alpha-20230801163310-8bc4340 → 4.0.0-alpha-20230810155929-e89edf7

package/cjs/rules/graphql-js-validation.js

@@ -5,25 +5,20 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
     for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var graphql_js_validation_exports = {};
 __export(graphql_js_validation_exports, {
   GRAPHQL_JS_VALIDATIONS: () => GRAPHQL_JS_VALIDATIONS
 });
 module.exports = __toCommonJS(graphql_js_validation_exports);
-var import_graphql = require("graphql");
-var import_validate = require("graphql/validation/validate.js");
-var import_utils = require("../utils.js");
+var import_graphql = require("graphql"), import_validation = require("graphql/validation/index.js"), import_validate = require("graphql/validation/validate.js"), import_utils = require("../utils.js");
 function validateDocument({
   context,
   schema = null,
@@ -31,78 +26,61 @@ function validateDocument({
   rule,
   hasDidYouMeanSuggestions
 }) {
-  var _a;
-  if (documentNode.definitions.length === 0) {
-    return;
-  }
-  try {
-    const validationErrors = schema ? (0, import_graphql.validate)(schema, documentNode, [rule]) : (0, import_validate.validateSDL)(documentNode, null, [rule]);
-    for (const error of validationErrors) {
-      const { line, column } = error.locations[0];
-      const sourceCode = context.getSourceCode();
-      const { tokens } = sourceCode.ast;
-      const token = tokens.find(
-        (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
-      );
-      let loc = {
-        line,
-        column: column - 1
-      };
-      if (token) {
-        loc = // if cursor on `@` symbol than use next node
-        token.type === "@" ? sourceCode.getNodeByRangeIndex(token.range[1] + 1).loc : token.loc;
+  if (documentNode.definitions.length !== 0)
+    try {
+      const validationErrors = schema ? (0, import_graphql.validate)(schema, documentNode, [rule]) : (0, import_validate.validateSDL)(documentNode, null, [rule]);
+      for (const error of validationErrors) {
+        const { line, column } = error.locations[0], sourceCode = context.getSourceCode(), { tokens } = sourceCode.ast, token = tokens.find(
+          (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
+        );
+        let loc = {
+          line,
+          column: column - 1
+        };
+        token && (loc = // if cursor on `@` symbol than use next node
+        token.type === "@" ? sourceCode.getNodeByRangeIndex(token.range[1] + 1).loc : token.loc);
+        const didYouMeanContent = error.message.match(/Did you mean (?<content>.*)\?$/)?.groups.content, matches = didYouMeanContent ? [...didYouMeanContent.matchAll(/"(?<name>[^"]*)"/g)] : [];
+        context.report({
+          loc,
+          message: error.message,
+          suggest: hasDidYouMeanSuggestions ? matches.map((match) => {
+            const { name } = match.groups;
+            return {
+              desc: `Rename to \`${name}\``,
+              fix: (fixer) => fixer.replaceText(token, name)
+            };
+          }) : []
+        });
       }
-      const didYouMeanContent = (_a = error.message.match(/Did you mean (?<content>.*)\?$/)) == null ? void 0 : _a.groups.content;
-      const matches = didYouMeanContent ? [...didYouMeanContent.matchAll(/"(?<name>[^"]*)"/g)] : [];
+    } catch (error) {
       context.report({
-        loc,
-        message: error.message,
-        suggest: hasDidYouMeanSuggestions ? matches.map((match) => {
-          const { name } = match.groups;
-          return {
-            desc: `Rename to \`${name}\``,
-            fix: (fixer) => fixer.replaceText(token, name)
-          };
-        }) : []
+        loc: import_utils.REPORT_ON_FIRST_CHARACTER,
+        message: error.message
       });
     }
-  } catch (error) {
-    context.report({
-      loc: import_utils.REPORT_ON_FIRST_CHARACTER,
-      message: error.message
-    });
-  }
 }
 const getFragmentDefsAndFragmentSpreads = (node) => {
-  const fragmentDefs = /* @__PURE__ */ new Set();
-  const fragmentSpreads = /* @__PURE__ */ new Set();
-  const visitor = {
+  const fragmentDefs = /* @__PURE__ */ new Set(), fragmentSpreads = /* @__PURE__ */ new Set();
+  return (0, import_graphql.visit)(node, {
     FragmentDefinition(node2) {
       fragmentDefs.add(node2.name.value);
     },
     FragmentSpread(node2) {
       fragmentSpreads.add(node2.name.value);
     }
-  };
-  (0, import_graphql.visit)(node, visitor);
-  return { fragmentDefs, fragmentSpreads };
-};
-const getMissingFragments = (node) => {
+  }), { fragmentDefs, fragmentSpreads };
+}, getMissingFragments = (node) => {
   const { fragmentDefs, fragmentSpreads } = getFragmentDefsAndFragmentSpreads(node);
   return [...fragmentSpreads].filter((name) => !fragmentDefs.has(name));
-};
-const handleMissingFragments = ({ ruleId, context, node }) => {
+}, handleMissingFragments = ({ ruleId, context, node }) => {
   const missingFragments = getMissingFragments(node);
   if (missingFragments.length > 0) {
-    const siblings = (0, import_utils.requireSiblingsOperations)(ruleId, context);
-    const fragmentsToAdd = [];
+    const siblings = (0, import_utils.requireSiblingsOperations)(ruleId, context), fragmentsToAdd = [];
     for (const fragmentName of missingFragments) {
       const [foundFragment] = siblings.getFragment(fragmentName).map((source) => source.document);
-      if (foundFragment) {
-        fragmentsToAdd.push(foundFragment);
-      }
+      foundFragment && fragmentsToAdd.push(foundFragment);
     }
-    if (fragmentsToAdd.length > 0) {
+    if (fragmentsToAdd.length > 0)
       return handleMissingFragments({
         ruleId,
         context,
@@ -111,131 +89,105 @@ const handleMissingFragments = ({ ruleId, context, node }) => {
           definitions: [...node.definitions, ...fragmentsToAdd]
         }
       });
-    }
   }
   return node;
-};
-const validationToRule = ({
+}, validationToRule = ({
   ruleId,
-  ruleName,
+  rule,
   getDocumentNode,
   schema = [],
   hasDidYouMeanSuggestions
-}, docs) => {
-  let ruleFn = null;
-  try {
-    ruleFn = require(`graphql/validation/rules/${ruleName}Rule`)[`${ruleName}Rule`];
-  } catch {
-    try {
-      ruleFn = require(`graphql/validation/rules/${ruleName}`)[`${ruleName}Rule`];
-    } catch {
-      ruleFn = require("graphql/validation")[`${ruleName}Rule`];
-    }
-  }
-  return {
-    [ruleId]: {
-      meta: {
-        docs: {
-          recommended: true,
-          ...docs,
-          graphQLJSRuleName: ruleName,
-          url: `https://the-guild.dev/graphql/eslint/rules/${ruleId}`,
-          description: `${docs.description}
+}, docs) => ({
+  [ruleId]: {
+    meta: {
+      docs: {
+        recommended: !0,
+        ...docs,
+        graphQLJSRuleName: rule.name,
+        url: `https://the-guild.dev/graphql/eslint/rules/${ruleId}`,
+        description: `${docs.description}
 > This rule is a wrapper around a \`graphql-js\` validation function.`
-        },
-        schema,
-        hasSuggestions: hasDidYouMeanSuggestions
       },
-      create(context) {
-        if (!ruleFn) {
-          import_utils.logger.warn(
-            `Rule "${ruleId}" depends on a GraphQL validation rule "${ruleName}" but it's not available in the "graphql" version you are using. Skipping\u2026`
-          );
-          return {};
+      schema,
+      hasSuggestions: hasDidYouMeanSuggestions
+    },
+    create(context) {
+      return {
+        Document(node) {
+          const schema2 = docs.requiresSchema ? (0, import_utils.requireGraphQLSchemaFromContext)(ruleId, context) : null, documentNode = getDocumentNode ? getDocumentNode({ ruleId, context, node: node.rawNode() }) : node.rawNode();
+          validateDocument({
+            context,
+            schema: schema2,
+            documentNode,
+            rule,
+            hasDidYouMeanSuggestions
+          });
         }
-        return {
-          Document(node) {
-            const schema2 = docs.requiresSchema ? (0, import_utils.requireGraphQLSchemaFromContext)(ruleId, context) : null;
-            const documentNode = getDocumentNode ? getDocumentNode({ ruleId, context, node: node.rawNode() }) : node.rawNode();
-            validateDocument({
-              context,
-              schema: schema2,
-              documentNode,
-              rule: ruleFn,
-              hasDidYouMeanSuggestions
-            });
-          }
-        };
-      }
+      };
     }
-  };
-};
-const GRAPHQL_JS_VALIDATIONS = Object.assign(
+  }
+}), GRAPHQL_JS_VALIDATIONS = Object.assign(
   {},
   validationToRule(
     {
       ruleId: "executable-definitions",
-      ruleName: "ExecutableDefinitions"
+      rule: import_validation.ExecutableDefinitionsRule
     },
     {
       category: "Operations",
       description: "A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "fields-on-correct-type",
-      ruleName: "FieldsOnCorrectType",
-      hasDidYouMeanSuggestions: true
+      rule: import_validation.FieldsOnCorrectTypeRule,
+      hasDidYouMeanSuggestions: !0
     },
     {
       category: "Operations",
       description: "A GraphQL document is only valid if all fields selected are defined by the parent type, or are an allowed meta field such as `__typename`.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "fragments-on-composite-type",
-      ruleName: "FragmentsOnCompositeTypes"
+      rule: import_validation.FragmentsOnCompositeTypesRule
     },
     {
       category: "Operations",
       description: "Fragments use a type condition to determine if they apply, since fragments can only be spread into a composite type (object, interface, or union), the type condition must also be a composite type.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "known-argument-names",
-      ruleName: "KnownArgumentNames",
-      hasDidYouMeanSuggestions: true
+      rule: import_validation.KnownArgumentNamesRule,
+      hasDidYouMeanSuggestions: !0
     },
     {
       category: ["Schema", "Operations"],
       description: "A GraphQL field is only valid if all supplied arguments are defined by that field.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "known-directives",
-      ruleName: "KnownDirectives",
+      rule: import_validation.KnownDirectivesRule,
       getDocumentNode({ context, node: documentNode }) {
         const { ignoreClientDirectives = [] } = context.options[0] || {};
-        if (ignoreClientDirectives.length === 0) {
+        if (ignoreClientDirectives.length === 0)
           return documentNode;
-        }
-        const filterDirectives = (node) => {
-          var _a;
-          return {
-            ...node,
-            directives: (_a = node.directives) == null ? void 0 : _a.filter(
-              (directive) => !ignoreClientDirectives.includes(directive.name.value)
-            )
-          };
-        };
+        const filterDirectives = (node) => ({
+          ...node,
+          directives: node.directives?.filter(
+            (directive) => !ignoreClientDirectives.includes(directive.name.value)
+          )
+        });
         return (0, import_graphql.visit)(documentNode, {
           Field: filterDirectives,
           OperationDefinition: filterDirectives
@@ -246,7 +198,7 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign(
         maxItems: 1,
         items: {
           type: "object",
-          additionalProperties: false,
+          additionalProperties: !1,
           required: ["ignoreClientDirectives"],
           properties: {
             ignoreClientDirectives: import_utils.ARRAY_DEFAULT_OPTIONS
@@ -257,7 +209,7 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign(
     {
       category: ["Schema", "Operations"],
       description: "A GraphQL document is only valid if all `@directive`s are known by the schema and legally positioned.",
-      requiresSchema: true,
+      requiresSchema: !0,
       examples: [
         {
           title: "Valid",
@@ -279,14 +231,14 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign(
   validationToRule(
     {
       ruleId: "known-fragment-names",
-      ruleName: "KnownFragmentNames",
+      rule: import_validation.KnownFragmentNamesRule,
       getDocumentNode: handleMissingFragments
     },
     {
       category: "Operations",
       description: "A GraphQL document is only valid if all `...Fragment` fragment spreads refer to fragments defined in the same document.",
-      requiresSchema: true,
-      requiresSiblings: true,
+      requiresSchema: !0,
+      requiresSiblings: !0,
       examples: [
         {
           title: "Incorrect",
@@ -347,30 +299,30 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign(
   validationToRule(
     {
       ruleId: "known-type-names",
-      ruleName: "KnownTypeNames",
-      hasDidYouMeanSuggestions: true
+      rule: import_validation.KnownTypeNamesRule,
+      hasDidYouMeanSuggestions: !0
     },
     {
       category: ["Schema", "Operations"],
       description: "A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "lone-anonymous-operation",
-      ruleName: "LoneAnonymousOperation"
+      rule: import_validation.LoneAnonymousOperationRule
     },
     {
       category: "Operations",
       description: "A GraphQL document that contains an anonymous operation (the `query` short-hand) is only valid if it contains only that one operation definition.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "lone-schema-definition",
-      ruleName: "LoneSchemaDefinition"
+      rule: import_validation.LoneSchemaDefinitionRule
     },
     {
       category: "Schema",
@@ -380,174 +332,160 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign(
   validationToRule(
     {
       ruleId: "no-fragment-cycles",
-      ruleName: "NoFragmentCycles"
+      rule: import_validation.NoFragmentCyclesRule
     },
     {
       category: "Operations",
       description: "A GraphQL fragment is only valid when it does not have cycles in fragments usage.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "no-undefined-variables",
-      ruleName: "NoUndefinedVariables",
+      rule: import_validation.NoUndefinedVariablesRule,
       getDocumentNode: handleMissingFragments
     },
     {
       category: "Operations",
       description: "A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.",
-      requiresSchema: true,
-      requiresSiblings: true
+      requiresSchema: !0,
+      requiresSiblings: !0
     }
   ),
   validationToRule(
     {
       ruleId: "no-unused-fragments",
-      ruleName: "NoUnusedFragments",
+      rule: import_validation.NoUnusedFragmentsRule,
       getDocumentNode: ({ ruleId, context, node }) => {
-        const siblings = (0, import_utils.requireSiblingsOperations)(ruleId, context);
-        const FilePathToDocumentsMap = [
+        const siblings = (0, import_utils.requireSiblingsOperations)(ruleId, context), FilePathToDocumentsMap = [
           ...siblings.getOperations(),
           ...siblings.getFragments()
-        ].reduce((map, { filePath, document }) => {
-          var _a;
-          (_a = map[filePath]) != null ? _a : map[filePath] = [];
-          map[filePath].push(document);
-          return map;
-        }, /* @__PURE__ */ Object.create(null));
-        const getParentNode = (currentFilePath, node2) => {
+        ].reduce((map, { filePath, document }) => (map[filePath] ??= [], map[filePath].push(document), map), /* @__PURE__ */ Object.create(null)), getParentNode = (currentFilePath, node2) => {
           const { fragmentDefs } = getFragmentDefsAndFragmentSpreads(node2);
-          if (fragmentDefs.size === 0) {
+          if (fragmentDefs.size === 0)
             return node2;
-          }
           delete FilePathToDocumentsMap[currentFilePath];
-          for (const [filePath, documents] of Object.entries(FilePathToDocumentsMap)) {
-            const missingFragments = getMissingFragments({
+          for (const [filePath, documents] of Object.entries(FilePathToDocumentsMap))
+            if (getMissingFragments({
               kind: import_graphql.Kind.DOCUMENT,
               definitions: documents
-            });
-            const isCurrentFileImportFragment = missingFragments.some(
+            }).some(
               (fragment) => fragmentDefs.has(fragment)
-            );
-            if (isCurrentFileImportFragment) {
+            ))
               return getParentNode(filePath, {
                 kind: import_graphql.Kind.DOCUMENT,
                 definitions: [...node2.definitions, ...documents]
               });
-            }
-          }
           return node2;
         };
-        return getParentNode(context.getFilename(), node);
+        return getParentNode(context.filename, node);
       }
     },
     {
       category: "Operations",
       description: "A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations.",
-      requiresSchema: true,
-      requiresSiblings: true
+      requiresSchema: !0,
+      requiresSiblings: !0
     }
   ),
   validationToRule(
     {
       ruleId: "no-unused-variables",
-      ruleName: "NoUnusedVariables",
+      rule: import_validation.NoUnusedVariablesRule,
       getDocumentNode: handleMissingFragments
     },
     {
       category: "Operations",
       description: "A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.",
-      requiresSchema: true,
-      requiresSiblings: true
+      requiresSchema: !0,
+      requiresSiblings: !0
     }
   ),
   validationToRule(
     {
       ruleId: "overlapping-fields-can-be-merged",
-      ruleName: "OverlappingFieldsCanBeMerged"
+      rule: import_validation.OverlappingFieldsCanBeMergedRule
     },
     {
       category: "Operations",
       description: "A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "possible-fragment-spread",
-      ruleName: "PossibleFragmentSpreads"
+      rule: import_validation.PossibleFragmentSpreadsRule
     },
     {
       category: "Operations",
       description: "A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "possible-type-extension",
-      ruleName: "PossibleTypeExtensions",
-      hasDidYouMeanSuggestions: true
+      rule: import_validation.PossibleTypeExtensionsRule,
+      hasDidYouMeanSuggestions: !0
     },
     {
       category: "Schema",
       description: "A type extension is only valid if the type is defined and has the same kind.",
-      // TODO: add in graphql-eslint v4
-      recommended: false,
-      requiresSchema: true,
-      isDisabledForAllConfig: true
+      recommended: !0,
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "provided-required-arguments",
-      ruleName: "ProvidedRequiredArguments"
+      rule: import_validation.ProvidedRequiredArgumentsRule
     },
     {
       category: ["Schema", "Operations"],
       description: "A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "scalar-leafs",
-      ruleName: "ScalarLeafs",
-      hasDidYouMeanSuggestions: true
+      rule: import_validation.ScalarLeafsRule,
+      hasDidYouMeanSuggestions: !0
     },
     {
       category: "Operations",
       description: "A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "one-field-subscriptions",
-      ruleName: "SingleFieldSubscriptions"
+      rule: import_validation.SingleFieldSubscriptionsRule
     },
     {
       category: "Operations",
       description: "A GraphQL subscription is valid only if it contains a single root field.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "unique-argument-names",
-      ruleName: "UniqueArgumentNames"
+      rule: import_validation.UniqueArgumentNamesRule
     },
     {
       category: "Operations",
       description: "A GraphQL field or directive is only valid if all supplied arguments are uniquely named.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "unique-directive-names",
-      ruleName: "UniqueDirectiveNames"
+      rule: import_validation.UniqueDirectiveNamesRule
     },
     {
       category: "Schema",
@@ -557,30 +495,18 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign(
   validationToRule(
     {
       ruleId: "unique-directive-names-per-location",
-      ruleName: "UniqueDirectivesPerLocation"
+      rule: import_validation.UniqueDirectivesPerLocationRule
     },
     {
       category: ["Schema", "Operations"],
       description: "A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.",
-      requiresSchema: true
-    }
-  ),
-  validationToRule(
-    {
-      ruleId: "unique-enum-value-names",
-      ruleName: "UniqueEnumValueNames"
-    },
-    {
-      category: "Schema",
-      description: "A GraphQL enum type is only valid if all its values are uniquely named.",
-      recommended: false,
-      isDisabledForAllConfig: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "unique-field-definition-names",
-      ruleName: "UniqueFieldDefinitionNames"
+      rule: import_validation.UniqueFieldDefinitionNamesRule
     },
     {
       category: "Schema",
@@ -590,7 +516,7 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign(
   validationToRule(
     {
       ruleId: "unique-input-field-names",
-      ruleName: "UniqueInputFieldNames"
+      rule: import_validation.UniqueInputFieldNamesRule
     },
     {
       category: "Operations",
@@ -600,7 +526,7 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign(
   validationToRule(
     {
       ruleId: "unique-operation-types",
-      ruleName: "UniqueOperationTypes"
+      rule: import_validation.UniqueOperationTypesRule
     },
     {
       category: "Schema",
@@ -610,7 +536,7 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign(
   validationToRule(
     {
       ruleId: "unique-type-names",
-      ruleName: "UniqueTypeNames"
+      rule: import_validation.UniqueTypeNamesRule
     },
     {
       category: "Schema",
@@ -620,46 +546,46 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign(
   validationToRule(
     {
       ruleId: "unique-variable-names",
-      ruleName: "UniqueVariableNames"
+      rule: import_validation.UniqueVariableNamesRule
     },
     {
       category: "Operations",
       description: "A GraphQL operation is only valid if all its variables are uniquely named.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "value-literals-of-correct-type",
-      ruleName: "ValuesOfCorrectType",
-      hasDidYouMeanSuggestions: true
+      rule: import_validation.ValuesOfCorrectTypeRule,
+      hasDidYouMeanSuggestions: !0
     },
     {
       category: "Operations",
       description: "A GraphQL document is only valid if all value literals are of the type expected at their position.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "variables-are-input-types",
-      ruleName: "VariablesAreInputTypes"
+      rule: import_validation.VariablesAreInputTypesRule
     },
     {
       category: "Operations",
       description: "A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).",
-      requiresSchema: true
+      requiresSchema: !0
     }
   ),
   validationToRule(
     {
       ruleId: "variables-in-allowed-position",
-      ruleName: "VariablesInAllowedPosition"
+      rule: import_validation.VariablesInAllowedPositionRule
     },
     {
       category: "Operations",
       description: "Variables passed to field arguments conform to type.",
-      requiresSchema: true
+      requiresSchema: !0
     }
   )
 );