@graphql-eslint/eslint-plugin 3.14.4-alpha-20230111221804-f30b422 → 3.14.4-alpha-20230111225020-02d9c28

package/docs/custom-rules.md

@@ -1,184 +1 @@
-# 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.
-
-You can explore the GraphQL AST for a given input on
-[astexplorer.net](https://astexplorer.net/#/gist/e72aaccc1e57cbba41659d73cabbf75c/f10ee29317a31ff8012a21762a382c4a03c34d40).
-
-## 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?.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 { requireGraphQLSchemaFromContext } from '@graphql-eslint/eslint-plugin'
-import { validate } from 'graphql'
-
-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.' }]
-    }
-  ]
-})
-```
+website/src/pages/docs/custom-rules.mdx

package/docs/deprecated-rules.md

@@ -1,24 +1 @@
-# 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).
+website/src/pages/rules/deprecated-rules.mdx

package/docs/parser-options.md

@@ -1,107 +1 @@
-# 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).
+website/src/pages/docs/getting-started/parser-options.mdx

package/docs/parser.md

@@ -1,67 +1 @@
-# 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`.
+website/src/pages/docs/getting-started/parser.mdx

package/esm/documents.js

@@ -1,10 +1,9 @@
 import { resolve } from 'path';
 import debugFactory from 'debug';
 import fg from 'fast-glob';
-import { Kind, visit, } from 'graphql';
 import { ModuleCache } from './cache.js';
-import { logger } from './utils.js';
 const debug = debugFactory('graphql-eslint:operations');
+const operationsCache = new ModuleCache();
 const handleVirtualPath = (documents) => {
     const filepathMap = Object.create(null);
     return documents.map(source => {
@@ -21,9 +20,7 @@ const handleVirtualPath = (documents) => {
         };
     });
 };
-const operationsCache = new ModuleCache();
-const siblingOperationsCache = new Map();
-const getSiblings = (project) => {
+export const getDocuments = (project) => {
     const documentsKey = project.documents;
     if (!documentsKey) {
         return [];
@@ -45,103 +42,3 @@ const getSiblings = (project) => {
     }
     return siblings;
 };
-export function getDocuments(project) {
-    const siblings = getSiblings(project);
-    if (siblings.length === 0) {
-        let printed = false;
-        const noopWarn = () => {
-            if (!printed) {
-                logger.warn('getSiblingOperations was called without any operations. Make sure to set "parserOptions.operations" to make this feature available!');
-                printed = true;
-            }
-            return [];
-        };
-        return {
-            available: false,
-            getFragment: noopWarn,
-            getFragments: noopWarn,
-            getFragmentByType: noopWarn,
-            getFragmentsInUse: noopWarn,
-            getOperation: noopWarn,
-            getOperations: noopWarn,
-            getOperationByType: noopWarn,
-        };
-    }
-    // Since the siblings array is cached, we can use it as cache key.
-    // We should get the same array reference each time we get
-    // to this point for the same graphql project
-    const value = siblingOperationsCache.get(siblings);
-    if (value) {
-        return value;
-    }
-    let fragmentsCache = null;
-    const getFragments = () => {
-        var _a;
-        if (fragmentsCache === null) {
-            const result = [];
-            for (const source of siblings) {
-                for (const definition of ((_a = source.document) === null || _a === void 0 ? void 0 : _a.definitions) || []) {
-                    if (definition.kind === Kind.FRAGMENT_DEFINITION) {
-                        result.push({
-                            filePath: source.location,
-                            document: definition,
-                        });
-                    }
-                }
-            }
-            fragmentsCache = result;
-        }
-        return fragmentsCache;
-    };
-    let cachedOperations = null;
-    const getOperations = () => {
-        var _a;
-        if (cachedOperations === null) {
-            const result = [];
-            for (const source of siblings) {
-                for (const definition of ((_a = source.document) === null || _a === void 0 ? void 0 : _a.definitions) || []) {
-                    if (definition.kind === Kind.OPERATION_DEFINITION) {
-                        result.push({
-                            filePath: source.location,
-                            document: definition,
-                        });
-                    }
-                }
-            }
-            cachedOperations = result;
-        }
-        return cachedOperations;
-    };
-    const getFragment = (name) => getFragments().filter(f => { var _a; return ((_a = f.document.name) === null || _a === void 0 ? void 0 : _a.value) === name; });
-    const collectFragments = (selectable, recursive, collected = new Map()) => {
-        visit(selectable, {
-            FragmentSpread(spread) {
-                const fragmentName = spread.name.value;
-                const [fragment] = getFragment(fragmentName);
-                if (!fragment) {
-                    logger.warn(`Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`);
-                    return;
-                }
-                if (!collected.has(fragmentName)) {
-                    collected.set(fragmentName, fragment.document);
-                    if (recursive) {
-                        collectFragments(fragment.document, recursive, collected);
-                    }
-                }
-            },
-        });
-        return collected;
-    };
-    const siblingOperations = {
-        available: true,
-        getFragment,
-        getFragments,
-        getFragmentByType: typeName => getFragments().filter(f => { var _a, _b; return ((_b = (_a = f.document.typeCondition) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.value) === typeName; }),
-        getFragmentsInUse: (selectable, recursive = true) => Array.from(collectFragments(selectable, recursive).values()),
-        getOperation: name => getOperations().filter(o => { var _a; return ((_a = o.document.name) === null || _a === void 0 ? void 0 : _a.value) === name; }),
-        getOperations,
-        getOperationByType: type => getOperations().filter(o => o.document.operation === type),
-    };
-    siblingOperationsCache.set(siblings, siblingOperations);
-    return siblingOperations;
-}

package/esm/graphql-config.js

@@ -28,7 +28,7 @@ export function loadGraphQLConfig(options) {
         ? { projects: options.projects }
         : {
             schema: (options.schema || ''),
-            documents: options.documents || options.operations,
+            documents: options.documents,
             extensions: options.extensions,
             include: options.include,
             exclude: options.exclude,

package/esm/parser.js

@@ -1,16 +1,18 @@
 import { parseGraphQLSDL } from '@graphql-tools/utils';
 import debugFactory from 'debug';
-import { GraphQLError, GraphQLSchema } from 'graphql';
-import { getDocuments } from './documents.js';
+import { buildSchema, GraphQLError, GraphQLSchema } from 'graphql';
 import { convertToESTree, extractComments, extractTokens } from './estree-converter/index.js';
 import { loadGraphQLConfig } from './graphql-config.js';
 import { getSchema } from './schema.js';
+import { getSiblings } from './siblings.js';
 import { CWD, VIRTUAL_DOCUMENT_REGEX } from './utils.js';
 const debug = debugFactory('graphql-eslint:parser');
 debug('cwd %o', CWD);
 export function parseForESLint(code, options) {
     try {
         const { filePath } = options;
+        // TODO: remove in graphql-eslint v4
+        options.documents || (options.documents = options.operations);
         // First parse code from file, in case of syntax error do not try load schema,
         // documents or even graphql-config instance
         const { document } = parseGraphQLSDL(filePath, code, {
@@ -20,12 +22,16 @@ export function parseForESLint(code, options) {
         const gqlConfig = loadGraphQLConfig(options);
         const realFilepath = filePath.replace(VIRTUAL_DOCUMENT_REGEX, '');
         const project = gqlConfig.getProjectForFile(realFilepath);
-        const schema = getSchema(project, options.schemaOptions);
+        const schema = project
+            ? getSchema(project, options.schemaOptions)
+            : typeof options.schema === 'string'
+                ? buildSchema(options.schema)
+                : null;
         const rootTree = convertToESTree(document, schema instanceof GraphQLSchema ? schema : undefined);
         return {
             services: {
                 schema,
-                siblingOperations: getDocuments(project),
+                siblingOperations: getSiblings(project, options.documents),
             },
             ast: {
                 comments: extractComments(document.loc),

package/esm/rules/alphabetize.js

@@ -83,7 +83,7 @@ export const rule = {
         docs: {
             category: ['Schema', 'Operations'],
             description: 'Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.',
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
             examples: [
                 {
                     title: 'Incorrect',

package/esm/rules/description-style.js

@@ -42,7 +42,7 @@ export const rule = {
             ],
             description: 'Require all comments to follow the same style (either block or inline).',
             category: 'Schema',
-            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/description-style.md',
+            url: 'https://the-guild.dev/graphql/eslint/rules/description-style',
             recommended: true,
         },
         schema,

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

@@ -115,7 +115,7 @@ const validationToRule = ({ ruleId, ruleName, getDocumentNode, schema = [], hasD
                     recommended: true,
                     ...docs,
                     graphQLJSRuleName: ruleName,
-                    url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${ruleId}.md`,
+                    url: `https://the-guild.dev/graphql/eslint/rules/${ruleId}`,
                     description: `${docs.description}\n> This rule is a wrapper around a \`graphql-js\` validation function.`,
                 },
                 schema,

package/esm/rules/input-name.js

@@ -9,7 +9,7 @@ const schema = {
             checkInputType: {
                 type: 'boolean',
                 default: false,
-                description: 'Check that the input type name follows the convention <mutationName>Input',
+                description: 'Check that the input type name follows the convention \\<mutationName>Input',
             },
             caseSensitiveInputType: {
                 type: 'boolean',
@@ -41,7 +41,7 @@ export const rule = {
         docs: {
             description: 'Require mutation argument to be always called "input" and input type to be called Mutation name + "Input".\nUsing the same name for all input parameters will make your schemas easier to consume and more predictable. Using the same name as mutation for InputType will make it easier to find mutations that InputType belongs to.',
             category: 'Schema',
-            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/input-name.md',
+            url: 'https://the-guild.dev/graphql/eslint/rules/input-name',
             examples: [
                 {
                     title: 'Incorrect',
@@ -53,7 +53,7 @@ export const rule = {
           `,
                 },
                 {
-                    title: 'Correct (with checkInputType)',
+                    title: 'Correct (with `checkInputType`)',
                     usage: [{ checkInputType: true }],
                     code: /* GraphQL */ `
             type Mutation {
@@ -62,7 +62,7 @@ export const rule = {
           `,
                 },
                 {
-                    title: 'Correct (without checkInputType)',
+                    title: 'Correct (without `checkInputType`)',
                     usage: [{ checkInputType: false }],
                     code: /* GraphQL */ `
             type Mutation {

package/esm/rules/lone-executable-definition.js

@@ -26,7 +26,7 @@ export const rule = {
         docs: {
             category: 'Operations',
             description: 'Require queries, mutations, subscriptions or fragments to be located in separate files.',
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
             examples: [
                 {
                     title: 'Incorrect',

package/esm/rules/match-document-filename.js

@@ -1,7 +1,6 @@
-import { existsSync } from 'fs';
 import { basename, extname } from 'path';
 import { Kind } from 'graphql';
-import { convertCase, REPORT_ON_FIRST_CHARACTER } from '../utils.js';
+import { convertCase, REPORT_ON_FIRST_CHARACTER, VIRTUAL_DOCUMENT_REGEX, } from '../utils.js';
 const MATCH_EXTENSION = 'MATCH_EXTENSION';
 const MATCH_STYLE = 'MATCH_STYLE';
 const CASE_STYLES = [
@@ -54,7 +53,7 @@ export const rule = {
         docs: {
             category: 'Operations',
             description: 'This rule allows you to enforce that the file name should match the operation name.',
-            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/match-document-filename.md',
+            url: 'https://the-guild.dev/graphql/eslint/rules/match-document-filename',
             examples: [
                 {
                     title: 'Correct',
@@ -166,7 +165,7 @@ export const rule = {
             fileExtension: null,
         };
         const filePath = context.getFilename();
-        const isVirtualFile = !existsSync(filePath);
+        const isVirtualFile = VIRTUAL_DOCUMENT_REGEX.test(filePath);
         if (process.env.NODE_ENV !== 'test' && isVirtualFile) {
             // Skip validation for code files
             return {};

package/esm/rules/naming-convention.js

@@ -97,7 +97,7 @@ export const rule = {
             description: 'Require names to follow specified conventions.',
             category: ['Schema', 'Operations'],
             recommended: true,
-            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/naming-convention.md',
+            url: 'https://the-guild.dev/graphql/eslint/rules/naming-convention',
             examples: [
                 {
                     title: 'Incorrect',