@graphql-eslint/eslint-plugin 4.0.0-alpha-20220821140530-e968cfc → 4.0.0-alpha-20230801163310-8bc4340

package/esm/parser.js

@@ -0,0 +1,70 @@
+import "./chunk-BMTV3EA2.js";
+import { parseGraphQLSDL } from "@graphql-tools/utils";
+import debugFactory from "debug";
+import { buildSchema, GraphQLError } from "graphql";
+import { convertToESTree, extractComments, extractTokens } from "./estree-converter/index.js";
+import { loadGraphQLConfig } from "./graphql-config.js";
+import { getSchema } from "./schema.js";
+import { getSiblings } from "./siblings.js";
+import { CWD, VIRTUAL_DOCUMENT_REGEX } from "./utils.js";
+const debug = debugFactory("graphql-eslint:parser");
+debug("cwd %o", CWD);
+function parseForESLint(code, options) {
+  var _a, _b;
+  try {
+    const { filePath } = options;
+    options.documents || (options.documents = options.operations);
+    const { document } = parseGraphQLSDL(filePath, code, {
+      ...options.graphQLParserOptions,
+      noLocation: false
+    });
+    const gqlConfig = loadGraphQLConfig(options);
+    const realFilepath = filePath.replace(VIRTUAL_DOCUMENT_REGEX, "");
+    const project = gqlConfig.getProjectForFile(realFilepath);
+    let schema = null;
+    try {
+      schema = project ? getSchema(project, options.schemaOptions) : typeof options.schema === "string" ? buildSchema(options.schema) : null;
+    } catch (error) {
+      if (error instanceof Error) {
+        error.message = `Error while loading schema: ${error.message}`;
+      }
+      throw error;
+    }
+    const rootTree = convertToESTree(document, schema);
+    return {
+      services: {
+        schema,
+        siblingOperations: getSiblings(project, options.documents)
+      },
+      ast: {
+        comments: extractComments(document.loc),
+        tokens: extractTokens(filePath, code),
+        loc: rootTree.loc,
+        range: rootTree.range,
+        type: "Program",
+        sourceType: "script",
+        body: [rootTree]
+      }
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      error.message = `[graphql-eslint] ${error.message}`;
+    }
+    if (error instanceof GraphQLError) {
+      const location = (_a = error.locations) == null ? void 0 : _a[0];
+      const eslintError = {
+        index: (_b = error.positions) == null ? void 0 : _b[0],
+        ...location && {
+          lineNumber: location.line,
+          column: location.column - 1
+        },
+        message: error.message
+      };
+      throw eslintError;
+    }
+    throw error;
+  }
+}
+export {
+  parseForESLint
+};

package/esm/processor.d.mts

@@ -0,0 +1,9 @@
+import { Linter } from 'eslint';
+
+type Block = Linter.ProcessorFile & {
+    lineOffset: number;
+    offset: number;
+};
+declare const processor: Linter.Processor<Block | string>;
+
+export { Block, processor };

package/esm/processor.js

@@ -0,0 +1,106 @@
+import "./chunk-BMTV3EA2.js";
+import { relative } from "path";
+import {
+  gqlPluckFromCodeStringSync
+} from "@graphql-tools/graphql-tag-pluck";
+import { asArray } from "@graphql-tools/utils";
+import { loadOnDiskGraphQLConfig } from "./graphql-config.js";
+import { CWD, REPORT_ON_FIRST_CHARACTER, truthy } from "./utils.js";
+const blocksMap = /* @__PURE__ */ 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 ? void 0 : onDiskConfig.getProjectForFile(filePath).extensions.pluckConfig;
+    if (pluckConfig) {
+      const {
+        modules = [],
+        globalGqlIdentifierName = ["gql", "graphql"],
+        gqlMagicComment = "GraphQL"
+      } = pluckConfig;
+      keywords = [
+        ...new Set(
+          [
+            ...modules.map(({ identifier }) => identifier),
+            ...asArray(globalGqlIdentifierName),
+            gqlMagicComment
+          ].filter(truthy)
+        )
+      ];
+    }
+    if (keywords.every((keyword) => !code.includes(keyword))) {
+      return [code];
+    }
+    try {
+      const sources = gqlPluckFromCodeStringSync(filePath, code, {
+        skipIndent: true,
+        ...pluckConfig
+      });
+      const blocks = sources.map((item) => ({
+        filename: "document.graphql",
+        text: item.body,
+        lineOffset: item.locationOffset.line - 1,
+        // @ts-expect-error -- `index` field exist but show ts error
+        offset: item.locationOffset.index + 1
+      }));
+      blocksMap.set(filePath, blocks);
+      return [
+        ...blocks,
+        code
+        /* source code must be provided and be last */
+      ];
+    } catch (error) {
+      if (error instanceof Error) {
+        error.message = `[graphql-eslint] Error while preprocessing "${relative(
+          CWD,
+          filePath
+        )}" file
+
+${error.message}`;
+      }
+      console.error(error);
+      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] || []) {
+        const isVueOrSvelte = /\.(vue|svelte)$/.test(filePath);
+        if (isVueOrSvelte) {
+          delete message.endLine;
+          delete message.endColumn;
+          delete message.fix;
+          delete message.suggestions;
+          Object.assign(message, REPORT_ON_FIRST_CHARACTER);
+          continue;
+        }
+        message.line += lineOffset;
+        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 || []) {
+          const [start, end] = suggestion.fix.range;
+          suggestion.fix.range = [start + offset, end + offset];
+        }
+      }
+    }
+    const result = messages.flat();
+    return result.sort((a, b) => a.line - b.line || a.column - b.column);
+  }
+};
+export {
+  processor
+};

package/esm/rules/alphabetize.d.mts

@@ -0,0 +1,84 @@
+import { FromSchema } from 'json-schema-to-ts';
+import { f as GraphQLESLintRule } from '../types-ace77d86.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.mjs';
+
+declare const schema: {
+    readonly type: "array";
+    readonly minItems: 1;
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly fields: {
+                readonly items: {
+                    readonly enum: ("ObjectTypeDefinition" | "InterfaceTypeDefinition" | "InputObjectTypeDefinition")[];
+                };
+                readonly description: "Fields of `type`, `interface`, and `input`.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+            readonly values: {
+                readonly items: {
+                    readonly enum: ["EnumTypeDefinition"];
+                };
+                readonly description: "Values of `enum`.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+            readonly selections: {
+                readonly items: {
+                    readonly enum: ("OperationDefinition" | "FragmentDefinition")[];
+                };
+                readonly description: "Selections of `fragment` and operations `query`, `mutation` and `subscription`.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+            readonly variables: {
+                readonly items: {
+                    readonly enum: ["OperationDefinition"];
+                };
+                readonly description: "Variables of operations `query`, `mutation` and `subscription`.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+            readonly arguments: {
+                readonly items: {
+                    readonly enum: ("Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition")[];
+                };
+                readonly description: "Arguments of fields and directives.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+            readonly definitions: {
+                readonly type: "boolean";
+                readonly description: "Definitions – `type`, `interface`, `enum`, `scalar`, `input`, `union` and `directive`.";
+                readonly default: false;
+            };
+            readonly groups: {
+                readonly minItems: 2;
+                readonly description: "Custom order group. Example: `['id', '*', 'createdAt', 'updatedAt']` where `*` says for everything else.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };

package/esm/rules/alphabetize.js

@@ -0,0 +1,364 @@
+import "../chunk-BMTV3EA2.js";
+import {
+  Kind
+} from "graphql";
+import lowerCase from "lodash.lowercase";
+import { ARRAY_DEFAULT_OPTIONS, displayNodeName, truthy } from "../utils.js";
+const RULE_ID = "alphabetize";
+const fieldsEnum = [
+  Kind.OBJECT_TYPE_DEFINITION,
+  Kind.INTERFACE_TYPE_DEFINITION,
+  Kind.INPUT_OBJECT_TYPE_DEFINITION
+];
+const valuesEnum = [Kind.ENUM_TYPE_DEFINITION];
+const selectionsEnum = [
+  Kind.OPERATION_DEFINITION,
+  Kind.FRAGMENT_DEFINITION
+];
+const variablesEnum = [Kind.OPERATION_DEFINITION];
+const argumentsEnum = [
+  Kind.FIELD_DEFINITION,
+  Kind.FIELD,
+  Kind.DIRECTIVE_DEFINITION,
+  Kind.DIRECTIVE
+];
+const 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 \u2013 `type`, `interface`, `enum`, `scalar`, `input`, `union` and `directive`.",
+        default: false
+      },
+      groups: {
+        ...ARRAY_DEFAULT_OPTIONS,
+        minItems: 2,
+        description: "Custom order group. Example: `['id', '*', 'createdAt', 'updatedAt']` where `*` says for everything else."
+      }
+    }
+  }
+};
+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://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          usage: [{ fields: [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: [Kind.OBJECT_TYPE_DEFINITION] }],
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              age: Int
+              firstName: String!
+              lastName: String!
+              password: String
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          usage: [{ values: [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: [Kind.ENUM_TYPE_DEFINITION] }],
+          code: (
+            /* GraphQL */
+            `
+            enum Role {
+              ADMIN
+              GOD
+              SUPER_ADMIN
+              USER
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          usage: [{ selections: [Kind.OPERATION_DEFINITION] }],
+          code: (
+            /* GraphQL */
+            `
+            query {
+              me {
+                firstName
+                lastName
+                email # should be before "lastName"
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ selections: [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,
+            // groups: ['id', '*', 'createdAt', 'updatedAt']
+          }
+        ],
+        operations: [
+          {
+            selections: selectionsEnum,
+            variables: variablesEnum,
+            arguments: [Kind.FIELD, Kind.DIRECTIVE]
+          }
+        ]
+      }
+    },
+    messages: {
+      [RULE_ID]: "{{ currNode }} should be before {{ prevNode }}"
+    },
+    schema
+  },
+  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;
+      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 === 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 _a2, _b2, _c2, _d2;
+      for (let i = 1; i < nodes.length; i += 1) {
+        const currNode = nodes[i];
+        const currName = "alias" in currNode && ((_a2 = currNode.alias) == null ? void 0 : _a2.value) || "name" in currNode && ((_b2 = currNode.name) == null ? void 0 : _b2.value);
+        if (!currName) {
+          continue;
+        }
+        const prevNode = nodes[i - 1];
+        const prevName = "alias" in prevNode && ((_c2 = prevNode.alias) == null ? void 0 : _c2.value) || "name" in prevNode && ((_d2 = prevNode.name) == null ? void 0 : _d2.value);
+        if (prevName) {
+          const compareResult = prevName.localeCompare(currName);
+          const { groups } = opts;
+          let shouldSortByGroup = false;
+          if (groups == null ? void 0 : groups.length) {
+            if (!groups.includes("*")) {
+              throw new Error("`groups` option should contain `*` string.");
+            }
+            let indexForPrev = groups.indexOf(prevName);
+            if (indexForPrev === -1)
+              indexForPrev = groups.indexOf("*");
+            let indexForCurr = groups.indexOf(currName);
+            if (indexForCurr === -1)
+              indexForCurr = groups.indexOf("*");
+            shouldSortByGroup = indexForPrev - indexForCurr > 0;
+            if (indexForPrev < indexForCurr) {
+              continue;
+            }
+          }
+          const shouldSort = compareResult === 1;
+          if (!shouldSortByGroup && !shouldSort) {
+            const isSameName = compareResult === 0;
+            if (!isSameName || !prevNode.kind.endsWith("Extension") || currNode.kind.endsWith("Extension")) {
+              continue;
+            }
+          }
+        }
+        context.report({
+          // @ts-expect-error can't be undefined
+          node: "alias" in currNode && currNode.alias || currNode.name,
+          messageId: RULE_ID,
+          data: {
+            currNode: displayNodeName(currNode),
+            prevNode: prevName ? displayNodeName(prevNode) : 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 : []);
+    const listeners = {};
+    const kinds = [
+      fields.has(Kind.OBJECT_TYPE_DEFINITION) && [
+        Kind.OBJECT_TYPE_DEFINITION,
+        Kind.OBJECT_TYPE_EXTENSION
+      ],
+      fields.has(Kind.INTERFACE_TYPE_DEFINITION) && [
+        Kind.INTERFACE_TYPE_DEFINITION,
+        Kind.INTERFACE_TYPE_EXTENSION
+      ],
+      fields.has(Kind.INPUT_OBJECT_TYPE_DEFINITION) && [
+        Kind.INPUT_OBJECT_TYPE_DEFINITION,
+        Kind.INPUT_OBJECT_TYPE_EXTENSION
+      ]
+    ].filter(truthy).flat();
+    const fieldsSelector = kinds.join(",");
+    const hasEnumValues = ((_b = opts.values) == null ? void 0 : _b[0]) === Kind.ENUM_TYPE_DEFINITION;
+    const selectionsSelector = (_c = opts.selections) == null ? void 0 : _c.join(",");
+    const hasVariables = ((_d = opts.variables) == null ? void 0 : _d[0]) === Kind.OPERATION_DEFINITION;
+    const argumentsSelector = (_e = opts.arguments) == null ? void 0 : _e.join(",");
+    if (fieldsSelector) {
+      listeners[fieldsSelector] = (node) => {
+        checkNodes(node.fields);
+      };
+    }
+    if (hasEnumValues) {
+      const enumValuesSelector = [Kind.ENUM_TYPE_DEFINITION, 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) => {
+        var _a2;
+        checkNodes((_a2 = node.variableDefinitions) == null ? void 0 : _a2.map((varDef) => varDef.variable));
+      };
+    }
+    if (argumentsSelector) {
+      listeners[argumentsSelector] = (node) => {
+        checkNodes(node.arguments);
+      };
+    }
+    if (opts.definitions) {
+      listeners.Document = (node) => {
+        checkNodes(node.definitions);
+      };
+    }
+    return listeners;
+  }
+};
+export {
+  rule
+};

package/esm/rules/description-style.d.mts

@@ -0,0 +1,28 @@
+import { FromSchema } from 'json-schema-to-ts';
+import { f as GraphQLESLintRule } from '../types-ace77d86.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.mjs';
+
+declare const schema: {
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly style: {
+                readonly enum: readonly ["block", "inline"];
+                readonly default: "block";
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };