@graphql-eslint/eslint-plugin/index.js

GraphQL plugin for ESLint

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

const graphqlTagPluck = require('@graphql-tools/graphql-tag-pluck');
const utils = require('@graphql-tools/utils');
const path = require('path');
const debugFactory = _interopDefault(require('debug'));
const graphqlConfig = require('graphql-config');
const codeFileLoader = require('@graphql-tools/code-file-loader');
const graphql = require('graphql');
const validate = require('graphql/validation/validate');
const lowerCase = _interopDefault(require('lodash.lowercase'));
const chalk = _interopDefault(require('chalk'));
const fs = require('fs');
const valueFromASTUntyped = require('graphql/utilities/valueFromASTUntyped');
const depthLimit = _interopDefault(require('graphql-depth-limit'));
const fg = _interopDefault(require('fast-glob'));
const eslint = require('eslint');
const codeFrame = require('@babel/code-frame');

const debug = debugFactory('graphql-eslint:graphql-config');
let graphQLConfig;
function loadOnDiskGraphQLConfig(filePath) {
    return graphqlConfig.loadConfigSync({
        // load config relative to the file being linted
        rootDir: path.dirname(filePath),
        throwOnEmpty: false,
        throwOnMissing: false,
        extensions: [codeFileLoaderExtension],
    });
}
function loadGraphQLConfig(options) {
    // We don't want cache config on test environment
    // Otherwise schema and documents will be same for all tests
    if (process.env.NODE_ENV !== 'test' && graphQLConfig) {
        return graphQLConfig;
    }
    const onDiskConfig = !options.skipGraphQLConfig && loadOnDiskGraphQLConfig(options.filePath);
    debug('options.skipGraphQLConfig: %o', options.skipGraphQLConfig);
    if (onDiskConfig) {
        debug('Graphql-config path %o', onDiskConfig.filepath);
    }
    const configOptions = options.projects
        ? { projects: options.projects }
        : {
            schema: (options.schema || ''),
            documents: options.documents || options.operations,
            extensions: options.extensions,
            include: options.include,
            exclude: options.exclude,
        };
    graphQLConfig =
        onDiskConfig ||
            new graphqlConfig.GraphQLConfig({
                config: configOptions,
                filepath: 'virtual-config',
            }, [codeFileLoaderExtension]);
    return graphQLConfig;
}
const codeFileLoaderExtension = api => {
    const { schema, documents } = api.loaders;
    schema.register(new codeFileLoader.CodeFileLoader());
    documents.register(new codeFileLoader.CodeFileLoader());
    return { name: 'graphql-eslint-loaders' };
};

const blocksMap = new Map();
let onDiskConfig;
let onDiskConfigLoaded = false;
const RELEVANT_KEYWORDS = ['gql', 'graphql', 'GraphQL'];
const processor = {
    supportsAutofix: true,
    preprocess(code, filePath) {
        if (!onDiskConfigLoaded) {
            onDiskConfig = loadOnDiskGraphQLConfig(filePath);
            onDiskConfigLoaded = true;
        }
        let keywords = RELEVANT_KEYWORDS;
        const pluckConfig = onDiskConfig === null || onDiskConfig === void 0 ? void 0 : onDiskConfig.getProjectForFile(filePath).extensions.pluckConfig;
        if (pluckConfig) {
            const { modules = [], globalGqlIdentifierName = ['gql', 'graphql'], gqlMagicComment = 'GraphQL', } = pluckConfig;
            keywords = [
                ...new Set([
                    ...modules.map(({ identifier }) => identifier),
                    ...utils.asArray(globalGqlIdentifierName),
                    gqlMagicComment,
                ].filter(Boolean)),
            ];
        }
        if (keywords.every(keyword => !code.includes(keyword))) {
            return [code];
        }
        try {
            const sources = graphqlTagPluck.gqlPluckFromCodeStringSync(filePath, code, {
                skipIndent: true,
                ...pluckConfig,
            });
            const isSvelte = filePath.endsWith('.svelte');
            const blocks = sources.map(item => ({
                filename: 'document.graphql',
                text: item.body,
                lineOffset: item.locationOffset.line - (isSvelte ? 3 : 1),
                // @ts-expect-error -- `index` field exist but show ts error
                offset: item.locationOffset.index + (isSvelte ? -52 : 1),
            }));
            blocksMap.set(filePath, blocks);
            return [...blocks, code /* source code must be provided and be last */];
        }
        catch (_a) {
            // in case of parsing error return code as is
            return [code];
        }
    },
    postprocess(messages, filePath) {
        const blocks = blocksMap.get(filePath) || [];
        for (let i = 0; i < blocks.length; i += 1) {
            const { lineOffset, offset } = blocks[i];
            for (const message of messages[i]) {
                message.line += lineOffset;
                // endLine can not exist if only `loc: { start, column }` was provided to context.report
                if (typeof message.endLine === 'number') {
                    message.endLine += lineOffset;
                }
                if (message.fix) {
                    message.fix.range[0] += offset;
                    message.fix.range[1] += offset;
                }
                for (const suggestion of message.suggestions || []) {
                    suggestion.fix.range[0] += offset;
                    suggestion.fix.range[1] += offset;
                }
            }
        }
        const result = messages.flat();
        // sort eslint/graphql-eslint messages by line/column
        return result.sort((a, b) => a.line - b.line || a.column - b.column);
    },
};

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;
}
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;
}
const logger = {
    // eslint-disable-next-line no-console
    error: (...args) => console.error(chalk.red('error'), '[graphql-eslint]', chalk(...args)),
    // eslint-disable-next-line no-console
    warn: (...args) => console.warn(chalk.yellow('warning'), '[graphql-eslint]', chalk(...args)),
};
const normalizePath = (path) => (path || '').replace(/\\/g, '/');
const VIRTUAL_DOCUMENT_REGEX = /\/\d+_document.graphql$/;
const CWD = process.cwd();
const getTypeName = (node) => 'type' in node ? getTypeName(node.type) : node.name.value;
const TYPES_KINDS = [
    graphql.Kind.OBJECT_TYPE_DEFINITION,
    graphql.Kind.INTERFACE_TYPE_DEFINITION,
    graphql.Kind.ENUM_TYPE_DEFINITION,
    graphql.Kind.SCALAR_TYPE_DEFINITION,
    graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
    graphql.Kind.UNION_TYPE_DEFINITION,
];
const pascalCase = (str) => lowerCase(str)
    .split(' ')
    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
    .join('');
const camelCase = (str) => {
    const result = pascalCase(str);
    return result.charAt(0).toLowerCase() + result.slice(1);
};
const convertCase = (style, str) => {
    switch (style) {
        case 'camelCase':
            return camelCase(str);
        case 'PascalCase':
            return pascalCase(str);
        case 'snake_case':
            return lowerCase(str).replace(/ /g, '_');
        case 'UPPER_CASE':
            return lowerCase(str).replace(/ /g, '_').toUpperCase();
        case 'kebab-case':
            return lowerCase(str).replace(/ /g, '-');
    }
};
function getLocation(start, fieldName = '') {
    const { line, column } = start;
    return {
        start: {
            line,
            column,
        },
        end: {
            line,
            column: column + fieldName.length,
        },
    };
}
const REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 };
const ARRAY_DEFAULT_OPTIONS = {
    type: 'array',
    uniqueItems: true,
    minItems: 1,
    items: {
        type: 'string',
    },
};
const englishJoinWords = words => new Intl.ListFormat('en-US', { type: 'disjunction' }).format(words);

function validateDocument(context, schema = null, documentNode, rule) {
    if (documentNode.definitions.length === 0) {
        return;
    }
    try {
        const validationErrors = schema
            ? graphql.validate(schema, documentNode, [rule])
            : validate.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;
            }
            context.report({
                loc,
                message: error.message,
            });
        }
    }
    catch (e) {
        context.report({
            loc: 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);
        },
    };
    graphql.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 = 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.Kind.DOCUMENT,
                    definitions: [...node.definitions, ...fragmentsToAdd],
                },
            });
        }
    }
    return node;
};
const validationToRule = (ruleId, ruleName, docs, getDocumentNode, schema = []) => {
    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\n> This rule is a wrapper around a \`graphql-js\` validation function.`,
                },
                schema,
            },
            create(context) {
                if (!ruleFn) {
                    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
                            ? requireGraphQLSchemaFromContext(ruleId, context)
                            : null;
                        const documentNode = getDocumentNode
                            ? getDocumentNode({ ruleId, context, node: node.rawNode() })
                            : node.rawNode();
                        validateDocument(context, schema, documentNode, ruleFn);
                    },
                };
            },
        },
    };
};
const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-definitions', 'ExecutableDefinitions', {
    category: 'Operations',
    description: 'A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.',
    requiresSchema: true,
}), validationToRule('fields-on-correct-type', 'FieldsOnCorrectType', {
    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('fragments-on-composite-type', '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('known-argument-names', 'KnownArgumentNames', {
    category: ['Schema', 'Operations'],
    description: 'A GraphQL field is only valid if all supplied arguments are defined by that field.',
    requiresSchema: true,
}), validationToRule('known-directives', 'KnownDirectives', {
    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
              }
            }
          `,
        },
    ],
}, ({ 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 graphql.visit(documentNode, {
        Field: filterDirectives,
        OperationDefinition: filterDirectives,
    });
}, {
    type: 'array',
    maxItems: 1,
    items: {
        type: 'object',
        additionalProperties: false,
        required: ['ignoreClientDirectives'],
        properties: {
            ignoreClientDirectives: ARRAY_DEFAULT_OPTIONS,
        },
    },
}), validationToRule('known-fragment-names', 'KnownFragmentNames', {
    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
            }
          `,
        },
    ],
}, handleMissingFragments), validationToRule('known-type-names', 'KnownTypeNames', {
    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('lone-anonymous-operation', 'LoneAnonymousOperation', {
    category: 'Operations',
    description: 'A GraphQL document is only valid if when it contains an anonymous operation (the query short-hand) that it contains only that one operation definition.',
    requiresSchema: true,
}), validationToRule('lone-schema-definition', 'LoneSchemaDefinition', {
    category: 'Schema',
    description: 'A GraphQL document is only valid if it contains only one schema definition.',
}), validationToRule('no-fragment-cycles', 'NoFragmentCycles', {
    category: 'Operations',
    description: 'A GraphQL fragment is only valid when it does not have cycles in fragments usage.',
    requiresSchema: true,
}), validationToRule('no-undefined-variables', 'NoUndefinedVariables', {
    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,
}, handleMissingFragments), validationToRule('no-unused-fragments', 'NoUnusedFragments', {
    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,
}, ({ ruleId, context, node }) => {
    const siblings = 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.Kind.DOCUMENT,
                definitions: documents,
            });
            const isCurrentFileImportFragment = missingFragments.some(fragment => fragmentDefs.has(fragment));
            if (isCurrentFileImportFragment) {
                return getParentNode(filePath, {
                    kind: graphql.Kind.DOCUMENT,
                    definitions: [...node.definitions, ...documents],
                });
            }
        }
        return node;
    };
    return getParentNode(context.getFilename(), node);
}), validationToRule('no-unused-variables', 'NoUnusedVariables', {
    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,
}, handleMissingFragments), validationToRule('overlapping-fields-can-be-merged', '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('possible-fragment-spread', '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('possible-type-extension', 'PossibleTypeExtensions', {
    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('provided-required-arguments', '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('scalar-leafs', 'ScalarLeafs', {
    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('one-field-subscriptions', 'SingleFieldSubscriptions', {
    category: 'Operations',
    description: 'A GraphQL subscription is valid only if it contains a single root field.',
    requiresSchema: true,
}), validationToRule('unique-argument-names', 'UniqueArgumentNames', {
    category: 'Operations',
    description: 'A GraphQL field or directive is only valid if all supplied arguments are uniquely named.',
    requiresSchema: true,
}), validationToRule('unique-directive-names', 'UniqueDirectiveNames', {
    category: 'Schema',
    description: 'A GraphQL document is only valid if all defined directives have unique names.',
}), validationToRule('unique-directive-names-per-location', '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('unique-enum-value-names', 'UniqueEnumValueNames', {
    category: 'Schema',
    description: 'A GraphQL enum type is only valid if all its values are uniquely named.',
    recommended: false,
    isDisabledForAllConfig: true,
}), validationToRule('unique-field-definition-names', 'UniqueFieldDefinitionNames', {
    category: 'Schema',
    description: 'A GraphQL complex type is only valid if all its fields are uniquely named.',
}), validationToRule('unique-input-field-names', 'UniqueInputFieldNames', {
    category: 'Operations',
    description: 'A GraphQL input object value is only valid if all supplied fields are uniquely named.',
}), validationToRule('unique-operation-types', 'UniqueOperationTypes', {
    category: 'Schema',
    description: 'A GraphQL document is only valid if it has only one type per operation.',
}), validationToRule('unique-type-names', 'UniqueTypeNames', {
    category: 'Schema',
    description: 'A GraphQL document is only valid if all defined types have unique names.',
}), validationToRule('unique-variable-names', 'UniqueVariableNames', {
    category: 'Operations',
    description: 'A GraphQL operation is only valid if all its variables are uniquely named.',
    requiresSchema: true,
}), validationToRule('value-literals-of-correct-type', 'ValuesOfCorrectType', {
    category: 'Operations',
    description: 'A GraphQL document is only valid if all value literals are of the type expected at their position.',
    requiresSchema: true,
}), validationToRule('variables-are-input-types', '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('variables-in-allowed-position', 'VariablesInAllowedPosition', {
    category: 'Operations',
    description: 'Variables passed to field arguments conform to type.',
    requiresSchema: true,
}));

const RULE_ID = 'alphabetize';
const fieldsEnum = [
    graphql.Kind.OBJECT_TYPE_DEFINITION,
    graphql.Kind.INTERFACE_TYPE_DEFINITION,
    graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
];
const valuesEnum = [graphql.Kind.ENUM_TYPE_DEFINITION];
const selectionsEnum = [
    graphql.Kind.OPERATION_DEFINITION,
    graphql.Kind.FRAGMENT_DEFINITION,
];
const variablesEnum = [graphql.Kind.OPERATION_DEFINITION];
const argumentsEnum = [
    graphql.Kind.FIELD_DEFINITION,
    graphql.Kind.FIELD,
    graphql.Kind.DIRECTIVE_DEFINITION,
    graphql.Kind.DIRECTIVE,
];
const rule = {
    meta: {
        type: 'suggestion',
        fixable: 'code',
        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`,
            examples: [
                {
                    title: 'Incorrect',
                    usage: [{ fields: [graphql.Kind.OBJECT_TYPE_DEFINITION] }],
                    code: /* GraphQL */ `
            type User {
              password: String
              firstName: String! # should be before "password"
              age: Int # should be before "firstName"
              lastName: String!
            }
          `,
                },
                {
                    title: 'Correct',
                    usage: [{ fields: [graphql.Kind.OBJECT_TYPE_DEFINITION] }],
                    code: /* GraphQL */ `
            type User {
              age: Int
              firstName: String!
              lastName: String!
              password: String
            }
          `,
                },
                {
                    title: 'Incorrect',
                    usage: [{ values: [graphql.Kind.ENUM_TYPE_DEFINITION] }],
                    code: /* GraphQL */ `
            enum Role {
              SUPER_ADMIN
              ADMIN # should be before "SUPER_ADMIN"
              USER
              GOD # should be before "USER"
            }
          `,
                },
                {
                    title: 'Correct',
                    usage: [{ values: [graphql.Kind.ENUM_TYPE_DEFINITION] }],
                    code: /* GraphQL */ `
            enum Role {
              ADMIN
              GOD
              SUPER_ADMIN
              USER
            }
          `,
                },
                {
                    title: 'Incorrect',
                    usage: [{ selections: [graphql.Kind.OPERATION_DEFINITION] }],
                    code: /* GraphQL */ `
            query {
              me {
                firstName
                lastName
                email # should be before "lastName"
              }
            }
          `,
                },
                {
                    title: 'Correct',
                    usage: [{ selections: [graphql.Kind.OPERATION_DEFINITION] }],
                    code: /* GraphQL */ `
            query {
              me {
                email
                firstName
                lastName
              }
            }
          `,
                },
            ],
            configOptions: {
                schema: [
                    {
                        fields: fieldsEnum,
                        values: valuesEnum,
                        arguments: argumentsEnum,
                        // TODO: add in graphql-eslint v4
                        // definitions: true,
                    },
                ],
                operations: [
                    {
                        selections: selectionsEnum,
                        variables: variablesEnum,
                        arguments: [graphql.Kind.FIELD, graphql.Kind.DIRECTIVE],
                    },
                ],
            },
        },
        messages: {
            [RULE_ID]: '`{{ currName }}` should be before {{ prevName }}.',
        },
        schema: {
            type: 'array',
            minItems: 1,
            maxItems: 1,
            items: {
                type: 'object',
                additionalProperties: false,
                minProperties: 1,
                properties: {
                    fields: {
                        ...ARRAY_DEFAULT_OPTIONS,
                        items: {
                            enum: fieldsEnum,
                        },
                        description: 'Fields of `type`, `interface`, and `input`.',
                    },
                    values: {
                        ...ARRAY_DEFAULT_OPTIONS,
                        items: {
                            enum: valuesEnum,
                        },
                        description: 'Values of `enum`.',
                    },
                    selections: {
                        ...ARRAY_DEFAULT_OPTIONS,
                        items: {
                            enum: selectionsEnum,
                        },
                        description: 'Selections of `fragment` and operations `query`, `mutation` and `subscription`.',
                    },
                    variables: {
                        ...ARRAY_DEFAULT_OPTIONS,
                        items: {
                            enum: variablesEnum,
                        },
                        description: 'Variables of operations `query`, `mutation` and `subscription`.',
                    },
                    arguments: {
                        ...ARRAY_DEFAULT_OPTIONS,
                        items: {
                            enum: argumentsEnum,
                        },
                        description: 'Arguments of fields and directives.',
                    },
                    definitions: {
                        type: 'boolean',
                        description: 'Definitions – `type`, `interface`, `enum`, `scalar`, `input`, `union` and `directive`.',
                        default: false,
                    },
                },
            },
        },
    },
    create(context) {
        var _a, _b, _c, _d, _e;
        const sourceCode = context.getSourceCode();
        function isNodeAndCommentOnSameLine(node, comment) {
            return node.loc.end.line === comment.loc.start.line;
        }
        function getBeforeComments(node) {
            const commentsBefore = sourceCode.getCommentsBefore(node);
            if (commentsBefore.length === 0) {
                return [];
            }
            const tokenBefore = sourceCode.getTokenBefore(node);
            if (tokenBefore) {
                return commentsBefore.filter(comment => !isNodeAndCommentOnSameLine(tokenBefore, comment));
            }
            const filteredComments = [];
            const nodeLine = node.loc.start.line;
            // Break on comment that not attached to node
            for (let i = commentsBefore.length - 1; i >= 0; i -= 1) {
                const comment = commentsBefore[i];
                if (nodeLine - comment.loc.start.line - filteredComments.length > 1) {
                    break;
                }
                filteredComments.unshift(comment);
            }
            return filteredComments;
        }
        function getRangeWithComments(node) {
            if (node.kind === graphql.Kind.VARIABLE) {
                node = node.parent;
            }
            const [firstBeforeComment] = getBeforeComments(node);
            const [firstAfterComment] = sourceCode.getCommentsAfter(node);
            const from = firstBeforeComment || node;
            const to = firstAfterComment && isNodeAndCommentOnSameLine(node, firstAfterComment)
                ? firstAfterComment
                : node;
            return [from.range[0], to.range[1]];
        }
        function checkNodes(nodes) {
            var _a, _b, _c, _d;
            // Starts from 1, ignore nodes.length <= 1
            for (let i = 1; i < nodes.length; i += 1) {
                const currNode = nodes[i];
                const currName = ('alias' in currNode && ((_a = currNode.alias) === null || _a === void 0 ? void 0 : _a.value)) ||
                    ('name' in currNode && ((_b = currNode.name) === null || _b === void 0 ? void 0 : _b.value));
                if (!currName) {
                    // we don't move unnamed current nodes
                    continue;
                }
                const prevNode = nodes[i - 1];
                const prevName = ('alias' in prevNode && ((_c = prevNode.alias) === null || _c === void 0 ? void 0 : _c.value)) ||
                    ('name' in prevNode && ((_d = prevNode.name) === null || _d === void 0 ? void 0 : _d.value));
                if (prevName) {
                    // Compare with lexicographic order
                    const compareResult = prevName.localeCompare(currName);
                    const shouldSort = compareResult === 1;
                    if (!shouldSort) {
                        const isSameName = compareResult === 0;
                        if (!isSameName ||
                            !prevNode.kind.endsWith('Extension') ||
                            currNode.kind.endsWith('Extension')) {
                            continue;
                        }
                    }
                }
                context.report({
                    node: ('alias' in currNode && currNode.alias) || currNode.name,
                    messageId: RULE_ID,
                    data: {
                        currName,
                        prevName: prevName ? `\`${prevName}\`` : lowerCase(prevNode.kind),
                    },
                    *fix(fixer) {
                        const prevRange = getRangeWithComments(prevNode);
                        const currRange = getRangeWithComments(currNode);
                        yield fixer.replaceTextRange(prevRange, sourceCode.getText({ range: currRange }));
                        yield fixer.replaceTextRange(currRange, sourceCode.getText({ range: prevRange }));
                    },
                });
            }
        }
        const opts = context.options[0];
        const fields = new Set((_a = opts.fields) !== null && _a !== void 0 ? _a : []);
        const listeners = {};
        const kinds = [
            fields.has(graphql.Kind.OBJECT_TYPE_DEFINITION) && [
                graphql.Kind.OBJECT_TYPE_DEFINITION,
                graphql.Kind.OBJECT_TYPE_EXTENSION,
            ],
            fields.has(graphql.Kind.INTERFACE_TYPE_DEFINITION) && [
                graphql.Kind.INTERFACE_TYPE_DEFINITION,
                graphql.Kind.INTERFACE_TYPE_EXTENSION,
            ],
            fields.has(graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION) && [
                graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
                graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION,
            ],
        ]
            .filter(Boolean)
            .flat();
        const fieldsSelector = kinds.join(',');
        const hasEnumValues = ((_b = opts.values) === null || _b === void 0 ? void 0 : _b[0]) === graphql.Kind.ENUM_TYPE_DEFINITION;
        const selectionsSelector = (_c = opts.selections) === null || _c === void 0 ? void 0 : _c.join(',');
        const hasVariables = ((_d = opts.variables) === null || _d === void 0 ? void 0 : _d[0]) === graphql.Kind.OPERATION_DEFINITION;
        const argumentsSelector = (_e = opts.arguments) === null || _e === void 0 ? void 0 : _e.join(',');
        if (fieldsSelector) {
            listeners[fieldsSelector] = (node) => {
                checkNodes(node.fields);
            };
        }
        if (hasEnumValues) {
            const enumValuesSelector = [graphql.Kind.ENUM_TYPE_DEFINITION, graphql.Kind.ENUM_TYPE_EXTENSION].join(',');
            listeners[enumValuesSelector] = (node) => {
                checkNodes(node.values);
            };
        }
        if (selectionsSelector) {
            listeners[`:matches(${selectionsSelector}) SelectionSet`] = (node) => {
                checkNodes(node.selections);
            };
        }
        if (hasVariables) {
            listeners.OperationDefinition = (node) => {
                checkNodes(node.variableDefinitions.map(varDef => varDef.variable));
            };
        }
        if (argumentsSelector) {
            listeners[argumentsSelector] = (node) => {
                checkNodes(node.arguments);
            };
        }
        if (opts.definitions) {
            listeners.Document = node => {
                checkNodes(node.definitions);
            };
        }
        return listeners;
    },
};

const rule$1 = {
    meta: {
        type: 'suggestion',
        hasSuggestions: true,
        docs: {
            examples: [
                {
                    title: 'Incorrect',
                    usage: [{ style: 'inline' }],
                    code: /* GraphQL */ `
            """ Description """
            type someTypeName {
              # ...
            }
          `,
                },
                {
                    title: 'Correct',
                    usage: [{ style: 'inline' }],
                    code: /* GraphQL */ `
            " Description "
            type someTypeName {
              # ...
            }
          `,
                },
            ],
            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',
            recommended: true,
        },
        schema: [
            {
                type: 'object',
                additionalProperties: false,
                properties: {
                    style: {
                        enum: ['block', 'inline'],
                        default: 'block',
                    },
                },
            },
        ],
    },
    create(context) {
        const { style = 'block' } = context.options[0] || {};
        const isBlock = style === 'block';
        return {
            [`.description[type=StringValue][block!=${isBlock}]`](node) {
                context.report({
                    loc: isBlock ? node.loc : node.loc.start,
                    message: `Unexpected ${isBlock ? 'inline' : 'block'} description.`,
                    suggest: [
                        {
                            desc: `Change to ${isBlock ? 'block' : 'inline'} style description`,
                            fix(fixer) {
                                const sourceCode = context.getSourceCode();
                                const originalText = sourceCode.getText(node);
                                const newText = isBlock
                                    ? originalText.replace(/(^")|("$)/g, '"""')
                                    : originalText.replace(/(^""")|("""$)/g, '"').replace(/\s+/g, ' ');
                                return fixer.replaceText(node, newText);
                            },
                        },
                    ],
                });
            },
        };
    },
};

const isObjectType = (node) => [graphql.Kind.OBJECT_TYPE_DEFINITION, graphql.Kind.OBJECT_TYPE_EXTENSION].includes(node.type);
const isQueryType = (node) => isObjectType(node) && node.name.value === 'Query';
const isMutationType = (node) => isObjectType(node) && node.name.value === 'Mutation';
const rule$2 = {
    meta: {
        type: 'suggestion',
        hasSuggestions: true,
        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',
            examples: [
                {
                    title: 'Incorrect',
                    usage: [{ checkInputType: true }],
                    code: /* GraphQL */ `
            type Mutation {
              SetMessage(message: InputMessage): String
            }
          `,
                },
                {
                    title: 'Correct (with checkInputType)',
                    usage: [{ checkInputType: true }],
                    code: /* GraphQL */ `
            type Mutation {
              SetMessage(input: SetMessageInput): String
            }
          `,
                },
                {
                    title: 'Correct (without checkInputType)',
                    usage: [{ checkInputType: false }],
                    code: /* GraphQL */ `
            type Mutation {
              SetMessage(input: AnyInputTypeName): String
            }
          `,
                },
            ],
        },
        schema: [
            {
                type: 'object',
                additionalProperties: false,
                properties: {
                    checkInputType: {
                        type: 'boolean',
                        default: false,
                        description: 'Check that the input type name follows the convention <mutationName>Input',
                    },
                    caseSensitiveInputType: {
                        type: 'boolean',
                        default: true,
                        description: 'Allow for case discrepancies in the input type name',
                    },
                    checkQueries: {
                        type: 'boolean',
                        default: false,
                        description: 'Apply the rule to Queries',
                    },
                    checkMutations: {
                        type: 'boolean',
                        default: true,
                        description: 'Apply the rule to Mutations',
                    },
                },
            },
        ],
    },
    create(context) {
        const options = {
            checkInputType: false,
            caseSensitiveInputType: true,
            checkQueries: false,
            checkMutations: true,
            ...context.options[0],
        };
        const shouldCheckType = node => (options.checkMutations && isMutationType(node)) ||
            (options.checkQueries && isQueryType(node));
        const listeners = {
            'FieldDefinition > InputValueDefinition[name.value!=input] > Name'(node) {
                if (shouldCheckType(node.parent.parent.parent)) {
                    const inputName = node.value;
                    context.report({
                        node,
                        message: `Input \`${inputName}\` should be called \`input\`.`,
                        suggest: [
                            {
                                desc: 'Rename to `input`',
                                fix: fixer => fixer.replaceText(node, 'input'),
                            },
                        ],
                    });
                }
            },
        };
        if (options.checkInputType) {
            listeners['FieldDefinition > InputValueDefinition NamedType'] = (node) => {
                const findInputType = item => {
                    let currentNode = item;
                    while (currentNode.type !== graphql.Kind.INPUT_VALUE_DEFINITION) {
                        currentNode = currentNode.parent;
                    }
                    return currentNode;
                };
                const inputValueNode = findInputType(node);
                if (shouldCheckType(inputValueNode.parent.parent)) {
                    const mutationName = `${inputValueNode.parent.name.value}Input`;
                    const name = node.name.value;
                    if ((options.caseSensitiveInputType && node.name.value !== mutationName) ||
                        name.toLowerCase() !== mutationName.toLowerCase()) {
                        context.report({
                            node: node.name,
                            message: `Input type \`${name}\` name should be \`${mutationName}\`.`,
                            suggest: [
                                {
                                    desc: `Rename to \`${mutationName}\``,
                                    fix: fixer => fixer.replaceText(node, mutationName),
                                },
                            ],
                        });
                    }
                }
            };
        }
        return listeners;
    },
};

const MATCH_EXTENSION = 'MATCH_EXTENSION';
const MATCH_STYLE = 'MATCH_STYLE';
const ACCEPTED_EXTENSIONS = ['.gql', '.graphql'];
const CASE_STYLES = [
    'camelCase',
    'PascalCase',
    'snake_case',
    'UPPER_CASE',
    'kebab-case',
    'matchDocumentStyle',
];
const schemaOption = {
    oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
};
const rule$3 = {
    meta: {
        type: 'suggestion',
        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',
            examples: [
                {
                    title: 'Correct',
                    usage: [{ fileExtension: '.gql' }],
                    code: /* GraphQL */ `
            # user.gql
            type User {
              id: ID!
            }
          `,
                },
                {
                    title: 'Correct',
                    usage: [{ query: 'snake_case' }],
                    code: /* GraphQL */ `
            # user_by_id.gql
            query UserById {
              userById(id: 5) {
                id
                name
                fullName
              }
            }
          `,
                },
                {
                    title: 'Correct',
                    usage: [{ fragment: { style: 'kebab-case', suffix: '.fragment' } }],
                    code: /* GraphQL */ `
            # user-fields.fragment.gql
            fragment user_fields on User {
              id
              email
            }
          `,
                },
                {
                    title: 'Correct',
                    usage: [{ mutation: { style: 'PascalCase', suffix: 'Mutation' } }],
                    code: /* GraphQL */ `
            # DeleteUserMutation.gql
            mutation DELETE_USER {
              deleteUser(id: 5)
            }
          `,
                },
                {
                    title: 'Incorrect',
                    usage: [{ fileExtension: '.graphql' }],
                    code: /* GraphQL */ `
            # post.gql
            type Post {
              id: ID!
            }
          `,
                },
                {
                    title: 'Incorrect',
                    usage: [{ query: 'PascalCase' }],
                    code: /* GraphQL */ `
            # user-by-id.gql
            query UserById {
              userById(id: 5) {
                id
                name
                fullName
              }
            }
          `,
                },
            ],
            configOptions: [
                {
                    query: 'kebab-case',
                    mutation: 'kebab-case',
                    subscription: 'kebab-case',
                    fragment: 'kebab-case',
                },
            ],
        },
        messages: {
            [MATCH_EXTENSION]: 'File extension "{{ fileExtension }}" don\'t match extension "{{ expectedFileExtension }}"',
            [MATCH_STYLE]: 'Unexpected filename "{{ filename }}". Rename it to "{{ expectedFilename }}"',
        },
        schema: {
            definitions: {
                asString: {
                    enum: CASE_STYLES,
                    description: `One of: ${CASE_STYLES.map(t => `\`${t}\``).join(', ')}`,
                },
                asObject: {
                    type: 'object',
                    additionalProperties: false,
                    minProperties: 1,
                    properties: {
                        style: { enum: CASE_STYLES },
                        suffix: { type: 'string' },
                    },
                },
            },
            type: 'array',
            minItems: 1,
            maxItems: 1,
            items: {
                type: 'object',
                additionalProperties: false,
                minProperties: 1,
                properties: {
                    fileExtension: { enum: ACCEPTED_EXTENSIONS },
                    query: schemaOption,
                    mutation: schemaOption,
                    subscription: schemaOption,