@graphql-eslint/eslint-plugin 3.14.0-alpha-20221221142641-4e1a924 → 3.14.0-alpha-20221222012949-5caade4

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

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("../utils");
+const RULE_ID = 'strict-id-in-types';
+const schema = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            acceptedIdNames: {
+                ...utils_1.ARRAY_DEFAULT_OPTIONS,
+                default: ['id'],
+            },
+            acceptedIdTypes: {
+                ...utils_1.ARRAY_DEFAULT_OPTIONS,
+                default: ['ID'],
+            },
+            exceptions: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    types: {
+                        ...utils_1.ARRAY_DEFAULT_OPTIONS,
+                        description: 'This is used to exclude types with names that match one of the specified values.',
+                    },
+                    suffixes: {
+                        ...utils_1.ARRAY_DEFAULT_OPTIONS,
+                        description: 'This is used to exclude types with names with suffixes that match one of the specified values.',
+                    },
+                },
+            },
+        },
+    },
+};
+exports.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 = (0, utils_1.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 === graphql_1.Kind.NON_NULL_TYPE &&
+                        fieldNode.type.type.kind === graphql_1.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}: ${(0, utils_1.englishJoinWords)(options.acceptedIdNames)}. Accepted type${pluralTypesSuffix}: ${(0, utils_1.englishJoinWords)(options.acceptedIdTypes)}.`,
+                    });
+                }
+            },
+        };
+    },
+};

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = exports.checkNode = void 0;
+const path_1 = require("path");
+const graphql_1 = require("graphql");
+const utils_1 = require("../utils");
+const RULE_ID = 'unique-fragment-name';
+const checkNode = (context, node, ruleId) => {
+    const documentName = node.name.value;
+    const siblings = (0, utils_1.requireSiblingsOperations)(ruleId, context);
+    const siblingDocuments = node.kind === graphql_1.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 = (0, utils_1.normalizePath)(f.filePath) === (0, utils_1.normalizePath)(filepath);
+        return isSameName && !isSamePath;
+    });
+    if (conflictingDocuments.length > 0) {
+        context.report({
+            messageId: ruleId,
+            data: {
+                documentName,
+                summary: conflictingDocuments
+                    .map(f => `\t${(0, path_1.relative)(utils_1.CWD, f.filePath.replace(utils_1.VIRTUAL_DOCUMENT_REGEX, ''))}`)
+                    .join('\n'),
+            },
+            node: node.name,
+        });
+    }
+};
+exports.checkNode = checkNode;
+exports.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) {
+                (0, exports.checkNode)(context, node, RULE_ID);
+            },
+        };
+    },
+};

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const unique_fragment_name_1 = require("./unique-fragment-name");
+const RULE_ID = 'unique-operation-name';
+exports.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) {
+                (0, unique_fragment_name_1.checkNode)(context, node, RULE_ID);
+            },
+        };
+    },
+};

package/cjs/schema.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchema = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const fast_glob_1 = tslib_1.__importDefault(require("fast-glob"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const cache_1 = require("./cache");
+const schemaCache = new cache_1.ModuleCache();
+const debug = (0, debug_1.default)('graphql-eslint:schema');
+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 graphql_1.GraphQLSchema);
+            const schemaPaths = fast_glob_1.default.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_1.default.red(`Error while loading schema: ${error.message}`);
+        schema = error;
+    }
+    return schema;
+}
+exports.getSchema = getSchema;

package/cjs/testkit.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLRuleTester = void 0;
+/* eslint-env jest */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const eslint_1 = require("eslint");
+const code_frame_1 = require("@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('');
+}
+class GraphQLRuleTester extends eslint_1.RuleTester {
+    constructor(parserOptions = {}) {
+        const config = {
+            parser: require.resolve('@graphql-eslint/eslint-plugin'),
+            parserOptions: {
+                ...parserOptions,
+                skipGraphQLConfig: true,
+            },
+        };
+        super(config);
+        this.config = config;
+    }
+    fromMockFile(path) {
+        return (0, fs_1.readFileSync)((0, path_1.resolve)(__dirname, `../tests/mocks/${path}`), 'utf-8');
+    }
+    runGraphQLTests(ruleId, rule, tests) {
+        const ruleTests = eslint_1.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 eslint_1.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();
+            });
+        }
+    }
+}
+exports.GraphQLRuleTester = GraphQLRuleTester;
+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 (0, code_frame_1.codeFrameColumns)(code, location, {
+        linesAbove: linesOffset,
+        linesBelow: linesOffset,
+        message,
+    });
+}

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/utils.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.englishJoinWords = exports.ARRAY_DEFAULT_OPTIONS = exports.REPORT_ON_FIRST_CHARACTER = exports.getLocation = exports.convertCase = exports.camelCase = exports.pascalCase = exports.TYPES_KINDS = exports.getTypeName = exports.CWD = exports.VIRTUAL_DOCUMENT_REGEX = exports.normalizePath = exports.logger = exports.requireGraphQLSchemaFromContext = exports.requireSiblingsOperations = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const lodash_lowercase_1 = tslib_1.__importDefault(require("lodash.lowercase"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+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;
+}
+exports.requireSiblingsOperations = requireSiblingsOperations;
+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`);
+    }
+    else if (schema instanceof Error) {
+        throw schema;
+    }
+    return schema;
+}
+exports.requireGraphQLSchemaFromContext = requireGraphQLSchemaFromContext;
+exports.logger = {
+    // eslint-disable-next-line no-console
+    error: (...args) => console.error(chalk_1.default.red('error'), '[graphql-eslint]', (0, chalk_1.default)(...args)),
+    // eslint-disable-next-line no-console
+    warn: (...args) => console.warn(chalk_1.default.yellow('warning'), '[graphql-eslint]', (0, chalk_1.default)(...args)),
+};
+const normalizePath = (path) => (path || '').replace(/\\/g, '/');
+exports.normalizePath = normalizePath;
+exports.VIRTUAL_DOCUMENT_REGEX = /\/\d+_document.graphql$/;
+exports.CWD = process.cwd();
+const getTypeName = (node) => 'type' in node ? (0, exports.getTypeName)(node.type) : node.name.value;
+exports.getTypeName = getTypeName;
+exports.TYPES_KINDS = [
+    graphql_1.Kind.OBJECT_TYPE_DEFINITION,
+    graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
+    graphql_1.Kind.ENUM_TYPE_DEFINITION,
+    graphql_1.Kind.SCALAR_TYPE_DEFINITION,
+    graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    graphql_1.Kind.UNION_TYPE_DEFINITION,
+];
+const pascalCase = (str) => (0, lodash_lowercase_1.default)(str)
+    .split(' ')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+exports.pascalCase = pascalCase;
+const camelCase = (str) => {
+    const result = (0, exports.pascalCase)(str);
+    return result.charAt(0).toLowerCase() + result.slice(1);
+};
+exports.camelCase = camelCase;
+const convertCase = (style, str) => {
+    switch (style) {
+        case 'camelCase':
+            return (0, exports.camelCase)(str);
+        case 'PascalCase':
+            return (0, exports.pascalCase)(str);
+        case 'snake_case':
+            return (0, lodash_lowercase_1.default)(str).replace(/ /g, '_');
+        case 'UPPER_CASE':
+            return (0, lodash_lowercase_1.default)(str).replace(/ /g, '_').toUpperCase();
+        case 'kebab-case':
+            return (0, lodash_lowercase_1.default)(str).replace(/ /g, '-');
+    }
+};
+exports.convertCase = convertCase;
+function getLocation(start, fieldName = '') {
+    const { line, column } = start;
+    return {
+        start: {
+            line,
+            column,
+        },
+        end: {
+            line,
+            column: column + fieldName.length,
+        },
+    };
+}
+exports.getLocation = getLocation;
+exports.REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 };
+exports.ARRAY_DEFAULT_OPTIONS = {
+    type: 'array',
+    uniqueItems: true,
+    minItems: 1,
+    items: {
+        type: 'string',
+    },
+};
+const englishJoinWords = words => new Intl.ListFormat('en-US', { type: 'disjunction' }).format(words);
+exports.englishJoinWords = englishJoinWords;