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

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

@@ -0,0 +1,499 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAPHQL_JS_VALIDATIONS = void 0;
+const graphql_1 = require("graphql");
+const validate_1 = require("graphql/validation/validate");
+const utils_1 = require("../utils");
+function validateDocument({ context, schema = null, documentNode, rule, hasDidYouMeanSuggestions, }) {
+    var _a;
+    if (documentNode.definitions.length === 0) {
+        return;
+    }
+    try {
+        const validationErrors = schema
+            ? (0, graphql_1.validate)(schema, documentNode, [rule])
+            : (0, validate_1.validateSDL)(documentNode, null, [rule]);
+        for (const error of validationErrors) {
+            const { line, column } = error.locations[0];
+            const sourceCode = context.getSourceCode();
+            const { tokens } = sourceCode.ast;
+            const token = tokens.find(token => token.loc.start.line === line && token.loc.start.column === column - 1);
+            let loc = {
+                line,
+                column: column - 1,
+            };
+            if (token) {
+                loc =
+                    // if cursor on `@` symbol than use next node
+                    token.type === '@'
+                        ? sourceCode.getNodeByRangeIndex(token.range[1] + 1).loc
+                        : token.loc;
+            }
+            const didYouMeanContent = (_a = error.message.match(/Did you mean (?<content>.*)\?$/)) === null || _a === void 0 ? void 0 : _a.groups.content;
+            const matches = didYouMeanContent ? [...didYouMeanContent.matchAll(/"(?<name>[^"]*)"/g)] : [];
+            context.report({
+                loc,
+                message: error.message,
+                suggest: hasDidYouMeanSuggestions
+                    ? matches.map(match => {
+                        const { name } = match.groups;
+                        return {
+                            desc: `Rename to \`${name}\``,
+                            fix: fixer => fixer.replaceText(token, name),
+                        };
+                    })
+                    : [],
+            });
+        }
+    }
+    catch (e) {
+        context.report({
+            loc: utils_1.REPORT_ON_FIRST_CHARACTER,
+            message: e.message,
+        });
+    }
+}
+const getFragmentDefsAndFragmentSpreads = (node) => {
+    const fragmentDefs = new Set();
+    const fragmentSpreads = new Set();
+    const visitor = {
+        FragmentDefinition(node) {
+            fragmentDefs.add(node.name.value);
+        },
+        FragmentSpread(node) {
+            fragmentSpreads.add(node.name.value);
+        },
+    };
+    (0, graphql_1.visit)(node, visitor);
+    return { fragmentDefs, fragmentSpreads };
+};
+const getMissingFragments = (node) => {
+    const { fragmentDefs, fragmentSpreads } = getFragmentDefsAndFragmentSpreads(node);
+    return [...fragmentSpreads].filter(name => !fragmentDefs.has(name));
+};
+const handleMissingFragments = ({ ruleId, context, node }) => {
+    const missingFragments = getMissingFragments(node);
+    if (missingFragments.length > 0) {
+        const siblings = (0, utils_1.requireSiblingsOperations)(ruleId, context);
+        const fragmentsToAdd = [];
+        for (const fragmentName of missingFragments) {
+            const [foundFragment] = siblings.getFragment(fragmentName).map(source => source.document);
+            if (foundFragment) {
+                fragmentsToAdd.push(foundFragment);
+            }
+        }
+        if (fragmentsToAdd.length > 0) {
+            // recall fn to make sure to add fragments inside fragments
+            return handleMissingFragments({
+                ruleId,
+                context,
+                node: {
+                    kind: graphql_1.Kind.DOCUMENT,
+                    definitions: [...node.definitions, ...fragmentsToAdd],
+                },
+            });
+        }
+    }
+    return node;
+};
+const validationToRule = ({ ruleId, ruleName, getDocumentNode, schema = [], hasDidYouMeanSuggestions, }, docs) => {
+    let ruleFn = null;
+    try {
+        ruleFn = require(`graphql/validation/rules/${ruleName}Rule`)[`${ruleName}Rule`];
+    }
+    catch (_a) {
+        try {
+            ruleFn = require(`graphql/validation/rules/${ruleName}`)[`${ruleName}Rule`];
+        }
+        catch (_b) {
+            ruleFn = require('graphql/validation')[`${ruleName}Rule`];
+        }
+    }
+    return {
+        [ruleId]: {
+            meta: {
+                docs: {
+                    recommended: true,
+                    ...docs,
+                    graphQLJSRuleName: ruleName,
+                    url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${ruleId}.md`,
+                    description: `${docs.description}\n> This rule is a wrapper around a \`graphql-js\` validation function.`,
+                },
+                schema,
+                hasSuggestions: hasDidYouMeanSuggestions,
+            },
+            create(context) {
+                if (!ruleFn) {
+                    utils_1.logger.warn(`Rule "${ruleId}" depends on a GraphQL validation rule "${ruleName}" but it's not available in the "graphql" version you are using. Skipping…`);
+                    return {};
+                }
+                return {
+                    Document(node) {
+                        const schema = docs.requiresSchema
+                            ? (0, utils_1.requireGraphQLSchemaFromContext)(ruleId, context)
+                            : null;
+                        const documentNode = getDocumentNode
+                            ? getDocumentNode({ ruleId, context, node: node.rawNode() })
+                            : node.rawNode();
+                        validateDocument({
+                            context,
+                            schema,
+                            documentNode,
+                            rule: ruleFn,
+                            hasDidYouMeanSuggestions,
+                        });
+                    },
+                };
+            },
+        },
+    };
+};
+exports.GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule({
+    ruleId: 'executable-definitions',
+    ruleName: 'ExecutableDefinitions',
+}, {
+    category: 'Operations',
+    description: 'A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'fields-on-correct-type',
+    ruleName: 'FieldsOnCorrectType',
+    hasDidYouMeanSuggestions: true,
+}, {
+    category: 'Operations',
+    description: '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`.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'fragments-on-composite-type',
+    ruleName: 'FragmentsOnCompositeTypes',
+}, {
+    category: 'Operations',
+    description: '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.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'known-argument-names',
+    ruleName: 'KnownArgumentNames',
+    hasDidYouMeanSuggestions: true,
+}, {
+    category: ['Schema', 'Operations'],
+    description: 'A GraphQL field is only valid if all supplied arguments are defined by that field.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'known-directives',
+    ruleName: 'KnownDirectives',
+    getDocumentNode({ context, node: documentNode }) {
+        const { ignoreClientDirectives = [] } = context.options[0] || {};
+        if (ignoreClientDirectives.length === 0) {
+            return documentNode;
+        }
+        const filterDirectives = (node) => ({
+            ...node,
+            directives: node.directives.filter(directive => !ignoreClientDirectives.includes(directive.name.value)),
+        });
+        return (0, graphql_1.visit)(documentNode, {
+            Field: filterDirectives,
+            OperationDefinition: filterDirectives,
+        });
+    },
+    schema: {
+        type: 'array',
+        maxItems: 1,
+        items: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['ignoreClientDirectives'],
+            properties: {
+                ignoreClientDirectives: utils_1.ARRAY_DEFAULT_OPTIONS,
+            },
+        },
+    },
+}, {
+    category: ['Schema', 'Operations'],
+    description: 'A GraphQL document is only valid if all `@directive`s are known by the schema and legally positioned.',
+    requiresSchema: true,
+    examples: [
+        {
+            title: 'Valid',
+            usage: [{ ignoreClientDirectives: ['client'] }],
+            code: /* GraphQL */ `
+            {
+              product {
+                someClientField @client
+              }
+            }
+          `,
+        },
+    ],
+}), validationToRule({
+    ruleId: 'known-fragment-names',
+    ruleName: 'KnownFragmentNames',
+    getDocumentNode: handleMissingFragments,
+}, {
+    category: 'Operations',
+    description: 'A GraphQL document is only valid if all `...Fragment` fragment spreads refer to fragments defined in the same document.',
+    requiresSchema: true,
+    requiresSiblings: true,
+    examples: [
+        {
+            title: 'Incorrect',
+            code: /* GraphQL */ `
+            query {
+              user {
+                id
+                ...UserFields # fragment not defined in the document
+              }
+            }
+          `,
+        },
+        {
+            title: 'Correct',
+            code: /* GraphQL */ `
+            fragment UserFields on User {
+              firstName
+              lastName
+            }
+
+            query {
+              user {
+                id
+                ...UserFields
+              }
+            }
+          `,
+        },
+        {
+            title: 'Correct (`UserFields` fragment located in a separate file)',
+            code: /* GraphQL */ `
+            # user.gql
+            query {
+              user {
+                id
+                ...UserFields
+              }
+            }
+
+            # user-fields.gql
+            fragment UserFields on User {
+              id
+            }
+          `,
+        },
+    ],
+}), validationToRule({
+    ruleId: 'known-type-names',
+    ruleName: 'KnownTypeNames',
+    hasDidYouMeanSuggestions: true,
+}, {
+    category: ['Schema', 'Operations'],
+    description: 'A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'lone-anonymous-operation',
+    ruleName: 'LoneAnonymousOperation',
+}, {
+    category: 'Operations',
+    description: 'A GraphQL document that contains an anonymous operation (the `query` short-hand) is only valid if it contains only that one operation definition.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'lone-schema-definition',
+    ruleName: 'LoneSchemaDefinition',
+}, {
+    category: 'Schema',
+    description: 'A GraphQL document is only valid if it contains only one schema definition.',
+}), validationToRule({
+    ruleId: 'no-fragment-cycles',
+    ruleName: 'NoFragmentCycles',
+}, {
+    category: 'Operations',
+    description: 'A GraphQL fragment is only valid when it does not have cycles in fragments usage.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'no-undefined-variables',
+    ruleName: 'NoUndefinedVariables',
+    getDocumentNode: handleMissingFragments,
+}, {
+    category: 'Operations',
+    description: 'A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.',
+    requiresSchema: true,
+    requiresSiblings: true,
+}), validationToRule({
+    ruleId: 'no-unused-fragments',
+    ruleName: 'NoUnusedFragments',
+    getDocumentNode: ({ ruleId, context, node }) => {
+        const siblings = (0, utils_1.requireSiblingsOperations)(ruleId, context);
+        const FilePathToDocumentsMap = [
+            ...siblings.getOperations(),
+            ...siblings.getFragments(),
+        ].reduce((map, { filePath, document }) => {
+            var _a;
+            (_a = map[filePath]) !== null && _a !== void 0 ? _a : (map[filePath] = []);
+            map[filePath].push(document);
+            return map;
+        }, Object.create(null));
+        const getParentNode = (currentFilePath, node) => {
+            const { fragmentDefs } = getFragmentDefsAndFragmentSpreads(node);
+            if (fragmentDefs.size === 0) {
+                return node;
+            }
+            // skip iteration over documents for current filepath
+            delete FilePathToDocumentsMap[currentFilePath];
+            for (const [filePath, documents] of Object.entries(FilePathToDocumentsMap)) {
+                const missingFragments = getMissingFragments({
+                    kind: graphql_1.Kind.DOCUMENT,
+                    definitions: documents,
+                });
+                const isCurrentFileImportFragment = missingFragments.some(fragment => fragmentDefs.has(fragment));
+                if (isCurrentFileImportFragment) {
+                    return getParentNode(filePath, {
+                        kind: graphql_1.Kind.DOCUMENT,
+                        definitions: [...node.definitions, ...documents],
+                    });
+                }
+            }
+            return node;
+        };
+        return getParentNode(context.getFilename(), node);
+    },
+}, {
+    category: 'Operations',
+    description: 'A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations.',
+    requiresSchema: true,
+    requiresSiblings: true,
+}), validationToRule({
+    ruleId: 'no-unused-variables',
+    ruleName: 'NoUnusedVariables',
+    getDocumentNode: handleMissingFragments,
+}, {
+    category: 'Operations',
+    description: 'A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.',
+    requiresSchema: true,
+    requiresSiblings: true,
+}), validationToRule({
+    ruleId: 'overlapping-fields-can-be-merged',
+    ruleName: 'OverlappingFieldsCanBeMerged',
+}, {
+    category: 'Operations',
+    description: '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.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'possible-fragment-spread',
+    ruleName: 'PossibleFragmentSpreads',
+}, {
+    category: 'Operations',
+    description: '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.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'possible-type-extension',
+    ruleName: 'PossibleTypeExtensions',
+    hasDidYouMeanSuggestions: true,
+}, {
+    category: 'Schema',
+    description: 'A type extension is only valid if the type is defined and has the same kind.',
+    // TODO: add in graphql-eslint v4
+    recommended: false,
+    requiresSchema: true,
+    isDisabledForAllConfig: true,
+}), validationToRule({
+    ruleId: 'provided-required-arguments',
+    ruleName: 'ProvidedRequiredArguments',
+}, {
+    category: ['Schema', 'Operations'],
+    description: 'A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'scalar-leafs',
+    ruleName: 'ScalarLeafs',
+    hasDidYouMeanSuggestions: true,
+}, {
+    category: 'Operations',
+    description: 'A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'one-field-subscriptions',
+    ruleName: 'SingleFieldSubscriptions',
+}, {
+    category: 'Operations',
+    description: 'A GraphQL subscription is valid only if it contains a single root field.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'unique-argument-names',
+    ruleName: 'UniqueArgumentNames',
+}, {
+    category: 'Operations',
+    description: 'A GraphQL field or directive is only valid if all supplied arguments are uniquely named.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'unique-directive-names',
+    ruleName: 'UniqueDirectiveNames',
+}, {
+    category: 'Schema',
+    description: 'A GraphQL document is only valid if all defined directives have unique names.',
+}), validationToRule({
+    ruleId: 'unique-directive-names-per-location',
+    ruleName: 'UniqueDirectivesPerLocation',
+}, {
+    category: ['Schema', 'Operations'],
+    description: 'A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'unique-enum-value-names',
+    ruleName: 'UniqueEnumValueNames',
+}, {
+    category: 'Schema',
+    description: 'A GraphQL enum type is only valid if all its values are uniquely named.',
+    recommended: false,
+    isDisabledForAllConfig: true,
+}), validationToRule({
+    ruleId: 'unique-field-definition-names',
+    ruleName: 'UniqueFieldDefinitionNames',
+}, {
+    category: 'Schema',
+    description: 'A GraphQL complex type is only valid if all its fields are uniquely named.',
+}), validationToRule({
+    ruleId: 'unique-input-field-names',
+    ruleName: 'UniqueInputFieldNames',
+}, {
+    category: 'Operations',
+    description: 'A GraphQL input object value is only valid if all supplied fields are uniquely named.',
+}), validationToRule({
+    ruleId: 'unique-operation-types',
+    ruleName: 'UniqueOperationTypes',
+}, {
+    category: 'Schema',
+    description: 'A GraphQL document is only valid if it has only one type per operation.',
+}), validationToRule({
+    ruleId: 'unique-type-names',
+    ruleName: 'UniqueTypeNames',
+}, {
+    category: 'Schema',
+    description: 'A GraphQL document is only valid if all defined types have unique names.',
+}), validationToRule({
+    ruleId: 'unique-variable-names',
+    ruleName: 'UniqueVariableNames',
+}, {
+    category: 'Operations',
+    description: 'A GraphQL operation is only valid if all its variables are uniquely named.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'value-literals-of-correct-type',
+    ruleName: 'ValuesOfCorrectType',
+    hasDidYouMeanSuggestions: true,
+}, {
+    category: 'Operations',
+    description: 'A GraphQL document is only valid if all value literals are of the type expected at their position.',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'variables-are-input-types',
+    ruleName: 'VariablesAreInputTypes',
+}, {
+    category: 'Operations',
+    description: 'A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).',
+    requiresSchema: true,
+}), validationToRule({
+    ruleId: 'variables-in-allowed-position',
+    ruleName: 'VariablesInAllowedPosition',
+}, {
+    category: 'Operations',
+    description: 'Variables passed to field arguments conform to type.',
+    requiresSchema: true,
+}));

package/cjs/rules/index.js

@@ -0,0 +1,68 @@
+"use strict";
+/*
+ * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rules = void 0;
+const graphql_js_validation_1 = require("./graphql-js-validation");
+const alphabetize_1 = require("./alphabetize");
+const description_style_1 = require("./description-style");
+const input_name_1 = require("./input-name");
+const lone_executable_definition_1 = require("./lone-executable-definition");
+const match_document_filename_1 = require("./match-document-filename");
+const naming_convention_1 = require("./naming-convention");
+const no_anonymous_operations_1 = require("./no-anonymous-operations");
+const no_case_insensitive_enum_values_duplicates_1 = require("./no-case-insensitive-enum-values-duplicates");
+const no_deprecated_1 = require("./no-deprecated");
+const no_duplicate_fields_1 = require("./no-duplicate-fields");
+const no_hashtag_description_1 = require("./no-hashtag-description");
+const no_root_type_1 = require("./no-root-type");
+const no_scalar_result_type_on_mutation_1 = require("./no-scalar-result-type-on-mutation");
+const no_typename_prefix_1 = require("./no-typename-prefix");
+const no_unreachable_types_1 = require("./no-unreachable-types");
+const no_unused_fields_1 = require("./no-unused-fields");
+const relay_arguments_1 = require("./relay-arguments");
+const relay_connection_types_1 = require("./relay-connection-types");
+const relay_edge_types_1 = require("./relay-edge-types");
+const relay_page_info_1 = require("./relay-page-info");
+const require_deprecation_date_1 = require("./require-deprecation-date");
+const require_deprecation_reason_1 = require("./require-deprecation-reason");
+const require_description_1 = require("./require-description");
+const require_field_of_type_query_in_mutation_result_1 = require("./require-field-of-type-query-in-mutation-result");
+const require_id_when_available_1 = require("./require-id-when-available");
+const selection_set_depth_1 = require("./selection-set-depth");
+const strict_id_in_types_1 = require("./strict-id-in-types");
+const unique_fragment_name_1 = require("./unique-fragment-name");
+const unique_operation_name_1 = require("./unique-operation-name");
+exports.rules = {
+    ...graphql_js_validation_1.GRAPHQL_JS_VALIDATIONS,
+    alphabetize: alphabetize_1.rule,
+    'description-style': description_style_1.rule,
+    'input-name': input_name_1.rule,
+    'lone-executable-definition': lone_executable_definition_1.rule,
+    'match-document-filename': match_document_filename_1.rule,
+    'naming-convention': naming_convention_1.rule,
+    'no-anonymous-operations': no_anonymous_operations_1.rule,
+    'no-case-insensitive-enum-values-duplicates': no_case_insensitive_enum_values_duplicates_1.rule,
+    'no-deprecated': no_deprecated_1.rule,
+    'no-duplicate-fields': no_duplicate_fields_1.rule,
+    'no-hashtag-description': no_hashtag_description_1.rule,
+    'no-root-type': no_root_type_1.rule,
+    'no-scalar-result-type-on-mutation': no_scalar_result_type_on_mutation_1.rule,
+    'no-typename-prefix': no_typename_prefix_1.rule,
+    'no-unreachable-types': no_unreachable_types_1.rule,
+    'no-unused-fields': no_unused_fields_1.rule,
+    'relay-arguments': relay_arguments_1.rule,
+    'relay-connection-types': relay_connection_types_1.rule,
+    'relay-edge-types': relay_edge_types_1.rule,
+    'relay-page-info': relay_page_info_1.rule,
+    'require-deprecation-date': require_deprecation_date_1.rule,
+    'require-deprecation-reason': require_deprecation_reason_1.rule,
+    'require-description': require_description_1.rule,
+    'require-field-of-type-query-in-mutation-result': require_field_of_type_query_in_mutation_result_1.rule,
+    'require-id-when-available': require_id_when_available_1.rule,
+    'selection-set-depth': selection_set_depth_1.rule,
+    'strict-id-in-types': strict_id_in_types_1.rule,
+    'unique-fragment-name': unique_fragment_name_1.rule,
+    'unique-operation-name': unique_operation_name_1.rule,
+};