@graphql-eslint/eslint-plugin 3.19.3 → 3.20.0-alpha-20230703155329-a20556f

package/{typings/estree-converter/types.d.cts → esm/estree-converter/types.d.mts}

@@ -1,6 +1,7 @@
 import { AST } from 'eslint';
-import { Comment, SourceLocation } from 'estree';
-import { ArgumentNode, ASTNode, DefinitionNode, DirectiveDefinitionNode, DirectiveNode, DocumentNode, EnumTypeDefinitionNode, EnumTypeExtensionNode, EnumValueDefinitionNode, ExecutableDefinitionNode, FieldDefinitionNode, FieldNode, FragmentSpreadNode, InlineFragmentNode, InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode, InputValueDefinitionNode, InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode, ListTypeNode, NamedTypeNode, NameNode, NonNullTypeNode, ObjectTypeDefinitionNode, ObjectTypeExtensionNode, OperationTypeDefinitionNode, SelectionNode, SelectionSetNode, TypeDefinitionNode, TypeExtensionNode, TypeInfo, TypeNode, VariableDefinitionNode, VariableNode } from 'graphql';
+import { SourceLocation, Comment } from 'estree';
+import { TypeInfo, ASTNode, TypeNode, DocumentNode, DefinitionNode, EnumValueDefinitionNode, EnumTypeDefinitionNode, EnumTypeExtensionNode, InputValueDefinitionNode, DirectiveDefinitionNode, FieldDefinitionNode, InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode, InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode, ObjectTypeDefinitionNode, ObjectTypeExtensionNode, SelectionSetNode, ExecutableDefinitionNode, FieldNode, InlineFragmentNode, SelectionNode, NameNode, DirectiveNode, VariableNode, VariableDefinitionNode, ArgumentNode, FragmentSpreadNode, NamedTypeNode, TypeDefinitionNode, TypeExtensionNode, ListTypeNode, NonNullTypeNode, OperationTypeDefinitionNode } from 'graphql';
+
 type SafeGraphQLType<T extends ASTNode> = T extends {
     type: TypeNode;
 } ? Omit<T, 'loc' | 'type'> & {
@@ -9,7 +10,7 @@ type SafeGraphQLType<T extends ASTNode> = T extends {
 type Writeable<T> = {
     -readonly [K in keyof T]: T[K];
 };
-export type TypeInformation = {
+type TypeInformation = {
     argument: ReturnType<TypeInfo['getArgument']>;
     defaultValue: ReturnType<TypeInfo['getDefaultValue']>;
     directive: ReturnType<TypeInfo['getDirective']>;
@@ -32,9 +33,10 @@ type Node<T extends ASTNode, WithTypeInfo extends boolean> = Writeable<SafeGraph
     rawNode: () => T;
     parent: GraphQLESTreeNode<ParentNode<T>>;
 };
-export type GraphQLESTreeNode<T, W extends boolean = false> = T extends ASTNode ? {
+type GraphQLESTreeNode<T, W extends boolean = false> = T extends ASTNode ? {
     [K in keyof Node<T, W>]: Node<T, W>[K] extends ReadonlyArray<infer ArrayItem> | undefined ? GraphQLESTreeNode<ArrayItem, W>[] : GraphQLESTreeNode<Node<T, W>[K], W>;
 } : T extends AST.Program ? T & {
     parent: null;
 } : T;
-export {};
+
+export { GraphQLESTreeNode, TypeInformation };

package/esm/estree-converter/utils.d.mts

@@ -0,0 +1,18 @@
+import * as graphql_jsutils_Maybe from 'graphql/jsutils/Maybe';
+import * as graphql_jsutils_ObjMap from 'graphql/jsutils/ObjMap';
+import * as graphql from 'graphql';
+import { GraphQLOutputType, GraphQLNamedType, Token, Location } from 'graphql';
+import { AST } from 'eslint';
+import { Comment, SourceLocation } from 'estree';
+
+declare const valueFromNode: (valueNode: graphql.ValueNode, variables?: graphql_jsutils_Maybe.Maybe<graphql_jsutils_ObjMap.ObjMap<unknown>>) => any;
+declare function getBaseType(type: GraphQLOutputType): GraphQLNamedType;
+type TokenKindValue = ':' | '!' | '...' | '(' | ')' | '[' | ']' | '{' | '}' | '@' | '&' | '<SOF>' | '=' | '|' | '$' | 'BlockString' | 'Comment' | 'Float' | 'Int' | 'Name' | 'String';
+declare function convertToken<T extends TokenKindValue | 'Block' | 'Line'>(token: Token, type: T): Omit<AST.Token, 'type'> & {
+    type: T;
+};
+declare function extractTokens(filePath: string, code: string): AST.Token[];
+declare function extractComments(loc?: Location): Comment[];
+declare function convertLocation(location: Location): SourceLocation;
+
+export { convertLocation, convertToken, extractComments, extractTokens, getBaseType, valueFromNode };

package/esm/estree-converter/utils.js

@@ -1,104 +1,113 @@
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
-import { isListType, isNonNullType, Source, TokenKind, } from 'graphql';
-import { valueFromASTUntyped } from 'graphql/utilities/valueFromASTUntyped.js';
-export const valueFromNode = (...args) => {
-    return valueFromASTUntyped(...args);
+import {
+  isListType,
+  isNonNullType,
+  Source,
+  TokenKind
+} from "graphql";
+import { valueFromASTUntyped } from "graphql/utilities/valueFromASTUntyped.js";
+const valueFromNode = (...args) => {
+  return valueFromASTUntyped(...args);
 };
-export function getBaseType(type) {
-    if (isNonNullType(type) || isListType(type)) {
-        return getBaseType(type.ofType);
-    }
-    return type;
+function getBaseType(type) {
+  if (isNonNullType(type) || isListType(type)) {
+    return getBaseType(type.ofType);
+  }
+  return type;
 }
-export 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],
-    };
+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,
+    /*
+     * 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]
+  };
 }
 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!");
 }
-export function extractTokens(filePath, code) {
-    const source = new Source(code, filePath);
-    const lexer = getLexer(source);
-    const tokens = [];
-    let token = lexer.advance();
-    while (token && token.kind !== TokenKind.EOF) {
-        const result = convertToken(token, token.kind);
-        tokens.push(result);
-        token = lexer.advance();
-    }
-    return tokens;
+function extractTokens(filePath, code) {
+  const source = new Source(code, filePath);
+  const lexer = getLexer(source);
+  const tokens = [];
+  let token = lexer.advance();
+  while (token && token.kind !== TokenKind.EOF) {
+    const result = convertToken(token, token.kind);
+    tokens.push(result);
+    token = lexer.advance();
+  }
+  return tokens;
 }
-export function extractComments(loc) {
-    if (!loc) {
-        return [];
-    }
-    const comments = [];
-    let token = loc.startToken;
-    while (token) {
-        if (token.kind === 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;
+function extractComments(loc) {
+  if (!loc) {
+    return [];
+  }
+  const comments = [];
+  let token = loc.startToken;
+  while (token) {
+    if (token.kind === 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;
 }
-export 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;
+function convertLocation(location) {
+  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;
 }
+export {
+  convertLocation,
+  convertToken,
+  extractComments,
+  extractTokens,
+  getBaseType,
+  valueFromNode
+};

package/{typings/flat-configs.d.cts → esm/flat-configs.d.mts}

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

package/esm/flat-configs.js

@@ -1,33 +1,36 @@
-import { configs } from './configs/index.js';
-import { parseForESLint } from './parser.js';
+import { configs } from "./configs/index.js";
+import { parseForESLint } from "./parser.js";
 const languageOptions = {
-    parser: { parseForESLint },
+  parser: { parseForESLint }
 };
-export const flatConfigs = {
-    'operations-all': {
-        languageOptions,
-        rules: {
-            ...configs['operations-recommended'].rules,
-            ...configs['operations-all'].rules,
-        },
-    },
-    'operations-recommended': {
-        languageOptions,
-        rules: configs['operations-recommended'].rules,
-    },
-    relay: {
-        languageOptions,
-        rules: configs.relay.rules,
-    },
-    'schema-all': {
-        languageOptions,
-        rules: {
-            ...configs['schema-recommended'].rules,
-            ...configs['schema-all'].rules,
-        },
-    },
-    'schema-recommended': {
-        languageOptions,
-        rules: configs['schema-recommended'].rules,
-    },
+const flatConfigs = {
+  "operations-all": {
+    languageOptions,
+    rules: {
+      ...configs["operations-recommended"].rules,
+      ...configs["operations-all"].rules
+    }
+  },
+  "operations-recommended": {
+    languageOptions,
+    rules: configs["operations-recommended"].rules
+  },
+  relay: {
+    languageOptions,
+    rules: configs.relay.rules
+  },
+  "schema-all": {
+    languageOptions,
+    rules: {
+      ...configs["schema-recommended"].rules,
+      ...configs["schema-all"].rules
+    }
+  },
+  "schema-recommended": {
+    languageOptions,
+    rules: configs["schema-recommended"].rules
+  }
+};
+export {
+  flatConfigs
 };

package/esm/graphql-config.d.mts

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

package/esm/graphql-config.js

@@ -1,49 +1,54 @@
-import { dirname } from 'path';
-import { CodeFileLoader } from '@graphql-tools/code-file-loader';
-import debugFactory from 'debug';
-import { GraphQLConfig, loadConfigSync, } from 'graphql-config';
-const debug = debugFactory('graphql-eslint:graphql-config');
+import { dirname } from "path";
+import { CodeFileLoader } from "@graphql-tools/code-file-loader";
+import debugFactory from "debug";
+import {
+  GraphQLConfig,
+  loadConfigSync
+} from "graphql-config";
+const debug = debugFactory("graphql-eslint:graphql-config");
 let graphQLConfig;
-export function loadOnDiskGraphQLConfig(filePath) {
-    return loadConfigSync({
-        // load config relative to the file being linted
-        rootDir: dirname(filePath),
-        throwOnEmpty: false,
-        throwOnMissing: false,
-        extensions: [codeFileLoaderExtension],
-    });
+function loadOnDiskGraphQLConfig(filePath) {
+  return loadConfigSync({
+    // load config relative to the file being linted
+    rootDir: dirname(filePath),
+    throwOnEmpty: false,
+    throwOnMissing: false,
+    extensions: [codeFileLoaderExtension]
+  });
 }
-export 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 GraphQLConfig({
-                config: configOptions,
-                filepath: 'virtual-config',
-            }, [codeFileLoaderExtension]);
+function loadGraphQLConfig(options) {
+  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 GraphQLConfig(
+    {
+      config: configOptions,
+      filepath: "virtual-config"
+    },
+    [codeFileLoaderExtension]
+  );
+  return graphQLConfig;
 }
-const codeFileLoaderExtension = api => {
-    const { schema, documents } = api.loaders;
-    schema.register(new CodeFileLoader());
-    documents.register(new CodeFileLoader());
-    return { name: 'graphql-eslint-loaders' };
+const codeFileLoaderExtension = (api) => {
+  const { schema, documents } = api.loaders;
+  schema.register(new CodeFileLoader());
+  documents.register(new CodeFileLoader());
+  return { name: "graphql-eslint-loaders" };
+};
+export {
+  loadGraphQLConfig,
+  loadOnDiskGraphQLConfig
 };

package/esm/index.d.mts

@@ -0,0 +1,22 @@
+import * as eslint from 'eslint';
+import { Block } from './processor.mjs';
+export { parseForESLint } from './parser.mjs';
+export { rules } from './rules/index.mjs';
+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-2e1afd7c.js';
+export { requireGraphQLSchemaFromContext, requireSiblingsOperations } from './utils.mjs';
+export { configs } from './configs/index.mjs';
+export { flatConfigs } from './flat-configs.mjs';
+import './rules/require-description.mjs';
+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.mjs';
+
+declare const processors: {
+    graphql: eslint.Linter.Processor<string | Block>;
+};
+
+export { processors };

package/esm/index.js

@@ -1,9 +1,18 @@
-import { processor } from './processor.js';
-export { parseForESLint } from './parser.js';
-export { rules } from './rules/index.js';
-export * from './testkit.js';
-export * from './types.js';
-export { requireGraphQLSchemaFromContext, requireSiblingsOperations } from './utils.js';
-export const processors = { graphql: processor };
-export { configs } from './configs/index.js';
-export { flatConfigs } from './flat-configs.js';
+import { processor } from "./processor.js";
+import { parseForESLint } from "./parser.js";
+import { rules } from "./rules/index.js";
+export * from "./testkit.js";
+export * from "./types.js";
+import { requireGraphQLSchemaFromContext, requireSiblingsOperations } from "./utils.js";
+const processors = { graphql: processor };
+import { configs } from "./configs/index.js";
+import { flatConfigs } from "./flat-configs.js";
+export {
+  configs,
+  flatConfigs,
+  parseForESLint,
+  processors,
+  requireGraphQLSchemaFromContext,
+  requireSiblingsOperations,
+  rules
+};

package/esm/package.json

@@ -1 +1 @@
-{ "type": "module" }
+{"type": "module"}

package/esm/parser.d.mts

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