@graphql-eslint/eslint-plugin 3.14.0-alpha-20221222211539-5e993f5 → 3.14.0-alpha-20221223011223-bd3e820

package/esm/rules/selection-set-depth.js

@@ -0,0 +1,131 @@
+import depthLimit from 'graphql-depth-limit';
+import { Kind } from 'graphql';
+import { ARRAY_DEFAULT_OPTIONS, logger, requireSiblingsOperations } from '../utils.js';
+const RULE_ID = 'selection-set-depth';
+const schema = {
+    type: 'array',
+    minItems: 1,
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['maxDepth'],
+        properties: {
+            maxDepth: {
+                type: 'number',
+            },
+            ignore: ARRAY_DEFAULT_OPTIONS,
+        },
+    },
+};
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            category: 'Operations',
+            description: 'Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://npmjs.com/package/graphql-depth-limit).',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            requiresSiblings: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    usage: [{ maxDepth: 1 }],
+                    code: `
+            query deep2 {
+              viewer { # Level 0
+                albums { # Level 1
+                  title # Level 2
+                }
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ maxDepth: 4 }],
+                    code: `
+            query deep2 {
+              viewer { # Level 0
+                albums { # Level 1
+                  title # Level 2
+                }
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct (ignored field)',
+                    usage: [{ maxDepth: 1, ignore: ['albums'] }],
+                    code: `
+            query deep2 {
+              viewer { # Level 0
+                albums { # Level 1
+                  title # Level 2
+                }
+              }
+            }
+          `,
+                },
+            ],
+            recommended: true,
+            configOptions: [{ maxDepth: 7 }],
+        },
+        schema,
+    },
+    create(context) {
+        let siblings = null;
+        try {
+            siblings = requireSiblingsOperations(RULE_ID, context);
+        }
+        catch (_a) {
+            logger.warn(`Rule "${RULE_ID}" works best with siblings operations loaded. For more info: https://bit.ly/graphql-eslint-operations`);
+        }
+        const { maxDepth, ignore = [] } = context.options[0];
+        const checkFn = depthLimit(maxDepth, { ignore });
+        return {
+            'OperationDefinition, FragmentDefinition'(node) {
+                try {
+                    const rawNode = node.rawNode();
+                    const fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [];
+                    const document = {
+                        kind: Kind.DOCUMENT,
+                        definitions: [rawNode, ...fragmentsInUse],
+                    };
+                    checkFn({
+                        getDocument: () => document,
+                        reportError(error) {
+                            const { line, column } = error.locations[0];
+                            const ancestors = context.getAncestors();
+                            const token = ancestors[0].tokens.find(token => token.loc.start.line === line && token.loc.start.column === column - 1);
+                            context.report({
+                                loc: {
+                                    line,
+                                    column: column - 1,
+                                },
+                                message: error.message,
+                                // Don't provide suggestions for fragment that can be in a separate file
+                                ...(token && {
+                                    suggest: [
+                                        {
+                                            desc: 'Remove selections',
+                                            fix(fixer) {
+                                                const sourceCode = context.getSourceCode();
+                                                const foundNode = sourceCode.getNodeByRangeIndex(token.range[0]);
+                                                const parentNode = foundNode.parent.parent;
+                                                return fixer.remove(foundNode.kind === 'Name' ? parentNode.parent : parentNode);
+                                            },
+                                        },
+                                    ],
+                                }),
+                            });
+                        },
+                    });
+                }
+                catch (e) {
+                    logger.warn(`Rule "${RULE_ID}" check failed due to a missing siblings operations. For more info: https://bit.ly/graphql-eslint-operations`, e);
+                }
+            },
+        };
+    },
+};

package/esm/rules/strict-id-in-types.js

@@ -0,0 +1,159 @@
+import { Kind } from 'graphql';
+import { ARRAY_DEFAULT_OPTIONS, requireGraphQLSchemaFromContext, englishJoinWords, } from '../utils.js';
+const RULE_ID = 'strict-id-in-types';
+const schema = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            acceptedIdNames: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                default: ['id'],
+            },
+            acceptedIdTypes: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                default: ['ID'],
+            },
+            exceptions: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    types: {
+                        ...ARRAY_DEFAULT_OPTIONS,
+                        description: 'This is used to exclude types with names that match one of the specified values.',
+                    },
+                    suffixes: {
+                        ...ARRAY_DEFAULT_OPTIONS,
+                        description: 'This is used to exclude types with names with suffixes that match one of the specified values.',
+                    },
+                },
+            },
+        },
+    },
+};
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: '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.',
+            category: 'Schema',
+            recommended: true,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            requiresSchema: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    usage: [
+                        {
+                            acceptedIdNames: ['id', '_id'],
+                            acceptedIdTypes: ['ID'],
+                            exceptions: { suffixes: ['Payload'] },
+                        },
+                    ],
+                    code: /* GraphQL */ `
+            # Incorrect field name
+            type InvalidFieldName {
+              key: ID!
+            }
+
+            # Incorrect field type
+            type InvalidFieldType {
+              id: String!
+            }
+
+            # Incorrect exception suffix
+            type InvalidSuffixResult {
+              data: String!
+            }
+
+            # Too many unique identifiers. Must only contain one.
+            type InvalidFieldName {
+              id: ID!
+              _id: ID!
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [
+                        {
+                            acceptedIdNames: ['id', '_id'],
+                            acceptedIdTypes: ['ID'],
+                            exceptions: { types: ['Error'], suffixes: ['Payload'] },
+                        },
+                    ],
+                    code: /* GraphQL */ `
+            type User {
+              id: ID!
+            }
+
+            type Post {
+              _id: ID!
+            }
+
+            type CreateUserPayload {
+              data: String!
+            }
+
+            type Error {
+              message: String!
+            }
+          `,
+                },
+            ],
+        },
+        schema,
+    },
+    create(context) {
+        const options = {
+            acceptedIdNames: ['id'],
+            acceptedIdTypes: ['ID'],
+            exceptions: {},
+            ...context.options[0],
+        };
+        const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
+        const rootTypeNames = [
+            schema.getQueryType(),
+            schema.getMutationType(),
+            schema.getSubscriptionType(),
+        ]
+            .filter(Boolean)
+            .map(type => type.name);
+        const selector = `ObjectTypeDefinition[name.value!=/^(${rootTypeNames.join('|')})$/]`;
+        return {
+            [selector](node) {
+                var _a, _b;
+                const typeName = node.name.value;
+                const shouldIgnoreNode = ((_a = options.exceptions.types) === null || _a === void 0 ? void 0 : _a.includes(typeName)) ||
+                    ((_b = options.exceptions.suffixes) === null || _b === void 0 ? void 0 : _b.some(suffix => typeName.endsWith(suffix)));
+                if (shouldIgnoreNode) {
+                    return;
+                }
+                const validIds = node.fields.filter(field => {
+                    const fieldNode = field.rawNode();
+                    const isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value);
+                    // To be a valid type, it must be non-null and one of the accepted types.
+                    let isValidIdType = false;
+                    if (fieldNode.type.kind === Kind.NON_NULL_TYPE &&
+                        fieldNode.type.type.kind === Kind.NAMED_TYPE) {
+                        isValidIdType = options.acceptedIdTypes.includes(fieldNode.type.type.name.value);
+                    }
+                    return isValidIdName && isValidIdType;
+                });
+                // Usually, there should be only one unique identifier field per type.
+                // Some clients allow multiple fields to be used. If more people need this,
+                // we can extend this rule later.
+                if (validIds.length !== 1) {
+                    const pluralNamesSuffix = options.acceptedIdNames.length > 1 ? 's' : '';
+                    const pluralTypesSuffix = options.acceptedIdTypes.length > 1 ? 's' : '';
+                    context.report({
+                        node: node.name,
+                        message: `${typeName} must have exactly one non-nullable unique identifier. Accepted name${pluralNamesSuffix}: ${englishJoinWords(options.acceptedIdNames)}. Accepted type${pluralTypesSuffix}: ${englishJoinWords(options.acceptedIdTypes)}.`,
+                    });
+                }
+            },
+        };
+    },
+};

package/esm/rules/unique-fragment-name.js

@@ -0,0 +1,86 @@
+import { relative } from 'path';
+import { Kind } from 'graphql';
+import { normalizePath, requireSiblingsOperations, VIRTUAL_DOCUMENT_REGEX, CWD } from '../utils.js';
+const RULE_ID = 'unique-fragment-name';
+export const checkNode = (context, node, ruleId) => {
+    const documentName = node.name.value;
+    const siblings = requireSiblingsOperations(ruleId, context);
+    const siblingDocuments = node.kind === Kind.FRAGMENT_DEFINITION
+        ? siblings.getFragment(documentName)
+        : siblings.getOperation(documentName);
+    const filepath = context.getFilename();
+    const conflictingDocuments = siblingDocuments.filter(f => {
+        var _a;
+        const isSameName = ((_a = f.document.name) === null || _a === void 0 ? void 0 : _a.value) === documentName;
+        const isSamePath = normalizePath(f.filePath) === normalizePath(filepath);
+        return isSameName && !isSamePath;
+    });
+    if (conflictingDocuments.length > 0) {
+        context.report({
+            messageId: ruleId,
+            data: {
+                documentName,
+                summary: conflictingDocuments
+                    .map(f => `\t${relative(CWD, f.filePath.replace(VIRTUAL_DOCUMENT_REGEX, ''))}`)
+                    .join('\n'),
+            },
+            node: node.name,
+        });
+    }
+};
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Operations',
+            description: 'Enforce unique fragment names across your project.',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            requiresSiblings: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            # user.fragment.graphql
+            fragment UserFields on User {
+              id
+              name
+              fullName
+            }
+
+            # user-fields.graphql
+            fragment UserFields on User {
+              id
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            # user.fragment.graphql
+            fragment AllUserFields on User {
+              id
+              name
+              fullName
+            }
+
+            # user-fields.graphql
+            fragment UserFields on User {
+              id
+            }
+          `,
+                },
+            ],
+        },
+        messages: {
+            [RULE_ID]: 'Fragment named "{{ documentName }}" already defined in:\n{{ summary }}',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            FragmentDefinition(node) {
+                checkNode(context, node, RULE_ID);
+            },
+        };
+    },
+};

package/esm/rules/unique-operation-name.js

@@ -0,0 +1,62 @@
+import { checkNode } from './unique-fragment-name.js';
+const RULE_ID = 'unique-operation-name';
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Operations',
+            description: 'Enforce unique operation names across your project.',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            requiresSiblings: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            # foo.query.graphql
+            query user {
+              user {
+                id
+              }
+            }
+
+            # bar.query.graphql
+            query user {
+              me {
+                id
+              }
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            # foo.query.graphql
+            query user {
+              user {
+                id
+              }
+            }
+
+            # bar.query.graphql
+            query me {
+              me {
+                id
+              }
+            }
+          `,
+                },
+            ],
+        },
+        messages: {
+            [RULE_ID]: 'Operation named "{{ documentName }}" already defined in:\n{{ summary }}',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            'OperationDefinition[name!=undefined]'(node) {
+                checkNode(context, node, RULE_ID);
+            },
+        };
+    },
+};

package/esm/schema.js

@@ -0,0 +1,37 @@
+import { GraphQLSchema } from 'graphql';
+import debugFactory from 'debug';
+import fg from 'fast-glob';
+import chalk from 'chalk';
+import { ModuleCache } from './cache.js';
+const schemaCache = new ModuleCache();
+const debug = debugFactory('graphql-eslint:schema');
+export function getSchema(project, schemaOptions) {
+    const schemaKey = project.schema;
+    if (!schemaKey) {
+        return null;
+    }
+    const cache = schemaCache.get(schemaKey);
+    if (cache) {
+        return cache;
+    }
+    let schema;
+    try {
+        debug('Loading schema from %o', project.schema);
+        schema = project.loadSchemaSync(project.schema, 'GraphQLSchema', {
+            ...schemaOptions,
+            pluckConfig: project.extensions.pluckConfig,
+        });
+        if (debug.enabled) {
+            debug('Schema loaded: %o', schema instanceof GraphQLSchema);
+            const schemaPaths = fg.sync(project.schema, { absolute: true });
+            debug('Schema pointers %O', schemaPaths);
+        }
+        // Do not set error to cache, since cache reload will be done after some `lifetime` seconds
+        schemaCache.set(schemaKey, schema);
+    }
+    catch (error) {
+        error.message = chalk.red(`Error while loading schema: ${error.message}`);
+        schema = error;
+    }
+    return schema;
+}

package/esm/testkit.js

@@ -0,0 +1,181 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+/* eslint-env jest */
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { RuleTester, Linter } from 'eslint';
+import { codeFrameColumns } from '@babel/code-frame';
+function indentCode(code, indent = 4) {
+    return code.replace(/^/gm, ' '.repeat(indent));
+}
+// A simple version of `SourceCodeFixer.applyFixes`
+// https://github.com/eslint/eslint/issues/14936#issuecomment-906746754
+function applyFix(code, { range, text }) {
+    return [code.slice(0, range[0]), text, code.slice(range[1])].join('');
+}
+export class GraphQLRuleTester extends RuleTester {
+    constructor(parserOptions = {}) {
+        const config = {
+            parser: require.resolve('@graphql-eslint/eslint-plugin'),
+            parserOptions: {
+                ...parserOptions,
+                skipGraphQLConfig: true,
+            },
+        };
+        super(config);
+        this.config = config;
+    }
+    fromMockFile(path) {
+        return readFileSync(resolve(__dirname, `../tests/mocks/${path}`), 'utf-8');
+    }
+    runGraphQLTests(ruleId, rule, tests) {
+        const ruleTests = Linter.version.startsWith('8')
+            ? tests
+            : {
+                valid: tests.valid.map(test => {
+                    if (typeof test === 'string') {
+                        return test;
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const { name, ...testCaseOptions } = test;
+                    return testCaseOptions;
+                }),
+                invalid: tests.invalid.map(test => {
+                    // ESLint 7 throws an error on CI - Unexpected top-level property "name"
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const { name, ...testCaseOptions } = test;
+                    return testCaseOptions;
+                }),
+            };
+        super.run(ruleId, rule, ruleTests);
+        const linter = new Linter();
+        linter.defineRule(ruleId, rule);
+        const hasOnlyTest = [...tests.valid, ...tests.invalid].some(t => typeof t !== 'string' && t.only);
+        // for (const [index, testCase] of tests.valid.entries()) {
+        //   const { name, code, filename, only }: RuleTester.ValidTestCase =
+        //     typeof testCase === 'string' ? { code: testCase } : testCase;
+        //
+        //   if (hasOnlyTest && !only) {
+        //     continue;
+        //   }
+        //
+        //   const verifyConfig = getVerifyConfig(ruleId, this.config, testCase);
+        //   defineParser(linter, verifyConfig.parser);
+        //
+        //   const messages = linter.verify(code, verifyConfig, { filename });
+        //   const codeFrame = printCode(code, { line: 0, column: 0 });
+        //
+        //   it(name || `Valid #${index + 1}\n${codeFrame}`, () => {
+        //     expect(messages).toEqual([]);
+        //   });
+        // }
+        for (const [idx, testCase] of tests.invalid.entries()) {
+            const { only, filename, options, name } = testCase;
+            if (hasOnlyTest && !only) {
+                continue;
+            }
+            const code = removeTrailingBlankLines(testCase.code);
+            const verifyConfig = getVerifyConfig(ruleId, this.config, testCase);
+            defineParser(linter, verifyConfig.parser);
+            const messages = linter.verify(code, verifyConfig, filename);
+            if (messages.length === 0) {
+                throw new Error('Invalid case should have at least one error.');
+            }
+            const codeFrame = indentCode(printCode(code, { line: 0, column: 0 }));
+            const messageForSnapshot = ['#### ⌨️ Code', codeFrame];
+            if (options) {
+                const opts = JSON.stringify(options, null, 2).slice(1, -1);
+                messageForSnapshot.push('#### ⚙️ Options', indentCode(removeTrailingBlankLines(opts), 2));
+            }
+            for (const [index, message] of messages.entries()) {
+                if (message.fatal) {
+                    throw new Error(message.message);
+                }
+                const codeWithMessage = printCode(code, message, 1);
+                messageForSnapshot.push(printWithIndex('#### ❌ Error', index, messages.length), indentCode(codeWithMessage));
+                const { suggestions } = message;
+                // Don't print suggestions in snapshots for too big codes
+                if (suggestions && (code.match(/\n/g) || '').length < 1000) {
+                    for (const [i, suggestion] of message.suggestions.entries()) {
+                        const title = printWithIndex('#### 💡 Suggestion', i, suggestions.length, suggestion.desc);
+                        const output = applyFix(code, suggestion.fix);
+                        const codeFrame = printCode(output, { line: 0, column: 0 });
+                        messageForSnapshot.push(title, indentCode(codeFrame, 2));
+                    }
+                }
+            }
+            if (rule.meta.fixable) {
+                const { fixed, output } = linter.verifyAndFix(code, verifyConfig, filename);
+                if (fixed) {
+                    messageForSnapshot.push('#### 🔧 Autofix output', indentCode(printCode(output)));
+                }
+            }
+            // @ts-expect-error -- we should import `vitest` but somebody could use globals from `jest`
+            it(name || `Invalid #${idx + 1}`, () => {
+                // @ts-expect-error -- ^ same
+                expect(messageForSnapshot.join('\n\n')).toMatchSnapshot();
+            });
+        }
+    }
+}
+function removeTrailingBlankLines(text) {
+    return text.replace(/^\s*\n/, '').trimEnd();
+}
+function printWithIndex(title, index, total, description) {
+    if (total > 1) {
+        title += ` ${index + 1}/${total}`;
+    }
+    if (description) {
+        title += `: ${description}`;
+    }
+    return title;
+}
+function getVerifyConfig(ruleId, testerConfig, testCase) {
+    const { parser = testerConfig.parser, parserOptions, options } = testCase;
+    return {
+        ...testerConfig,
+        parser,
+        parserOptions: {
+            ...testerConfig.parserOptions,
+            ...parserOptions,
+        },
+        rules: {
+            [ruleId]: Array.isArray(options) ? ['error', ...options] : 'error',
+        },
+    };
+}
+const parsers = new WeakMap();
+function defineParser(linter, parser) {
+    if (!parser) {
+        return;
+    }
+    if (!parsers.has(linter)) {
+        parsers.set(linter, new Set());
+    }
+    const defined = parsers.get(linter);
+    if (!defined.has(parser)) {
+        defined.add(parser);
+        linter.defineParser(parser, require(parser));
+    }
+}
+function printCode(code, result = {}, linesOffset = Number.POSITIVE_INFINITY) {
+    const { line, column, endLine, endColumn, message } = result;
+    const location = {};
+    if (typeof line === 'number' && typeof column === 'number') {
+        location.start = {
+            line,
+            column,
+        };
+    }
+    if (typeof endLine === 'number' && typeof endColumn === 'number') {
+        location.end = {
+            line: endLine,
+            column: endColumn,
+        };
+    }
+    return codeFrameColumns(code, location, {
+        linesAbove: linesOffset,
+        linesBelow: linesOffset,
+        message,
+    });
+}

package/esm/types.js

@@ -0,0 +1 @@
+export {};