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

package/cjs/parser.js

@@ -0,0 +1,103 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parser_exports = {};
+__export(parser_exports, {
+  parseForESLint: () => parseForESLint
+});
+module.exports = __toCommonJS(parser_exports);
+var import_utils = require("@graphql-tools/utils");
+var import_debug = __toESM(require("debug"));
+var import_graphql = require("graphql");
+var import_estree_converter = require("./estree-converter/index.js");
+var import_graphql_config = require("./graphql-config.js");
+var import_schema = require("./schema.js");
+var import_siblings = require("./siblings.js");
+var import_utils2 = require("./utils.js");
+const debug = (0, import_debug.default)("graphql-eslint:parser");
+debug("cwd %o", import_utils2.CWD);
+function parseForESLint(code, options) {
+  var _a, _b;
+  try {
+    const { filePath } = options;
+    options.documents || (options.documents = options.operations);
+    const { document } = (0, import_utils.parseGraphQLSDL)(filePath, code, {
+      ...options.graphQLParserOptions,
+      noLocation: false
+    });
+    const gqlConfig = (0, import_graphql_config.loadGraphQLConfig)(options);
+    const realFilepath = filePath.replace(import_utils2.VIRTUAL_DOCUMENT_REGEX, "");
+    const project = gqlConfig.getProjectForFile(realFilepath);
+    let schema = null;
+    try {
+      schema = project ? (0, import_schema.getSchema)(project, options.schemaOptions) : typeof options.schema === "string" ? (0, import_graphql.buildSchema)(options.schema) : null;
+    } catch (error) {
+      if (error instanceof Error) {
+        error.message = `Error while loading schema: ${error.message}`;
+      }
+      throw error;
+    }
+    const rootTree = (0, import_estree_converter.convertToESTree)(document, schema);
+    return {
+      services: {
+        schema,
+        siblingOperations: (0, import_siblings.getSiblings)(project, options.documents)
+      },
+      ast: {
+        comments: (0, import_estree_converter.extractComments)(document.loc),
+        tokens: (0, import_estree_converter.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 import_graphql.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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseForESLint
+});

package/cjs/processor.d.ts

@@ -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/cjs/processor.js

@@ -0,0 +1,127 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var processor_exports = {};
+__export(processor_exports, {
+  processor: () => processor
+});
+module.exports = __toCommonJS(processor_exports);
+var import_path = require("path");
+var import_graphql_tag_pluck = require("@graphql-tools/graphql-tag-pluck");
+var import_utils = require("@graphql-tools/utils");
+var import_graphql_config2 = require("./graphql-config.js");
+var import_utils2 = require("./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 = (0, import_graphql_config2.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),
+            ...(0, import_utils.asArray)(globalGqlIdentifierName),
+            gqlMagicComment
+          ].filter(import_utils2.truthy)
+        )
+      ];
+    }
+    if (keywords.every((keyword) => !code.includes(keyword))) {
+      return [code];
+    }
+    try {
+      const sources = (0, import_graphql_tag_pluck.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 "${(0, import_path.relative)(
+          import_utils2.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, import_utils2.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);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processor
+});

package/cjs/rules/alphabetize.d.ts

@@ -0,0 +1,84 @@
+import { FromSchema } from 'json-schema-to-ts';
+import { f as GraphQLESLintRule } from '../types-8d5f4ae0.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.js';
+
+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 };