@graphql-eslint/eslint-plugin 4.0.0-alpha-20220821140530-e968cfc → 4.0.0-alpha-20230801163310-8bc4340

package/esm/utils.d.mts

@@ -0,0 +1,44 @@
+import { AST } from 'eslint';
+import { Position } from 'estree';
+import { GraphQLSchema, ASTNode, Kind } from 'graphql';
+import { c as GraphQLESLintRuleContext, g as SiblingOperations } from './types-ace77d86.js';
+import { GraphQLESTreeNode } from './estree-converter/types.mjs';
+import '@graphql-tools/utils';
+import 'graphql-config';
+import 'json-schema-to-ts';
+
+declare function requireSiblingsOperations(ruleId: string, context: GraphQLESLintRuleContext): SiblingOperations | never;
+declare function requireGraphQLSchemaFromContext(ruleId: string, context: GraphQLESLintRuleContext): GraphQLSchema | never;
+declare const logger: {
+    error: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+};
+declare const normalizePath: (path: string) => string;
+declare const VIRTUAL_DOCUMENT_REGEX: RegExp;
+declare const CWD: string;
+declare const getTypeName: (node: ASTNode) => string;
+declare const TYPES_KINDS: readonly [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.ENUM_TYPE_DEFINITION, Kind.SCALAR_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.UNION_TYPE_DEFINITION];
+type CaseStyle = 'camelCase' | 'kebab-case' | 'PascalCase' | 'snake_case' | 'UPPER_CASE';
+declare const pascalCase: (str: string) => string;
+declare const camelCase: (str: string) => string;
+declare const convertCase: (style: CaseStyle, str: string) => string;
+declare function getLocation(start: Position, fieldName?: string): AST.SourceLocation;
+declare const REPORT_ON_FIRST_CHARACTER: {
+    column: number;
+    line: number;
+};
+declare const ARRAY_DEFAULT_OPTIONS: {
+    readonly type: "array";
+    readonly uniqueItems: true;
+    readonly minItems: 1;
+    readonly items: {
+        readonly type: "string";
+    };
+};
+declare const englishJoinWords: (words: string[]) => string;
+type Truthy<T> = T extends '' | 0 | false | null | undefined ? never : T;
+declare function truthy<T>(value: T): value is Truthy<T>;
+declare function displayNodeName(node: GraphQLESTreeNode<ASTNode>): string;
+declare function getNodeName(node: GraphQLESTreeNode<ASTNode>): string;
+
+export { ARRAY_DEFAULT_OPTIONS, CWD, CaseStyle, REPORT_ON_FIRST_CHARACTER, TYPES_KINDS, VIRTUAL_DOCUMENT_REGEX, camelCase, convertCase, displayNodeName, englishJoinWords, getLocation, getNodeName, getTypeName, logger, normalizePath, pascalCase, requireGraphQLSchemaFromContext, requireSiblingsOperations, truthy };

package/esm/utils.js

@@ -0,0 +1,155 @@
+import "./chunk-BMTV3EA2.js";
+import chalk from "chalk";
+import { Kind } from "graphql";
+import lowerCase from "lodash.lowercase";
+function requireSiblingsOperations(ruleId, context) {
+  const { siblingOperations } = context.parserServices;
+  if (!siblingOperations.available) {
+    throw new Error(
+      `Rule \`${ruleId}\` requires \`parserOptions.operations\` to be set and loaded. See https://bit.ly/graphql-eslint-operations for more info`
+    );
+  }
+  return siblingOperations;
+}
+function requireGraphQLSchemaFromContext(ruleId, context) {
+  const { schema } = context.parserServices;
+  if (!schema) {
+    throw new Error(
+      `Rule \`${ruleId}\` requires \`parserOptions.schema\` to be set and loaded. See https://bit.ly/graphql-eslint-schema for more info`
+    );
+  }
+  return schema;
+}
+const logger = {
+  error: (...args) => (
+    // eslint-disable-next-line no-console
+    console.error(chalk.red("error"), "[graphql-eslint]", chalk(...args))
+  ),
+  warn: (...args) => (
+    // eslint-disable-next-line no-console
+    console.warn(chalk.yellow("warning"), "[graphql-eslint]", chalk(...args))
+  )
+};
+const normalizePath = (path) => (path || "").replace(/\\/g, "/");
+const VIRTUAL_DOCUMENT_REGEX = /\/\d+_document.graphql$/;
+const CWD = process.cwd();
+const getTypeName = (node) => "type" in node ? getTypeName(node.type) : "name" in node && node.name ? node.name.value : "";
+const TYPES_KINDS = [
+  Kind.OBJECT_TYPE_DEFINITION,
+  Kind.INTERFACE_TYPE_DEFINITION,
+  Kind.ENUM_TYPE_DEFINITION,
+  Kind.SCALAR_TYPE_DEFINITION,
+  Kind.INPUT_OBJECT_TYPE_DEFINITION,
+  Kind.UNION_TYPE_DEFINITION
+];
+const pascalCase = (str) => lowerCase(str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+const camelCase = (str) => {
+  const result = pascalCase(str);
+  return result.charAt(0).toLowerCase() + result.slice(1);
+};
+const convertCase = (style, str) => {
+  switch (style) {
+    case "camelCase":
+      return camelCase(str);
+    case "PascalCase":
+      return pascalCase(str);
+    case "snake_case":
+      return lowerCase(str).replace(/ /g, "_");
+    case "UPPER_CASE":
+      return lowerCase(str).replace(/ /g, "_").toUpperCase();
+    case "kebab-case":
+      return lowerCase(str).replace(/ /g, "-");
+  }
+};
+function getLocation(start, fieldName = "") {
+  const { line, column } = start;
+  return {
+    start: {
+      line,
+      column
+    },
+    end: {
+      line,
+      column: column + fieldName.length
+    }
+  };
+}
+const REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 };
+const ARRAY_DEFAULT_OPTIONS = {
+  type: "array",
+  uniqueItems: true,
+  minItems: 1,
+  items: {
+    type: "string"
+  }
+};
+const englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words);
+function truthy(value) {
+  return !!value;
+}
+const DisplayNodeNameMap = {
+  [Kind.OBJECT_TYPE_DEFINITION]: "type",
+  [Kind.OBJECT_TYPE_EXTENSION]: "type",
+  [Kind.INTERFACE_TYPE_DEFINITION]: "interface",
+  [Kind.INTERFACE_TYPE_EXTENSION]: "interface",
+  [Kind.ENUM_TYPE_DEFINITION]: "enum",
+  [Kind.ENUM_TYPE_EXTENSION]: "enum",
+  [Kind.SCALAR_TYPE_DEFINITION]: "scalar",
+  [Kind.INPUT_OBJECT_TYPE_DEFINITION]: "input",
+  [Kind.INPUT_OBJECT_TYPE_EXTENSION]: "input",
+  [Kind.UNION_TYPE_DEFINITION]: "union",
+  [Kind.UNION_TYPE_EXTENSION]: "union",
+  [Kind.DIRECTIVE_DEFINITION]: "directive",
+  [Kind.FIELD_DEFINITION]: "field",
+  [Kind.ENUM_VALUE_DEFINITION]: "enum value",
+  [Kind.INPUT_VALUE_DEFINITION]: "input value",
+  [Kind.ARGUMENT]: "argument",
+  [Kind.VARIABLE]: "variable",
+  [Kind.FRAGMENT_DEFINITION]: "fragment",
+  [Kind.OPERATION_DEFINITION]: "operation",
+  [Kind.FIELD]: "field"
+};
+function displayNodeName(node) {
+  var _a, _b;
+  return `${node.kind === Kind.OPERATION_DEFINITION ? node.operation : DisplayNodeNameMap[node.kind]} "${"alias" in node && ((_a = node.alias) == null ? void 0 : _a.value) || "name" in node && ((_b = node.name) == null ? void 0 : _b.value)}"`;
+}
+function getNodeName(node) {
+  switch (node.kind) {
+    case Kind.OBJECT_TYPE_DEFINITION:
+    case Kind.OBJECT_TYPE_EXTENSION:
+    case Kind.INTERFACE_TYPE_DEFINITION:
+    case Kind.ENUM_TYPE_DEFINITION:
+    case Kind.SCALAR_TYPE_DEFINITION:
+    case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+    case Kind.UNION_TYPE_DEFINITION:
+    case Kind.DIRECTIVE_DEFINITION:
+      return displayNodeName(node);
+    case Kind.FIELD_DEFINITION:
+    case Kind.INPUT_VALUE_DEFINITION:
+    case Kind.ENUM_VALUE_DEFINITION:
+      return `${displayNodeName(node)} in ${displayNodeName(node.parent)}`;
+    case Kind.OPERATION_DEFINITION:
+      return node.name ? displayNodeName(node) : node.operation;
+  }
+  return "";
+}
+export {
+  ARRAY_DEFAULT_OPTIONS,
+  CWD,
+  REPORT_ON_FIRST_CHARACTER,
+  TYPES_KINDS,
+  VIRTUAL_DOCUMENT_REGEX,
+  camelCase,
+  convertCase,
+  displayNodeName,
+  englishJoinWords,
+  getLocation,
+  getNodeName,
+  getTypeName,
+  logger,
+  normalizePath,
+  pascalCase,
+  requireGraphQLSchemaFromContext,
+  requireSiblingsOperations,
+  truthy
+};

package/package.json

@@ -1,47 +1,60 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "4.0.0-alpha-20220821140530-e968cfc",
+  "version": "4.0.0-alpha-20230801163310-8bc4340",
   "description": "GraphQL plugin for ESLint",
-  "sideEffects": false,
-  "peerDependencies": {
-    "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
+  "repository": "https://github.com/B2o5T/graphql-eslint",
+  "author": "Dotan Simha <dotansimha@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=12"
   },
-  "dependencies": {
-    "@babel/code-frame": "^7.16.7",
-    "@graphql-tools/code-file-loader": "^7.2.14",
-    "@graphql-tools/graphql-tag-pluck": "^7.2.6",
-    "@graphql-tools/utils": "^8.6.9",
-    "chalk": "^4.1.2",
-    "debug": "^4.3.4",
-    "fast-glob": "^3.2.11",
-    "graphql-config": "^4.3.0",
-    "graphql-depth-limit": "^1.1.0",
-    "lodash.lowercase": "^4.3.0"
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "require": {
+        "types": "./cjs/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./esm/index.d.mts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./esm/index.d.mts",
+        "default": "./esm/index.js"
+      }
+    }
   },
-  "repository": "https://github.com/B2o5T/graphql-eslint",
+  "typings": "esm/index.d.mts",
   "keywords": [
     "eslint",
     "eslintplugin",
     "eslint-plugin",
     "graphql"
   ],
-  "author": "Dotan Simha <dotansimha@gmail.com>",
-  "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
-  "typescript": {
-    "definition": "index.d.ts"
+  "peerDependencies": {
+    "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
   },
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
-    }
+  "dependencies": {
+    "@graphql-tools/code-file-loader": "^7.3.6",
+    "@graphql-tools/graphql-tag-pluck": "^7.3.6",
+    "@graphql-tools/utils": "^9.0.0",
+    "chalk": "^4.1.2",
+    "debug": "^4.3.4",
+    "fast-glob": "^3.2.12",
+    "graphql-config": "^4.4.0",
+    "graphql-depth-limit": "^1.1.0",
+    "lodash.lowercase": "^4.3.0",
+    "tslib": "^2.4.1"
+  },
+  "publishConfig": {
+    "directory": "dist",
+    "access": "public"
+  },
+  "sideEffects": false,
+  "typescript": {
+    "definition": "cjs/index.d.ts"
   }
-}
+}

package/configs/base.json

@@ -1,4 +0,0 @@
-{
-  "parser": "@graphql-eslint/eslint-plugin",
-  "plugins": ["@graphql-eslint"]
-}

package/configs/operations-all.json

@@ -1,24 +0,0 @@
-{
-  "extends": ["./base.json", "./operations-recommended.json"],
-  "rules": {
-    "@graphql-eslint/alphabetize": [
-      "error",
-      {
-        "selections": ["OperationDefinition", "FragmentDefinition"],
-        "variables": ["OperationDefinition"],
-        "arguments": ["Field", "Directive"]
-      }
-    ],
-    "@graphql-eslint/match-document-filename": [
-      "error",
-      {
-        "query": "kebab-case",
-        "mutation": "kebab-case",
-        "subscription": "kebab-case",
-        "fragment": "kebab-case"
-      }
-    ],
-    "@graphql-eslint/unique-fragment-name": "error",
-    "@graphql-eslint/unique-operation-name": "error"
-  }
-}

package/configs/schema-all.json

@@ -1,26 +0,0 @@
-{
-  "extends": ["./base.json", "./schema-recommended.json"],
-  "rules": {
-    "@graphql-eslint/alphabetize": [
-      "error",
-      {
-        "fields": [
-          "ObjectTypeDefinition",
-          "InterfaceTypeDefinition",
-          "InputObjectTypeDefinition"
-        ],
-        "values": ["EnumTypeDefinition"],
-        "arguments": [
-          "FieldDefinition",
-          "Field",
-          "DirectiveDefinition",
-          "Directive"
-        ]
-      }
-    ],
-    "@graphql-eslint/input-name": "error",
-    "@graphql-eslint/no-scalar-result-type-on-mutation": "error",
-    "@graphql-eslint/require-deprecation-date": "error",
-    "@graphql-eslint/require-field-of-type-query-in-mutation-result": "error"
-  }
-}

package/docs/README.md

@@ -1,75 +0,0 @@
-## Available Rules
-
-Each rule has emojis denoting:
-
-- 🚀 `graphql-eslint` rule
-- 🔮 `graphql-js` rule
-- 🔧 if some problems reported by the rule are automatically fixable by the `--fix` [command line](https://eslint.org/docs/user-guide/command-line-interface#fixing-problems) option
-- 💡 if some problems reported by the rule are manually fixable by editor [suggestions](https://eslint.org/docs/developer-guide/working-with-rules#providing-suggestions)
-
-<!-- 🚨 IMPORTANT! Do not manually modify this table. Run: `yarn generate:docs` -->
-<!-- prettier-ignore-start -->
-Name&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|Description|&nbsp;&nbsp;&nbsp;&nbsp;Config&nbsp;&nbsp;&nbsp;&nbsp;|🚀&nbsp;/&nbsp;🔮|🔧&nbsp;/&nbsp;💡
--|-|:-:|:-:|:-:
-[alphabetize](rules/alphabetize.md)|Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.|![all][]|🚀|🔧
-[description-style](rules/description-style.md)|Require all comments to follow the same style (either block or inline).|![recommended][]|🚀|💡
-[executable-definitions](rules/executable-definitions.md)|A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.|![recommended][]|🔮|
-[fields-on-correct-type](rules/fields-on-correct-type.md)|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`.|![recommended][]|🔮|
-[fragments-on-composite-type](rules/fragments-on-composite-type.md)|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.|![recommended][]|🔮|
-[input-name](rules/input-name.md)|Require mutation argument to be always called "input" and input type to be called Mutation name + "Input".|![all][]|🚀|💡
-[known-argument-names](rules/known-argument-names.md)|A GraphQL field is only valid if all supplied arguments are defined by that field.|![recommended][]|🔮|
-[known-directives](rules/known-directives.md)|A GraphQL document is only valid if all `@directive`s are known by the schema and legally positioned.|![recommended][]|🔮|
-[known-fragment-names](rules/known-fragment-names.md)|A GraphQL document is only valid if all `...Fragment` fragment spreads refer to fragments defined in the same document.|![recommended][]|🔮|
-[known-type-names](rules/known-type-names.md)|A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema.|![recommended][]|🔮|
-[lone-anonymous-operation](rules/lone-anonymous-operation.md)|A GraphQL document is only valid if when it contains an anonymous operation (the query short-hand) that it contains only that one operation definition.|![recommended][]|🔮|
-[lone-schema-definition](rules/lone-schema-definition.md)|A GraphQL document is only valid if it contains only one schema definition.|![recommended][]|🔮|
-[match-document-filename](rules/match-document-filename.md)|This rule allows you to enforce that the file name should match the operation name.|![all][]|🚀|
-[naming-convention](rules/naming-convention.md)|Require names to follow specified conventions.|![recommended][]|🚀|💡
-[no-anonymous-operations](rules/no-anonymous-operations.md)|Require name for your GraphQL operations. This is useful since most GraphQL client libraries are using the operation name for caching purposes.|![recommended][]|🚀|💡
-[no-case-insensitive-enum-values-duplicates](rules/no-case-insensitive-enum-values-duplicates.md)|Disallow case-insensitive enum values duplicates.|![recommended][]|🚀|💡
-[no-deprecated](rules/no-deprecated.md)|Enforce that deprecated fields or enum values are not in use by operations.|![recommended][]|🚀|💡
-[no-duplicate-fields](rules/no-duplicate-fields.md)|Checks for duplicate fields in selection set, variables in operation definition, or in arguments set of a field.|![recommended][]|🚀|💡
-[no-fragment-cycles](rules/no-fragment-cycles.md)|A GraphQL fragment is only valid when it does not have cycles in fragments usage.|![recommended][]|🔮|
-[no-hashtag-description](rules/no-hashtag-description.md)|Requires to use `"""` or `"` for adding a GraphQL description instead of `#`.|![recommended][]|🚀|💡
-[no-root-type](rules/no-root-type.md)|Disallow using root types `mutation` and/or `subscription`.||🚀|💡
-[no-scalar-result-type-on-mutation](rules/no-scalar-result-type-on-mutation.md)|Avoid scalar result type on mutation type to make sure to return a valid state.|![all][]|🚀|💡
-[no-typename-prefix](rules/no-typename-prefix.md)|Enforces users to avoid using the type name in a field name while defining your schema.|![recommended][]|🚀|💡
-[no-undefined-variables](rules/no-undefined-variables.md)|A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.|![recommended][]|🔮|
-[no-unreachable-types](rules/no-unreachable-types.md)|Requires all types to be reachable at some level by root level fields.|![recommended][]|🚀|💡
-[no-unused-fields](rules/no-unused-fields.md)|Requires all fields to be used at some level by siblings operations.||🚀|💡
-[no-unused-fragments](rules/no-unused-fragments.md)|A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations.|![recommended][]|🔮|
-[no-unused-variables](rules/no-unused-variables.md)|A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.|![recommended][]|🔮|
-[one-field-subscriptions](rules/one-field-subscriptions.md)|A GraphQL subscription is valid only if it contains a single root field.|![recommended][]|🔮|
-[overlapping-fields-can-be-merged](rules/overlapping-fields-can-be-merged.md)|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.|![recommended][]|🔮|
-[possible-fragment-spread](rules/possible-fragment-spread.md)|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.|![recommended][]|🔮|
-[possible-type-extension](rules/possible-type-extension.md)|A type extension is only valid if the type is defined and has the same kind.||🔮|
-[provided-required-arguments](rules/provided-required-arguments.md)|A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.|![recommended][]|🔮|
-[relay-arguments](rules/relay-arguments.md)|Set of rules to follow Relay specification for Arguments.||🚀|
-[relay-connection-types](rules/relay-connection-types.md)|Set of rules to follow Relay specification for Connection types.||🚀|
-[relay-edge-types](rules/relay-edge-types.md)|Set of rules to follow Relay specification for Edge types.||🚀|
-[relay-page-info](rules/relay-page-info.md)|Set of rules to follow Relay specification for `PageInfo` object.||🚀|
-[require-deprecation-date](rules/require-deprecation-date.md)|Require deletion date on `@deprecated` directive. Suggest removing deprecated things after deprecated date.|![all][]|🚀|💡
-[require-deprecation-reason](rules/require-deprecation-reason.md)|Require all deprecation directives to specify a reason.|![recommended][]|🚀|
-[require-description](rules/require-description.md)|Enforce descriptions in type definitions and operations.|![recommended][]|🚀|
-[require-field-of-type-query-in-mutation-result](rules/require-field-of-type-query-in-mutation-result.md)|Allow the client in one round-trip not only to call mutation but also to get a wagon of data to update their application.|![all][]|🚀|
-[require-id-when-available](rules/require-id-when-available.md)|Enforce selecting specific fields when they are available on the GraphQL type.|![recommended][]|🚀|💡
-[scalar-leafs](rules/scalar-leafs.md)|A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.|![recommended][]|🔮|
-[selection-set-depth](rules/selection-set-depth.md)|Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://npmjs.com/package/graphql-depth-limit).|![recommended][]|🚀|💡
-[strict-id-in-types](rules/strict-id-in-types.md)|Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.|![recommended][]|🚀|
-[unique-argument-names](rules/unique-argument-names.md)|A GraphQL field or directive is only valid if all supplied arguments are uniquely named.|![recommended][]|🔮|
-[unique-directive-names](rules/unique-directive-names.md)|A GraphQL document is only valid if all defined directives have unique names.|![recommended][]|🔮|
-[unique-directive-names-per-location](rules/unique-directive-names-per-location.md)|A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.|![recommended][]|🔮|
-[unique-enum-value-names](rules/unique-enum-value-names.md)|A GraphQL enum type is only valid if all its values are uniquely named.||🔮|
-[unique-field-definition-names](rules/unique-field-definition-names.md)|A GraphQL complex type is only valid if all its fields are uniquely named.|![recommended][]|🔮|
-[unique-fragment-name](rules/unique-fragment-name.md)|Enforce unique fragment names across your project.|![all][]|🚀|
-[unique-input-field-names](rules/unique-input-field-names.md)|A GraphQL input object value is only valid if all supplied fields are uniquely named.|![recommended][]|🔮|
-[unique-operation-name](rules/unique-operation-name.md)|Enforce unique operation names across your project.|![all][]|🚀|
-[unique-operation-types](rules/unique-operation-types.md)|A GraphQL document is only valid if it has only one type per operation.|![recommended][]|🔮|
-[unique-type-names](rules/unique-type-names.md)|A GraphQL document is only valid if all defined types have unique names.|![recommended][]|🔮|
-[unique-variable-names](rules/unique-variable-names.md)|A GraphQL operation is only valid if all its variables are uniquely named.|![recommended][]|🔮|
-[value-literals-of-correct-type](rules/value-literals-of-correct-type.md)|A GraphQL document is only valid if all value literals are of the type expected at their position.|![recommended][]|🔮|
-[variables-are-input-types](rules/variables-are-input-types.md)|A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).|![recommended][]|🔮|
-[variables-in-allowed-position](rules/variables-in-allowed-position.md)|Variables passed to field arguments conform to type.|![recommended][]|🔮|
-<!-- prettier-ignore-end -->
-[recommended]: https://img.shields.io/badge/-recommended-green.svg
-[all]: https://img.shields.io/badge/-all-blue.svg

package/docs/custom-rules.md

@@ -1,148 +0,0 @@
-# Writing Custom Rules
-
-To get started with your own rules, start by understanding how [ESLint custom rules works](https://eslint.org/docs/developer-guide/working-with-rules).
-
-`graphql-eslint` converts the [GraphQL AST](https://graphql.org/graphql-js/language) into [ESTree structure](https://github.com/estree/estree), so it allows you to easily travel the GraphQL AST tree easily.
-
-You can visit any GraphQL AST node in your custom rules, and report this as error. You don't need to have special handlers for code-files, since `graphql-eslint` extracts usages of `gql` and magic `/* GraphQL */` comments automatically, and runs it through the parser, and eventually it knows to adjust errors location to fit in your code files original location.
-
-## Getting Started
-
-Start by creating a [simple ESLint rule file](https://eslint.org/docs/developer-guide/working-with-rules), and choose the AST nodes you wish to visit. It can either be a [simple AST node `Kind`](https://github.com/graphql/graphql-js/blob/master/src/language/kinds.d.ts) or a complex [ESLint selector](https://eslint.org/docs/developer-guide/selectors) that allows you to travel and filter AST nodes.
-
-We recommend you to read the [graphql-eslint parser documentation](parser.md) before getting started, to understand the differences between the AST structures.
-
-The `graphql-eslint` comes with a TypeScript wrapper for ESLint rules, and provides a testkit to simplify testing process with GraphQL schemas, so you can use that by importing `GraphQLESLintRule` type. But if you wish to use JavaScript - that's fine :)
-
-Here's an example for a simple rule that reports on anonymous GraphQL operations:
-
-```ts
-import { GraphQLESLintRule } from '@graphql-eslint/eslint-plugin'
-
-const rule: GraphQLESLintRule = {
-  create(context) {
-    return {
-      OperationDefinition(node) {
-        if (!node.name || !node.name.value) {
-          context.report({
-            node,
-            message: 'Oops, name is required!'
-          })
-        }
-      }
-    }
-  }
-}
-```
-
-So what happens here?
-
-1. `@graphql-eslint/eslint-plugin` handles the parsing process for your GraphQL content. It will load the GraphQL files (either from code files or from `.graphql` files with SDL), parse it using GraphQL parser, converts it to ESTree structure and let ESLint do the rest.
-1. Your rule is being loaded by ESLint, and executes just like any other ESLint rule.
-1. Our custom rule asks ESLint to run our function for every `OperationDefinition` found.
-1. If the `OperationDefinition` node doesn't have a valid `name` - we report an error to ESLint.
-
-#### More Examples
-
-You can scan the `packages/plugin/src/rules` directory in this repo for references for implementing rules. It coverts most of the use-cases and concepts of rules.
-
-## Accessing original GraphQL AST nodes
-
-Since our parser converts GraphQL AST to ESTree structure, there are some minor differences in the structure of the objects.
-If you are using TypeScript, and you typed your rule with `GraphQLESLintRule` - you'll see that each `node` is a bit different from the AST nodes of GraphQL (you can read more about that in [graphql-eslint parser documentation](parser.md)).
-
-If you need access to the original GraphQL AST `node`, you can use `.rawNode()` method on each node you get from the AST structure of ESLint.
-
-This is useful if you wish to use other GraphQL tools that works with the original GraphQL AST objects.
-
-Here's an example for using original `graphql-js` validate method to validate `OperationDefinition`:
-
-```ts
-import { validate } from 'graphql'
-import { requireGraphQLSchemaFromContext } from '@graphql-eslint/eslint-plugin'
-
-export const rule = {
-  create(context) {
-    return {
-      OperationDefinition(node) {
-        const schema = requireGraphQLSchemaFromContext(context)
-
-        validate(context, schema, {
-          kind: Kind.DOCUMENT,
-          definitions: [node.rawNode()]
-        })
-      }
-    }
-  }
-}
-```
-
-## `TypeInfo` / `GraphQLSchema`
-
-If you provide GraphQL schema in your ESLint configuration, it will get loaded automatically, and become available in your rules in two ways:
-
-1. You'll be able to access the loaded `GraphQLSchema` object.
-2. In every visited node, you'll be able to use `.typeInfo()` method to get an object with complete type information on your visited node (see [TypeInfo documentation](https://graphql.org/graphql-js/utilities/#typeinfo)).
-
-#### Getting `GraphQLSchema`
-
-To mark your ESLint rules as a rule that needs access to GraphQL schema, start by running `requireGraphQLSchemaFromContext` from the plugin package, it will make sure to return a schema, or throw an error for the user about the missing schema.
-
-```ts
-const schema = requireGraphQLSchemaFromContext(context)
-```
-
-#### Accessing TypeInfo
-
-If schema is provided and loaded successfully, the `typeInfo` will be available to use. Otherwise - it will be `undefined`.
-If your plugin requires `typeInfo` in order to operate and run, make sure to call `requireGraphQLSchemaFromContext` - it will validate that the schema is loaded.
-
-`typeInfo` is provided on every node, based on the type of that node, for example, to access the `GraphQLOutputType` while you are visiting a `SelectionSet` node, you can do:
-
-```ts
-import { requireGraphQLSchemaFromContext } from '@graphql-eslint/eslint-plugin'
-
-export const rule = {
-  create(context) {
-    requireGraphQLSchemaFromContext('your-rule-name', context)
-
-    return {
-      SelectionSet(node) {
-        const typeInfo = node.typeInfo()
-        if (typeInfo.gqlType) {
-          console.log(`The GraphQLOutputType is: ${typeInfo.gqlType}`)
-        }
-      }
-    }
-  }
-}
-```
-
-The structure of the return value of `.typeInfo()` is [defined here](https://github.com/B2o5T/graphql-eslint/blob/master/packages/plugin/src/estree-converter/converter.ts#L32-L40). So based on the `node` you are using, you'll get a different values on `.typeInfo()` result.
-
-## Testing your rules
-
-To test your rules, you can either use the wrapped `GraphQLRuleTester` from this library, or use the built-it [`RuleTester`](https://eslint.org/docs/developer-guide/working-with-rules#rule-unit-tests) of ESLint.
-
-The wrapped `GraphQLRuleTester` provides built-in configured parser, and a schema loader, if you need to test your rule with a loaded schema.
-
-```ts
-import { GraphQLRuleTester } from '@graphql-eslint/eslint-plugin'
-import { rule } from './my-rule'
-
-const ruleTester = new GraphQLRuleTester()
-
-ruleTester.runGraphQLTests('my-rule', rule, {
-  valid: [
-    {
-      code: 'query something { foo }'
-    }
-  ],
-  invalid: [
-    {
-      code: 'query invalid { foo }',
-      errors: [{ message: 'Your error message.' }],
-    }
-  ]
-})
-```

package/docs/deprecated-rules.md

@@ -1,21 +0,0 @@
-# Deprecated Rules
-
-## avoid-duplicate-fields
-
-This rule was renamed to [`no-duplicate-fields`](rules/no-duplicate-fields.md).
-
-## avoid-scalar-result-type-on-mutation
-
-This rule was renamed to [`no-scalar-result-type-on-mutation`](rules/no-scalar-result-type-on-mutation.md).
-
-## avoid-typename-prefix
-
-This rule was renamed to [`no-typename-prefix`](rules/no-typename-prefix.md).
-
-## avoid-operation-name-prefix
-
-This rule was removed because the same things can be validated using [`naming-convention`](rules/naming-convention.md).
-
-## no-operation-name-suffix
-
-This rule was removed because the same things can be validated using [`naming-convention`](rules/naming-convention.md).