@graphql-eslint/eslint-plugin 4.0.0-alpha-20220821140530-e968cfc → 4.0.0-alpha-20230810155929-e89edf7

package/esm/estree-converter/utils.js

@@ -0,0 +1,87 @@
+import "../chunk-U3TKCM4X.js";
+import {
+  isListType,
+  isNonNullType,
+  Lexer,
+  Source,
+  TokenKind
+} from "graphql";
+import { valueFromASTUntyped } from "graphql/utilities/valueFromASTUntyped.js";
+const valueFromNode = (...args) => valueFromASTUntyped(...args);
+function getBaseType(type) {
+  return isNonNullType(type) || isListType(type) ? getBaseType(type.ofType) : type;
+}
+function convertToken(token, type) {
+  const { line, column, end, start, value } = token;
+  return {
+    type,
+    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 extractTokens(filePath, code) {
+  const source = new Source(code, filePath), lexer = new Lexer(source), tokens = [];
+  let token = lexer.advance();
+  for (; token && token.kind !== TokenKind.EOF; ) {
+    const result = convertToken(token, token.kind);
+    tokens.push(result), token = lexer.advance();
+  }
+  return tokens;
+}
+function extractComments(loc) {
+  if (!loc)
+    return [];
+  const comments = [];
+  let token = loc.startToken;
+  for (; token; ) {
+    if (token.kind === TokenKind.COMMENT) {
+      const comment = convertToken(
+        token,
+        // `eslint-disable` directive works only with `Block` type comment
+        token.value.trimStart().startsWith("eslint") ? "Block" : "Line"
+      );
+      comments.push(comment);
+    }
+    token = token.next;
+  }
+  return comments;
+}
+function convertLocation(location) {
+  const { startToken, endToken, source, start, end } = location, 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
+  };
+  return loc.start.column === loc.end.column && (loc.end.column += end - start), loc;
+}
+export {
+  convertLocation,
+  convertToken,
+  extractComments,
+  extractTokens,
+  getBaseType,
+  valueFromNode
+};

package/esm/flat-configs.d.mts

@@ -0,0 +1,307 @@
+import { parseForESLint } from './parser.mjs';
+import './types.mjs';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import './siblings.mjs';
+import '@graphql-tools/utils';
+import './estree-converter/types.mjs';
+import 'graphql-config';
+
+declare const flatConfigs: {
+    'operations-all': {
+        languageOptions: {
+            parser: {
+                parseForESLint: typeof parseForESLint;
+            };
+        };
+        rules: {
+            '@graphql-eslint/alphabetize': (string | {
+                definitions: boolean;
+                selections: string[];
+                variables: boolean;
+                arguments: string[];
+                groups: string[];
+            })[];
+            '@graphql-eslint/lone-executable-definition': string;
+            '@graphql-eslint/match-document-filename': (string | {
+                query: string;
+                mutation: string;
+                subscription: string;
+                fragment: string;
+            })[];
+            '@graphql-eslint/no-one-place-fragments': string;
+            '@graphql-eslint/require-import-fragment': string;
+            '@graphql-eslint/executable-definitions': string;
+            '@graphql-eslint/fields-on-correct-type': string;
+            '@graphql-eslint/fragments-on-composite-type': string;
+            '@graphql-eslint/known-argument-names': string;
+            '@graphql-eslint/known-directives': string;
+            '@graphql-eslint/known-fragment-names': string;
+            '@graphql-eslint/known-type-names': string;
+            '@graphql-eslint/lone-anonymous-operation': string;
+            '@graphql-eslint/naming-convention': (string | {
+                VariableDefinition: string;
+                OperationDefinition: {
+                    style: string;
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                FragmentDefinition: {
+                    style: string;
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+            })[];
+            '@graphql-eslint/no-anonymous-operations': string;
+            '@graphql-eslint/no-deprecated': string;
+            '@graphql-eslint/no-duplicate-fields': string;
+            '@graphql-eslint/no-fragment-cycles': string;
+            '@graphql-eslint/no-undefined-variables': string;
+            '@graphql-eslint/no-unused-fragments': string;
+            '@graphql-eslint/no-unused-variables': string;
+            '@graphql-eslint/one-field-subscriptions': string;
+            '@graphql-eslint/overlapping-fields-can-be-merged': string;
+            '@graphql-eslint/possible-fragment-spread': string;
+            '@graphql-eslint/provided-required-arguments': string;
+            '@graphql-eslint/require-selections': string;
+            '@graphql-eslint/scalar-leafs': string;
+            '@graphql-eslint/selection-set-depth': (string | {
+                maxDepth: number;
+            })[];
+            '@graphql-eslint/unique-argument-names': string;
+            '@graphql-eslint/unique-directive-names-per-location': string;
+            '@graphql-eslint/unique-fragment-name': string;
+            '@graphql-eslint/unique-input-field-names': string;
+            '@graphql-eslint/unique-operation-name': string;
+            '@graphql-eslint/unique-variable-names': string;
+            '@graphql-eslint/value-literals-of-correct-type': string;
+            '@graphql-eslint/variables-are-input-types': string;
+            '@graphql-eslint/variables-in-allowed-position': string;
+        };
+    };
+    'operations-recommended': {
+        languageOptions: {
+            parser: {
+                parseForESLint: typeof parseForESLint;
+            };
+        };
+        rules: {
+            '@graphql-eslint/executable-definitions': string;
+            '@graphql-eslint/fields-on-correct-type': string;
+            '@graphql-eslint/fragments-on-composite-type': string;
+            '@graphql-eslint/known-argument-names': string;
+            '@graphql-eslint/known-directives': string;
+            '@graphql-eslint/known-fragment-names': string;
+            '@graphql-eslint/known-type-names': string;
+            '@graphql-eslint/lone-anonymous-operation': string;
+            '@graphql-eslint/naming-convention': (string | {
+                VariableDefinition: string;
+                OperationDefinition: {
+                    style: string;
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                FragmentDefinition: {
+                    style: string;
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+            })[];
+            '@graphql-eslint/no-anonymous-operations': string;
+            '@graphql-eslint/no-deprecated': string;
+            '@graphql-eslint/no-duplicate-fields': string;
+            '@graphql-eslint/no-fragment-cycles': string;
+            '@graphql-eslint/no-undefined-variables': string;
+            '@graphql-eslint/no-unused-fragments': string;
+            '@graphql-eslint/no-unused-variables': string;
+            '@graphql-eslint/one-field-subscriptions': string;
+            '@graphql-eslint/overlapping-fields-can-be-merged': string;
+            '@graphql-eslint/possible-fragment-spread': string;
+            '@graphql-eslint/provided-required-arguments': string;
+            '@graphql-eslint/require-selections': string;
+            '@graphql-eslint/scalar-leafs': string;
+            '@graphql-eslint/selection-set-depth': (string | {
+                maxDepth: number;
+            })[];
+            '@graphql-eslint/unique-argument-names': string;
+            '@graphql-eslint/unique-directive-names-per-location': string;
+            '@graphql-eslint/unique-fragment-name': string;
+            '@graphql-eslint/unique-input-field-names': string;
+            '@graphql-eslint/unique-operation-name': string;
+            '@graphql-eslint/unique-variable-names': string;
+            '@graphql-eslint/value-literals-of-correct-type': string;
+            '@graphql-eslint/variables-are-input-types': string;
+            '@graphql-eslint/variables-in-allowed-position': string;
+        };
+    };
+    'schema-relay': {
+        languageOptions: {
+            parser: {
+                parseForESLint: typeof parseForESLint;
+            };
+        };
+        rules: {
+            '@graphql-eslint/relay-arguments': string;
+            '@graphql-eslint/relay-connection-types': string;
+            '@graphql-eslint/relay-edge-types': string;
+            '@graphql-eslint/relay-page-info': string;
+        };
+    };
+    'schema-all': {
+        languageOptions: {
+            parser: {
+                parseForESLint: typeof parseForESLint;
+            };
+        };
+        rules: {
+            '@graphql-eslint/alphabetize': (string | {
+                definitions: boolean;
+                fields: string[];
+                values: boolean;
+                arguments: string[];
+                groups: string[];
+            })[];
+            '@graphql-eslint/input-name': string;
+            '@graphql-eslint/no-root-type': (string | {
+                disallow: string[];
+            })[];
+            '@graphql-eslint/no-scalar-result-type-on-mutation': string;
+            '@graphql-eslint/require-deprecation-date': string;
+            '@graphql-eslint/require-field-of-type-query-in-mutation-result': string;
+            '@graphql-eslint/require-nullable-fields-with-oneof': string;
+            '@graphql-eslint/require-nullable-result-in-root': string;
+            '@graphql-eslint/require-type-pattern-with-oneof': string;
+            '@graphql-eslint/description-style': string;
+            '@graphql-eslint/known-argument-names': string;
+            '@graphql-eslint/known-directives': string;
+            '@graphql-eslint/known-type-names': string;
+            '@graphql-eslint/lone-schema-definition': string;
+            '@graphql-eslint/naming-convention': (string | {
+                types: string;
+                FieldDefinition: string;
+                InputValueDefinition: string;
+                Argument: string;
+                DirectiveDefinition: string;
+                EnumValueDefinition: string;
+                'FieldDefinition[parent.name.value=Query]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'FieldDefinition[parent.name.value=Mutation]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'FieldDefinition[parent.name.value=Subscription]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'EnumTypeDefinition,EnumTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'InterfaceTypeDefinition,InterfaceTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'UnionTypeDefinition,UnionTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'ObjectTypeDefinition,ObjectTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+            })[];
+            '@graphql-eslint/no-hashtag-description': string;
+            '@graphql-eslint/no-typename-prefix': string;
+            '@graphql-eslint/no-unreachable-types': string;
+            '@graphql-eslint/possible-type-extension': string;
+            '@graphql-eslint/provided-required-arguments': string;
+            '@graphql-eslint/require-deprecation-reason': string;
+            '@graphql-eslint/require-description': (string | {
+                types: boolean;
+                DirectiveDefinition: boolean;
+                rootField: boolean;
+            })[];
+            '@graphql-eslint/strict-id-in-types': string;
+            '@graphql-eslint/unique-directive-names': string;
+            '@graphql-eslint/unique-directive-names-per-location': string;
+            '@graphql-eslint/unique-enum-value-names': string;
+            '@graphql-eslint/unique-field-definition-names': string;
+            '@graphql-eslint/unique-operation-types': string;
+            '@graphql-eslint/unique-type-names': string;
+        };
+    };
+    'schema-recommended': {
+        languageOptions: {
+            parser: {
+                parseForESLint: typeof parseForESLint;
+            };
+        };
+        rules: {
+            '@graphql-eslint/description-style': string;
+            '@graphql-eslint/known-argument-names': string;
+            '@graphql-eslint/known-directives': string;
+            '@graphql-eslint/known-type-names': string;
+            '@graphql-eslint/lone-schema-definition': string;
+            '@graphql-eslint/naming-convention': (string | {
+                types: string;
+                FieldDefinition: string;
+                InputValueDefinition: string;
+                Argument: string;
+                DirectiveDefinition: string;
+                EnumValueDefinition: string;
+                'FieldDefinition[parent.name.value=Query]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'FieldDefinition[parent.name.value=Mutation]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'FieldDefinition[parent.name.value=Subscription]': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'EnumTypeDefinition,EnumTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'InterfaceTypeDefinition,InterfaceTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'UnionTypeDefinition,UnionTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+                'ObjectTypeDefinition,ObjectTypeExtension': {
+                    forbiddenPrefixes: string[];
+                    forbiddenSuffixes: string[];
+                };
+            })[];
+            '@graphql-eslint/no-hashtag-description': string;
+            '@graphql-eslint/no-typename-prefix': string;
+            '@graphql-eslint/no-unreachable-types': string;
+            '@graphql-eslint/possible-type-extension': string;
+            '@graphql-eslint/provided-required-arguments': string;
+            '@graphql-eslint/require-deprecation-reason': string;
+            '@graphql-eslint/require-description': (string | {
+                types: boolean;
+                DirectiveDefinition: boolean;
+                rootField: boolean;
+            })[];
+            '@graphql-eslint/strict-id-in-types': string;
+            '@graphql-eslint/unique-directive-names': string;
+            '@graphql-eslint/unique-directive-names-per-location': string;
+            '@graphql-eslint/unique-enum-value-names': string;
+            '@graphql-eslint/unique-field-definition-names': string;
+            '@graphql-eslint/unique-operation-types': string;
+            '@graphql-eslint/unique-type-names': string;
+        };
+    };
+};
+
+export { flatConfigs };

package/esm/flat-configs.js

@@ -0,0 +1,36 @@
+import "./chunk-U3TKCM4X.js";
+import { configs } from "./configs/index.js";
+import { parseForESLint } from "./parser.js";
+const languageOptions = {
+  parser: { parseForESLint }
+}, flatConfigs = {
+  "operations-all": {
+    languageOptions,
+    rules: {
+      ...configs["operations-recommended"].rules,
+      ...configs["operations-all"].rules
+    }
+  },
+  "operations-recommended": {
+    languageOptions,
+    rules: configs["operations-recommended"].rules
+  },
+  "schema-relay": {
+    languageOptions,
+    rules: configs["schema-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,14 @@
+import { GraphQLConfig } from 'graphql-config';
+import { ParserOptions } from './types.mjs';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import './siblings.mjs';
+import '@graphql-tools/utils';
+import './estree-converter/types.mjs';
+
+declare function loadOnDiskGraphQLConfig(filePath: string): GraphQLConfig;
+declare function loadGraphQLConfig({ graphQLConfig: config, filePath, }: ParserOptions): GraphQLConfig;
+
+export { loadGraphQLConfig, loadOnDiskGraphQLConfig };

package/esm/graphql-config.js

@@ -0,0 +1,39 @@
+import "./chunk-U3TKCM4X.js";
+import path from "node: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;
+function loadOnDiskGraphQLConfig(filePath) {
+  return loadConfigSync({
+    // load config relative to the file being linted
+    rootDir: path.dirname(filePath),
+    throwOnMissing: !1,
+    extensions: [codeFileLoaderExtension]
+  });
+}
+function loadGraphQLConfig({
+  graphQLConfig: config,
+  filePath
+}) {
+  if (graphQLConfig)
+    return graphQLConfig;
+  debug("parserOptions.graphQLConfig: %o", config);
+  const onDiskConfig = !config && loadOnDiskGraphQLConfig(filePath);
+  onDiskConfig && debug("GraphQL-Config path %o", onDiskConfig.filepath);
+  const configOptions = config && ("projects" in config || "schemaPath" in config) ? config : {
+    // if `schema` is `undefined` will throw error `Project 'default' not found`
+    schema: config?.schema ?? "",
+    ...config
+  };
+  return graphQLConfig = onDiskConfig || new GraphQLConfig({ config: configOptions, filepath: "" }, [codeFileLoaderExtension]), graphQLConfig;
+}
+const codeFileLoaderExtension = (api) => {
+  const { schema, documents } = api.loaders;
+  return schema.register(new CodeFileLoader()), documents.register(new CodeFileLoader()), { name: "code-file-loaders" };
+};
+export {
+  loadGraphQLConfig,
+  loadOnDiskGraphQLConfig
+};

package/esm/index.d.mts

@@ -0,0 +1,28 @@
+import * as eslint from 'eslint';
+import { Block } from './processor.mjs';
+export { parseForESLint } from './parser.mjs';
+export { rules } from './rules/index.mjs';
+export { CategoryType, ConfigName, GraphQLESLintParseResult, GraphQLESLintRule, GraphQLESLintRuleContext, GraphQLESLintRuleListener, OmitRecursively, ParserOptions, ParserServices, Pointer, ReportDescriptor, RuleDocsInfo, Schema, ValueOf } from './types.mjs';
+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 'graphql/language/ast.js';
+import 'json-schema-to-ts/lib/types/type-utils/writable.js';
+import 'estree';
+import 'json-schema-to-ts';
+import './siblings.mjs';
+import '@graphql-tools/utils';
+import './estree-converter/types.mjs';
+import 'graphql-config';
+
+declare const processors: {
+    graphql: {
+        supportsAutofix: true;
+        preprocess(code: string, filePath: string): (string | Block)[];
+        postprocess(messages: eslint.Linter.LintMessage[][], filePath: string): eslint.Linter.LintMessage[];
+    };
+};
+
+export { processors };

package/esm/index.js

@@ -0,0 +1,18 @@
+import "./chunk-U3TKCM4X.js";
+import { processor } from "./processor.js";
+import { parseForESLint } from "./parser.js";
+import { rules } from "./rules/index.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

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

package/esm/parser.d.mts

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

package/esm/parser.js

@@ -0,0 +1,76 @@
+import "./chunk-U3TKCM4X.js";
+import { parseGraphQLSDL } from "@graphql-tools/utils";
+import debugFactory from "debug";
+import { 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";
+import { getDocuments } from "./documents.js";
+const debug = debugFactory("graphql-eslint:parser");
+debug("cwd %o", CWD);
+const LEGACY_PARSER_OPTIONS_KEYS = [
+  "schema",
+  "documents",
+  "extensions",
+  "include",
+  "exclude",
+  "projects",
+  "schemaOptions",
+  "graphQLParserOptions",
+  "skipGraphQLConfig",
+  "operations"
+];
+function parseForESLint(code, options) {
+  for (const key of LEGACY_PARSER_OPTIONS_KEYS)
+    if (key in options)
+      throw new Error(
+        `\`parserOptions.${key}\` was removed in graphql-eslint@4. Use physical graphql-config for setting schema and documents or \`parserOptions.graphQLConfig\` for programmatic usage.`
+      );
+  try {
+    const { filePath } = options, { document } = parseGraphQLSDL(filePath, code, { noLocation: !1 });
+    let project, schema, documents;
+    {
+      const gqlConfig = loadGraphQLConfig(options), realFilepath = filePath.replace(VIRTUAL_DOCUMENT_REGEX, "");
+      project = gqlConfig.getProjectForFile(realFilepath), documents = getDocuments(project);
+    }
+    try {
+      schema = getSchema(project);
+    } catch (error) {
+      throw error instanceof Error && (error.message = `Error while loading schema: ${error.message}`), error;
+    }
+    const rootTree = convertToESTree(document, schema);
+    return {
+      services: {
+        schema,
+        siblingOperations: getSiblings(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}`), error instanceof GraphQLError) {
+      const location = error.locations?.[0];
+      throw {
+        index: error.positions?.[0],
+        ...location && {
+          lineNumber: location.line,
+          column: location.column - 1
+        },
+        message: error.message
+      };
+    }
+    throw error;
+  }
+}
+export {
+  parseForESLint
+};

package/esm/processor.d.mts

@@ -0,0 +1,13 @@
+import { Linter } from 'eslint';
+
+type Block = Linter.ProcessorFile & {
+    lineOffset: number;
+    offset: number;
+};
+declare const processor: {
+    supportsAutofix: true;
+    preprocess(code: string, filePath: string): (string | Block)[];
+    postprocess(messages: Linter.LintMessage[][], filePath: string): Linter.LintMessage[];
+};
+
+export { Block, processor };