@graphql-eslint/eslint-plugin 4.0.0-alpha-20220821140530-e968cfc → 4.0.0-alpha-20230810155929-e89edf7

package/package.json

@@ -1,47 +1,55 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "4.0.0-alpha-20220821140530-e968cfc",
+  "version": "4.0.0-alpha-20230810155929-e89edf7",
   "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": ">=18"
   },
-  "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",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "browser": "./index.browser.mjs",
+      "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",
   "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": {
+    "eslint": ">=8.44.0",
+    "graphql": "^16"
   },
-  "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",
+    "debug": "^4.3.4",
+    "fast-glob": "^3.2.12",
+    "graphql-config": "^4.5.0",
+    "graphql-depth-limit": "^1.1.0",
+    "lodash.lowercase": "^4.3.0"
+  },
+  "publishConfig": {
+    "directory": "dist",
+    "access": "public"
+  },
+  "sideEffects": false
+}

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/configs/schema-recommended.json

@@ -1,49 +0,0 @@
-{
-  "extends": "./base.json",
-  "rules": {
-    "@graphql-eslint/description-style": "error",
-    "@graphql-eslint/known-argument-names": "error",
-    "@graphql-eslint/known-directives": "error",
-    "@graphql-eslint/known-type-names": "error",
-    "@graphql-eslint/lone-schema-definition": "error",
-    "@graphql-eslint/naming-convention": [
-      "error",
-      {
-        "types": "PascalCase",
-        "FieldDefinition": "camelCase",
-        "InputValueDefinition": "camelCase",
-        "Argument": "camelCase",
-        "DirectiveDefinition": "camelCase",
-        "EnumValueDefinition": "UPPER_CASE",
-        "FieldDefinition[parent.name.value=Query]": {
-          "forbiddenPrefixes": ["query", "get"],
-          "forbiddenSuffixes": ["Query"]
-        },
-        "FieldDefinition[parent.name.value=Mutation]": {
-          "forbiddenPrefixes": ["mutation"],
-          "forbiddenSuffixes": ["Mutation"]
-        },
-        "FieldDefinition[parent.name.value=Subscription]": {
-          "forbiddenPrefixes": ["subscription"],
-          "forbiddenSuffixes": ["Subscription"]
-        }
-      }
-    ],
-    "@graphql-eslint/no-case-insensitive-enum-values-duplicates": "error",
-    "@graphql-eslint/no-hashtag-description": "error",
-    "@graphql-eslint/no-typename-prefix": "error",
-    "@graphql-eslint/no-unreachable-types": "error",
-    "@graphql-eslint/provided-required-arguments": "error",
-    "@graphql-eslint/require-deprecation-reason": "error",
-    "@graphql-eslint/require-description": [
-      "error",
-      { "types": true, "DirectiveDefinition": true }
-    ],
-    "@graphql-eslint/strict-id-in-types": "error",
-    "@graphql-eslint/unique-directive-names": "error",
-    "@graphql-eslint/unique-directive-names-per-location": "error",
-    "@graphql-eslint/unique-field-definition-names": "error",
-    "@graphql-eslint/unique-operation-types": "error",
-    "@graphql-eslint/unique-type-names": "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).

package/docs/parser-options.md

@@ -1,85 +0,0 @@
-## Parser Options
-
-### `graphQLParserOptions`
-
-With this configuration, you can specify custom configurations for GraphQL's `parse` method. By default, `graphql-eslint` parser just adds `noLocation: false` to make sure all parsed AST has `location` set, since we need this for tokenizing and for converting the GraphQL AST into ESTree.
-
-You can find the [complete set of options for this object here](https://github.com/graphql/graphql-js/blob/6e48d16f92b9a6df8638b1486354c6be2537033b/src/language/parser.ts#L73)
-
-### `skipGraphQLConfig`
-
-If you are using [`graphql-config`](https://graphql-config.com) in your project, the parser will automatically use that to load your default GraphQL schema.
-
-You can disable this behaviour using `skipGraphQLConfig: true` in the `parserOptions`:
-
-```json
-  "parserOptions": {
-    "skipGraphQLConfig": true
-  }
-```
-
-### `schema`
-
-You can specify `parserOptions.schema` to load your GraphQL schema. The parser uses `graphql-tools` and it's loaders, that means you can either specify a URL, a path to a local `.json` (introspection) file, or a path to a local `.graphql` file(s). You can also use Glob expressions to load multiple files.
-
-Here are a few examples for a valid setup:
-
-```json
-  "parserOptions": {
-    "schema": "./schema.graphql"
-  }
-```
-
-```json
-  "parserOptions": {
-    "schema": "./schema.json"
-  }
-```
-
-```json
-  "parserOptions": {
-    "schema": "http://my-server/graphql"
-  }
-```
-
-```json
-  "parserOptions": {
-    "schema": "./src/**/*.graphql"
-  }
-```
-
-```json
-  "parserOptions": {
-    "schema": [
-      "src/schema-a.graphql",
-      "src/schema-b.graphql",
-      "src/schema-c.graphql"
-    ]
-  }
-```
-
-### `schemaOptions`
-
-If you wish to send additional configuration for the `graphql-tools` loaders that loads your schema, you can specify `schemaOptions` object:
-
-```json
-  "parserOptions": {
-    "schema": "http://my-server/graphql",
-    "schemaOptions": {
-      "headers": {
-        "Authorization": "Bearer MY_TOKEN"
-      }
-    }
-  }
-```
-
-```json
-  "parserOptions": {
-    "schema": "./src/**/*.graphql",
-    "schemaOptions": {
-      "assumeValid": true
-    }
-  }
-```
-
-> The configuration here is flexible, and will be sent to `graphql-tools` and it's loaders. So depends on the schema source, the options may vary. [You can read more about these loaders and their configuration here](https://graphql-tools.com/docs/api/interfaces/loaders_graphql_file_src.GraphQLFileLoaderOptions#properties).

package/docs/parser.md

@@ -1,49 +0,0 @@
-## GraphQL-ESLint Parser
-
-The `graphql-eslint` parser is works in the following way:
-
-1. Loads all relevant GraphQL code using ESLint core (either from `.graphql` files, or using [ESLint `processor`](https://eslint.org/docs/developer-guide/working-with-plugins#processors-in-plugins) to find in code-files).
-1. Is uses `graphql-js` (and `graphql-tools`) to parse the found string into a `DocumentNode`.
-1. Extracts all comments (marked as `# ...`) from the parsed AST, and provides to ESLint as directives hints.
-1. If `graphql-config` is used, or `schema` field is provided, the schema is being loaded and provided to the rules using `parserServices`.
-1. Converts the `DocumentNode` to ESTree structure (and enrich the nodes with `typeInfo`, if schema is loaded).
-
-### ESTree Conversion
-
-The GraphQL AST structure is very similar to ESTree structure, but there are a few differences that the `parser` does.
-
-Here's a list of changes that the parser performs, in order to make the GraphQL AST compatible with ESTree:
-
----
-
-**Problem**: GraphQL uses `kind` field to define the kind of the AST node, while ESTree uses `type`.
-
-**Solution**: The parser adds `type` field on each node, and just copies the value from `kind` field.
-
----
-
-**Problem**: Some GraphQL AST nodes are using `type` field (which conflicts with the ESTree kind).
-
-**Solution**: AST nodes that has `type` field are being transformed, and the `type` field changes to `gqlType`.
-
----
-
-**Problem**: GraphQL AST structure allows circular JSON links (while ESTree might fail on `Maximum call stack exceeded`).
-
-**Solution**: The parser removes circular JSONs (specifically around GraphQL `Location` and the `Lexer`)
-
----
-
-**Problem**: GraphQL uses `location` field to store the AST locations, while ESTree also uses it in a different structure.
-
-**Solution**: The parser creates a new `location` field that is compatible with ESTree.
-
-### Loading GraphQL Schema
-
-If you are using [`graphql-config`](https://graphql-config.com) in your project, the parser will automatically use that to load your default GraphQL schema (you can disable this behaviour using `skipGraphQLConfig: true` in the `parserOptions`).
-
-If you are not using `graphql-config`, you can specify `parserOptions.schema` to load your GraphQL schema. The parser uses `graphql-tools` and it's loaders, that means you can either specify a URL, a path to a local `.json` (introspection) file, or a path to a local `.graphql` file(s). You can also use Glob expressions to load multiple files.
-
-[You can find more detail on the `parserOptions` config here](parser-options.md)
-
-Providing the schema will make sure that rules that needs it will be able to access it, and it enriches every converted AST node with `typeInfo`.