@graphql-eslint/eslint-plugin 3.19.3 → 3.20.0-alpha-20230703154330-0d51273

package/cjs/estree-converter/utils.js

@@ -1,111 +1,135 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertLocation = exports.extractComments = exports.extractTokens = exports.convertToken = exports.getBaseType = exports.valueFromNode = void 0;
-const graphql_1 = require("graphql");
-const valueFromASTUntyped_js_1 = require("graphql/utilities/valueFromASTUntyped.js");
+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 utils_exports = {};
+__export(utils_exports, {
+  convertLocation: () => convertLocation,
+  convertToken: () => convertToken,
+  extractComments: () => extractComments,
+  extractTokens: () => extractTokens,
+  getBaseType: () => getBaseType,
+  valueFromNode: () => valueFromNode
+});
+module.exports = __toCommonJS(utils_exports);
+var import_graphql = require("graphql");
+var import_valueFromASTUntyped = require("graphql/utilities/valueFromASTUntyped.js");
 const valueFromNode = (...args) => {
-    return (0, valueFromASTUntyped_js_1.valueFromASTUntyped)(...args);
+  return (0, import_valueFromASTUntyped.valueFromASTUntyped)(...args);
 };
-exports.valueFromNode = valueFromNode;
 function getBaseType(type) {
-    if ((0, graphql_1.isNonNullType)(type) || (0, graphql_1.isListType)(type)) {
-        return getBaseType(type.ofType);
-    }
-    return type;
+  if ((0, import_graphql.isNonNullType)(type) || (0, import_graphql.isListType)(type)) {
+    return getBaseType(type.ofType);
+  }
+  return type;
 }
-exports.getBaseType = getBaseType;
 function convertToken(token, type) {
-    const { line, column, end, start, value } = token;
-    return {
-        type,
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TODO: remove `!` when drop support of graphql@15
-        value: value,
-        /*
-         * ESLint has 0-based column number
-         * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
-         */
-        loc: {
-            start: {
-                line,
-                column: column - 1,
-            },
-            end: {
-                line,
-                column: column - 1 + (end - start),
-            },
-        },
-        range: [start, end],
-    };
+  const { line, column, end, start, value } = token;
+  return {
+    type,
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TODO: remove `!` when drop support of graphql@15
+    value,
+    /*
+     * ESLint has 0-based column number
+     * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
+     */
+    loc: {
+      start: {
+        line,
+        column: column - 1
+      },
+      end: {
+        line,
+        column: column - 1 + (end - start)
+      }
+    },
+    range: [start, end]
+  };
 }
-exports.convertToken = convertToken;
 function getLexer(source) {
-    // GraphQL v14
-    const gqlLanguage = require('graphql/language');
-    if (gqlLanguage === null || gqlLanguage === void 0 ? void 0 : gqlLanguage.createLexer) {
-        return gqlLanguage.createLexer(source, {});
-    }
-    // GraphQL v15
-    const { Lexer: LexerCls } = require('graphql');
-    if (LexerCls && typeof LexerCls === 'function') {
-        return new LexerCls(source);
-    }
-    throw new Error('Unsupported GraphQL version! Please make sure to use GraphQL v14 or newer!');
+  const gqlLanguage = require("graphql/language");
+  if (gqlLanguage?.createLexer) {
+    return gqlLanguage.createLexer(source, {});
+  }
+  const { Lexer: LexerCls } = require("graphql");
+  if (LexerCls && typeof LexerCls === "function") {
+    return new LexerCls(source);
+  }
+  throw new Error("Unsupported GraphQL version! Please make sure to use GraphQL v14 or newer!");
 }
 function extractTokens(filePath, code) {
-    const source = new graphql_1.Source(code, filePath);
-    const lexer = getLexer(source);
-    const tokens = [];
-    let token = lexer.advance();
-    while (token && token.kind !== graphql_1.TokenKind.EOF) {
-        const result = convertToken(token, token.kind);
-        tokens.push(result);
-        token = lexer.advance();
-    }
-    return tokens;
+  const source = new import_graphql.Source(code, filePath);
+  const lexer = getLexer(source);
+  const tokens = [];
+  let token = lexer.advance();
+  while (token && token.kind !== import_graphql.TokenKind.EOF) {
+    const result = convertToken(token, token.kind);
+    tokens.push(result);
+    token = lexer.advance();
+  }
+  return tokens;
 }
-exports.extractTokens = extractTokens;
 function extractComments(loc) {
-    if (!loc) {
-        return [];
-    }
-    const comments = [];
-    let token = loc.startToken;
-    while (token) {
-        if (token.kind === graphql_1.TokenKind.COMMENT) {
-            const comment = convertToken(token, 
-            // `eslint-disable` directive works only with `Block` type comment
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TODO: remove `!` when drop support of graphql@15
-            token.value.trimStart().startsWith('eslint') ? 'Block' : 'Line');
-            comments.push(comment);
-        }
-        token = token.next;
+  if (!loc) {
+    return [];
+  }
+  const comments = [];
+  let token = loc.startToken;
+  while (token) {
+    if (token.kind === import_graphql.TokenKind.COMMENT) {
+      const comment = convertToken(
+        token,
+        // `eslint-disable` directive works only with `Block` type comment
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TODO: remove `!` when drop support of graphql@15
+        token.value.trimStart().startsWith("eslint") ? "Block" : "Line"
+      );
+      comments.push(comment);
     }
-    return comments;
+    token = token.next;
+  }
+  return comments;
 }
-exports.extractComments = extractComments;
 function convertLocation(location) {
-    const { startToken, endToken, source, start, end } = location;
-    /*
-     * ESLint has 0-based column number
-     * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
-     */
-    const loc = {
-        start: {
-            /*
-             * Kind.Document has startToken: { line: 0, column: 0 }, we set line as 1 and column as 0
-             */
-            line: startToken.line === 0 ? 1 : startToken.line,
-            column: startToken.column === 0 ? 0 : startToken.column - 1,
-        },
-        end: {
-            line: endToken.line,
-            column: endToken.column - 1,
-        },
-        source: source.body,
-    };
-    if (loc.start.column === loc.end.column) {
-        loc.end.column += end - start;
-    }
-    return loc;
+  const { startToken, endToken, source, start, end } = location;
+  const loc = {
+    start: {
+      /*
+       * Kind.Document has startToken: { line: 0, column: 0 }, we set line as 1 and column as 0
+       */
+      line: startToken.line === 0 ? 1 : startToken.line,
+      column: startToken.column === 0 ? 0 : startToken.column - 1
+    },
+    end: {
+      line: endToken.line,
+      column: endToken.column - 1
+    },
+    source: source.body
+  };
+  if (loc.start.column === loc.end.column) {
+    loc.end.column += end - start;
+  }
+  return loc;
 }
-exports.convertLocation = convertLocation;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertLocation,
+  convertToken,
+  extractComments,
+  extractTokens,
+  getBaseType,
+  valueFromNode
+});

package/{typings → cjs}/flat-configs.d.ts

@@ -1,5 +1,14 @@
 import { parseForESLint } from './parser.js';
-export declare const flatConfigs: {
+import './types-e3367e3c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import './estree-converter/types.js';
+
+declare const flatConfigs: {
     'operations-all': {
         languageOptions: {
             parser: {
@@ -247,3 +256,5 @@ export declare const flatConfigs: {
         };
     };
 };
+
+export { flatConfigs };

package/cjs/flat-configs.js

@@ -1,36 +1,60 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flatConfigs = void 0;
-const index_js_1 = require("./configs/index.js");
-const parser_js_1 = require("./parser.js");
+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 flat_configs_exports = {};
+__export(flat_configs_exports, {
+  flatConfigs: () => flatConfigs
+});
+module.exports = __toCommonJS(flat_configs_exports);
+var import_configs = require("./configs/index.js");
+var import_parser = require("./parser.js");
 const languageOptions = {
-    parser: { parseForESLint: parser_js_1.parseForESLint },
+  parser: { parseForESLint: import_parser.parseForESLint }
 };
-exports.flatConfigs = {
-    'operations-all': {
-        languageOptions,
-        rules: {
-            ...index_js_1.configs['operations-recommended'].rules,
-            ...index_js_1.configs['operations-all'].rules,
-        },
-    },
-    'operations-recommended': {
-        languageOptions,
-        rules: index_js_1.configs['operations-recommended'].rules,
-    },
-    relay: {
-        languageOptions,
-        rules: index_js_1.configs.relay.rules,
-    },
-    'schema-all': {
-        languageOptions,
-        rules: {
-            ...index_js_1.configs['schema-recommended'].rules,
-            ...index_js_1.configs['schema-all'].rules,
-        },
-    },
-    'schema-recommended': {
-        languageOptions,
-        rules: index_js_1.configs['schema-recommended'].rules,
-    },
+const flatConfigs = {
+  "operations-all": {
+    languageOptions,
+    rules: {
+      ...import_configs.configs["operations-recommended"].rules,
+      ...import_configs.configs["operations-all"].rules
+    }
+  },
+  "operations-recommended": {
+    languageOptions,
+    rules: import_configs.configs["operations-recommended"].rules
+  },
+  relay: {
+    languageOptions,
+    rules: import_configs.configs.relay.rules
+  },
+  "schema-all": {
+    languageOptions,
+    rules: {
+      ...import_configs.configs["schema-recommended"].rules,
+      ...import_configs.configs["schema-all"].rules
+    }
+  },
+  "schema-recommended": {
+    languageOptions,
+    rules: import_configs.configs["schema-recommended"].rules
+  }
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flatConfigs
+});

package/cjs/graphql-config.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLConfig } from 'graphql-config';
+import { P as ParserOptions } from './types-e3367e3c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import './estree-converter/types.js';
+
+declare function loadOnDiskGraphQLConfig(filePath: string): GraphQLConfig;
+declare function loadGraphQLConfig(options: ParserOptions): GraphQLConfig;
+
+export { loadGraphQLConfig, loadOnDiskGraphQLConfig };

package/cjs/graphql-config.js

@@ -1,55 +1,86 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadGraphQLConfig = exports.loadOnDiskGraphQLConfig = void 0;
-const tslib_1 = require("tslib");
-const path_1 = require("path");
-const code_file_loader_1 = require("@graphql-tools/code-file-loader");
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const graphql_config_1 = require("graphql-config");
-const debug = (0, debug_1.default)('graphql-eslint:graphql-config');
+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 graphql_config_exports = {};
+__export(graphql_config_exports, {
+  loadGraphQLConfig: () => loadGraphQLConfig,
+  loadOnDiskGraphQLConfig: () => loadOnDiskGraphQLConfig
+});
+module.exports = __toCommonJS(graphql_config_exports);
+var import_path = require("path");
+var import_code_file_loader = require("@graphql-tools/code-file-loader");
+var import_debug = __toESM(require("debug"));
+var import_graphql_config = require("graphql-config");
+const debug = (0, import_debug.default)("graphql-eslint:graphql-config");
 let graphQLConfig;
 function loadOnDiskGraphQLConfig(filePath) {
-    return (0, graphql_config_1.loadConfigSync)({
-        // load config relative to the file being linted
-        rootDir: (0, path_1.dirname)(filePath),
-        throwOnEmpty: false,
-        throwOnMissing: false,
-        extensions: [codeFileLoaderExtension],
-    });
+  return (0, import_graphql_config.loadConfigSync)({
+    // load config relative to the file being linted
+    rootDir: (0, import_path.dirname)(filePath),
+    throwOnEmpty: false,
+    throwOnMissing: false,
+    extensions: [codeFileLoaderExtension]
+  });
 }
-exports.loadOnDiskGraphQLConfig = loadOnDiskGraphQLConfig;
 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,
-            extensions: options.extensions,
-            include: options.include,
-            exclude: options.exclude,
-        };
-    graphQLConfig =
-        onDiskConfig ||
-            new graphql_config_1.GraphQLConfig({
-                config: configOptions,
-                filepath: 'virtual-config',
-            }, [codeFileLoaderExtension]);
+  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 || "",
+    // if `schema` is `undefined` will throw error `Project 'default' not found`
+    documents: options.documents,
+    extensions: options.extensions,
+    include: options.include,
+    exclude: options.exclude
+  };
+  graphQLConfig = onDiskConfig || new import_graphql_config.GraphQLConfig(
+    {
+      config: configOptions,
+      filepath: "virtual-config"
+    },
+    [codeFileLoaderExtension]
+  );
+  return graphQLConfig;
 }
-exports.loadGraphQLConfig = loadGraphQLConfig;
-const codeFileLoaderExtension = api => {
-    const { schema, documents } = api.loaders;
-    schema.register(new code_file_loader_1.CodeFileLoader());
-    documents.register(new code_file_loader_1.CodeFileLoader());
-    return { name: 'graphql-eslint-loaders' };
+const codeFileLoaderExtension = (api) => {
+  const { schema, documents } = api.loaders;
+  schema.register(new import_code_file_loader.CodeFileLoader());
+  documents.register(new import_code_file_loader.CodeFileLoader());
+  return { name: "graphql-eslint-loaders" };
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadGraphQLConfig,
+  loadOnDiskGraphQLConfig
+});

package/cjs/index.d.ts

@@ -0,0 +1,22 @@
+import * as eslint from 'eslint';
+import { Block } from './processor.js';
+export { parseForESLint } from './parser.js';
+export { rules } from './rules/index.js';
+export { C as CategoryType, f as GraphQLESLintParseResult, i as GraphQLESLintRule, g as GraphQLESLintRuleContext, G as GraphQLESLintRuleListener, b as GraphQLInvalidTestCase, c as GraphQLRuleTester, a as GraphQLValidTestCase, O as OmitRecursively, P as ParserOptions, e as ParserServices, d as Pointer, R as ReportDescriptor, h as RuleDocsInfo, S as Schema, V as ValueOf } from './types-e3367e3c.js';
+export { requireGraphQLSchemaFromContext, requireSiblingsOperations } from './utils.js';
+export { configs } from './configs/index.js';
+export { flatConfigs } from './flat-configs.js';
+import './rules/require-description.js';
+import 'graphql';
+import 'json-schema-to-ts/lib/types/type-utils/writable.js';
+import '@graphql-tools/utils';
+import 'estree';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import './estree-converter/types.js';
+
+declare const processors: {
+    graphql: eslint.Linter.Processor<string | Block>;
+};
+
+export { processors };

package/cjs/index.js

@@ -1,19 +1,51 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flatConfigs = exports.configs = exports.processors = exports.requireSiblingsOperations = exports.requireGraphQLSchemaFromContext = exports.rules = exports.parseForESLint = void 0;
-const tslib_1 = require("tslib");
-const processor_js_1 = require("./processor.js");
-var parser_js_1 = require("./parser.js");
-Object.defineProperty(exports, "parseForESLint", { enumerable: true, get: function () { return parser_js_1.parseForESLint; } });
-var index_js_1 = require("./rules/index.js");
-Object.defineProperty(exports, "rules", { enumerable: true, get: function () { return index_js_1.rules; } });
-tslib_1.__exportStar(require("./testkit.js"), exports);
-tslib_1.__exportStar(require("./types.js"), exports);
-var utils_js_1 = require("./utils.js");
-Object.defineProperty(exports, "requireGraphQLSchemaFromContext", { enumerable: true, get: function () { return utils_js_1.requireGraphQLSchemaFromContext; } });
-Object.defineProperty(exports, "requireSiblingsOperations", { enumerable: true, get: function () { return utils_js_1.requireSiblingsOperations; } });
-exports.processors = { graphql: processor_js_1.processor };
-var index_js_2 = require("./configs/index.js");
-Object.defineProperty(exports, "configs", { enumerable: true, get: function () { return index_js_2.configs; } });
-var flat_configs_js_1 = require("./flat-configs.js");
-Object.defineProperty(exports, "flatConfigs", { enumerable: true, get: function () { return flat_configs_js_1.flatConfigs; } });
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  configs: () => import_configs.configs,
+  flatConfigs: () => import_flat_configs.flatConfigs,
+  parseForESLint: () => import_parser.parseForESLint,
+  processors: () => processors,
+  requireGraphQLSchemaFromContext: () => import_utils.requireGraphQLSchemaFromContext,
+  requireSiblingsOperations: () => import_utils.requireSiblingsOperations,
+  rules: () => import_rules.rules
+});
+module.exports = __toCommonJS(src_exports);
+var import_processor = require("./processor.js");
+var import_parser = require("./parser.js");
+var import_rules = require("./rules/index.js");
+__reExport(src_exports, require("./testkit.js"), module.exports);
+__reExport(src_exports, require("./types.js"), module.exports);
+var import_utils = require("./utils.js");
+var import_configs = require("./configs/index.js");
+var import_flat_configs = require("./flat-configs.js");
+const processors = { graphql: import_processor.processor };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configs,
+  flatConfigs,
+  parseForESLint,
+  processors,
+  requireGraphQLSchemaFromContext,
+  requireSiblingsOperations,
+  rules,
+  ...require("./testkit.js"),
+  ...require("./types.js")
+});

package/cjs/parser.d.ts

@@ -0,0 +1,12 @@
+import { P as ParserOptions, f as GraphQLESLintParseResult } from './types-e3367e3c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import './estree-converter/types.js';
+
+declare function parseForESLint(code: string, options: ParserOptions): GraphQLESLintParseResult;
+
+export { parseForESLint };