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

package/esm/schema.js

@@ -0,0 +1,27 @@
+import "./chunk-U3TKCM4X.js";
+import debugFactory from "debug";
+import fg from "fast-glob";
+import { GraphQLSchema } from "graphql";
+import { ModuleCache } from "./cache.js";
+const schemaCache = new ModuleCache(), debug = debugFactory("graphql-eslint:schema");
+function getSchema(project) {
+  const schemaKey = project.schema;
+  if (!schemaKey)
+    return null;
+  const cache = schemaCache.get(schemaKey);
+  if (cache)
+    return cache;
+  debug("Loading schema from %o", project.schema);
+  const schema = project.loadSchemaSync(project.schema, "GraphQLSchema", {
+    pluckConfig: project.extensions.pluckConfig
+  });
+  if (debug.enabled) {
+    debug("Schema loaded: %o", schema instanceof GraphQLSchema);
+    const schemaPaths = fg.sync(project.schema, { absolute: !0 });
+    debug("Schema pointers %O", schemaPaths);
+  }
+  return schemaCache.set(schemaKey, schema), schema;
+}
+export {
+  getSchema
+};

package/esm/siblings.d.mts

@@ -0,0 +1,24 @@
+import { Source } from '@graphql-tools/utils';
+import { FragmentDefinitionNode, OperationDefinitionNode, SelectionSetNode, OperationTypeNode } from 'graphql';
+
+type FragmentSource = {
+    filePath: string;
+    document: FragmentDefinitionNode;
+};
+type OperationSource = {
+    filePath: string;
+    document: OperationDefinitionNode;
+};
+type SiblingOperations = {
+    available: boolean;
+    getFragment(fragmentName: string): FragmentSource[];
+    getFragments(): FragmentSource[];
+    getFragmentByType(typeName: string): FragmentSource[];
+    getFragmentsInUse(baseOperation: FragmentDefinitionNode | OperationDefinitionNode | SelectionSetNode, recursive?: boolean): FragmentDefinitionNode[];
+    getOperation(operationName: string): OperationSource[];
+    getOperations(): OperationSource[];
+    getOperationByType(operationType: OperationTypeNode): OperationSource[];
+};
+declare function getSiblings(documents: Source[]): SiblingOperations;
+
+export { FragmentSource, OperationSource, SiblingOperations, getSiblings };

package/esm/siblings.js

@@ -0,0 +1,80 @@
+import "./chunk-U3TKCM4X.js";
+import {
+  Kind,
+  visit
+} from "graphql";
+import { logger } from "./utils.js";
+const siblingOperationsCache = /* @__PURE__ */ new Map();
+function getSiblings(documents) {
+  if (documents.length === 0) {
+    let printed = !1;
+    const noopWarn = () => (printed || (logger.warn(
+      "getSiblingOperations was called without any operations. Make sure to set graphql-config `documents` field to make this feature available! See https://the-guild.dev/graphql/config/docs/user/documents for more info"
+    ), printed = !0), []);
+    return {
+      available: !1,
+      getFragment: noopWarn,
+      getFragments: noopWarn,
+      getFragmentByType: noopWarn,
+      getFragmentsInUse: noopWarn,
+      getOperation: noopWarn,
+      getOperations: noopWarn,
+      getOperationByType: noopWarn
+    };
+  }
+  const value = siblingOperationsCache.get(documents);
+  if (value)
+    return value;
+  let fragmentsCache = null;
+  const getFragments = () => {
+    if (fragmentsCache === null) {
+      const result = [];
+      for (const source of documents)
+        for (const definition of source.document?.definitions || [])
+          definition.kind === Kind.FRAGMENT_DEFINITION && result.push({
+            filePath: source.location,
+            document: definition
+          });
+      fragmentsCache = result;
+    }
+    return fragmentsCache;
+  };
+  let cachedOperations = null;
+  const getOperations = () => {
+    if (cachedOperations === null) {
+      const result = [];
+      for (const source of documents)
+        for (const definition of source.document?.definitions || [])
+          definition.kind === Kind.OPERATION_DEFINITION && result.push({
+            filePath: source.location,
+            document: definition
+          });
+      cachedOperations = result;
+    }
+    return cachedOperations;
+  }, getFragment = (name) => getFragments().filter((f) => f.document.name.value === name), collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => (visit(selectable, {
+    FragmentSpread(spread) {
+      const fragmentName = spread.name.value, [fragment] = getFragment(fragmentName);
+      if (!fragment) {
+        logger.warn(
+          `Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`
+        );
+        return;
+      }
+      collected.has(fragmentName) || (collected.set(fragmentName, fragment.document), recursive && collectFragments(fragment.document, recursive, collected));
+    }
+  }), collected), siblingOperations = {
+    available: !0,
+    getFragment,
+    getFragments,
+    getFragmentByType: (typeName) => getFragments().filter((f) => f.document.typeCondition.name.value === typeName),
+    getFragmentsInUse: (selectable, recursive = !0) => Array.from(collectFragments(selectable, recursive).values()),
+    getOperation: (name) => getOperations().filter((o) => o.document.name?.value === name),
+    getOperations,
+    getOperationByType: (type) => getOperations().filter((o) => o.document.operation === type)
+  };
+  return siblingOperationsCache.set(documents, siblingOperations), siblingOperations;
+}
+export {
+  getSiblings
+};

package/esm/types.d.mts

@@ -0,0 +1,75 @@
+import { Linter, Rule, AST } from 'eslint';
+import * as ESTree from 'estree';
+import { GraphQLSchema, ASTKindToNode } from 'graphql';
+import { JSONSchema } from 'json-schema-to-ts';
+import { SiblingOperations } from './siblings.mjs';
+import { GraphQLESTreeNode } from './estree-converter/types.mjs';
+import { IGraphQLConfig } from 'graphql-config';
+import '@graphql-tools/utils';
+
+type Schema = GraphQLSchema | null;
+type Pointer = string | string[];
+interface ParserOptions {
+    graphQLConfig?: IGraphQLConfig;
+    filePath: string;
+}
+type ParserServices = {
+    schema: Schema;
+    siblingOperations: SiblingOperations;
+};
+type GraphQLESLintParseResult = Linter.ESLintParseResult & {
+    services: ParserServices;
+};
+type Location = AST.SourceLocation | ESTree.Position;
+type ReportDescriptorLocation = {
+    loc: Location;
+} | {
+    node: {
+        loc: Location;
+    };
+};
+type ReportDescriptor = ReportDescriptorLocation & Rule.ReportDescriptorMessage & Rule.ReportDescriptorOptions;
+type GraphQLESLintRuleContext<Options = any[]> = Omit<Rule.RuleContext, 'options' | 'parserServices' | 'report'> & {
+    options: Options;
+    parserServices: ParserServices;
+    report(descriptor: ReportDescriptor): void;
+};
+type CategoryType = 'Operations' | 'Schema';
+type RuleMetaDataDocs = Required<Rule.RuleMetaData>['docs'];
+type RuleDocsInfo<T> = Omit<RuleMetaDataDocs, 'category' | 'suggestion'> & {
+    category: CategoryType | CategoryType[];
+    requiresSchema?: true;
+    requiresSiblings?: true;
+    examples?: {
+        title: string;
+        code: string;
+        usage?: T;
+    }[];
+    configOptions?: T | {
+        schema?: T;
+        operations?: T;
+    };
+    graphQLJSRuleName?: string;
+    isDisabledForAllConfig?: true;
+};
+type GraphQLESLintRuleListener<WithTypeInfo extends boolean = false> = Record<string, any> & {
+    [K in keyof ASTKindToNode]?: (node: GraphQLESTreeNode<ASTKindToNode[K], WithTypeInfo>) => void;
+};
+type GraphQLESLintRule<Options = [], WithTypeInfo extends boolean = false> = {
+    meta: Omit<Rule.RuleMetaData, 'docs' | 'schema'> & {
+        docs?: RuleDocsInfo<Options>;
+        schema: Readonly<JSONSchema> | [];
+    };
+    create(context: GraphQLESLintRuleContext<Options>): GraphQLESLintRuleListener<WithTypeInfo>;
+};
+type ValueOf<T> = T[keyof T];
+type Id<T> = {
+    [P in keyof T]: T[P];
+} & {};
+type OmitDistributive<T, K extends PropertyKey> = T extends object ? Id<OmitRecursively<T, K>> : T;
+type OmitRecursively<T extends object, K extends PropertyKey> = Omit<{
+    [P in keyof T]: OmitDistributive<T[P], K>;
+}, K>;
+type ConfigName = 'operations-all' | 'operations-recommended' | 'schema-all' | 'schema-recommended' | 'schema-relay';
+
+export { CategoryType, ConfigName, GraphQLESLintParseResult, GraphQLESLintRule, GraphQLESLintRuleContext, GraphQLESLintRuleListener, OmitRecursively, ParserOptions, ParserServices, Pointer, ReportDescriptor, RuleDocsInfo, Schema, ValueOf };

package/esm/utils.d.mts

@@ -0,0 +1,45 @@
+import { AST } from 'eslint';
+import { Position } from 'estree';
+import { GraphQLSchema, ASTNode, Kind } from 'graphql';
+import { SiblingOperations } from './siblings.mjs';
+import { GraphQLESLintRuleContext } from './types.mjs';
+import { GraphQLESTreeNode } from './estree-converter/types.mjs';
+import '@graphql-tools/utils';
+import 'json-schema-to-ts';
+import 'graphql-config';
+
+declare function requireSiblingsOperations(ruleId: string, context: GraphQLESLintRuleContext): SiblingOperations | never;
+declare function requireGraphQLSchemaFromContext(ruleId: string, context: GraphQLESLintRuleContext): GraphQLSchema | never;
+declare const logger: {
+    error: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+};
+declare const normalizePath: (path: string) => string;
+declare const VIRTUAL_DOCUMENT_REGEX: RegExp;
+declare const CWD: string;
+declare const getTypeName: (node: ASTNode) => string;
+declare const TYPES_KINDS: readonly [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.ENUM_TYPE_DEFINITION, Kind.SCALAR_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.UNION_TYPE_DEFINITION];
+type CaseStyle = 'camelCase' | 'kebab-case' | 'PascalCase' | 'snake_case' | 'UPPER_CASE';
+declare const pascalCase: (str: string) => string;
+declare const camelCase: (str: string) => string;
+declare const convertCase: (style: CaseStyle, str: string) => string;
+declare function getLocation(start: Position, fieldName?: string): AST.SourceLocation;
+declare const REPORT_ON_FIRST_CHARACTER: {
+    column: number;
+    line: number;
+};
+declare const ARRAY_DEFAULT_OPTIONS: {
+    readonly type: "array";
+    readonly uniqueItems: true;
+    readonly minItems: 1;
+    readonly items: {
+        readonly type: "string";
+    };
+};
+declare const englishJoinWords: (words: string[]) => string;
+type Truthy<T> = T extends '' | 0 | false | null | undefined ? never : T;
+declare function truthy<T>(value: T): value is Truthy<T>;
+declare function displayNodeName(node: GraphQLESTreeNode<ASTNode>): string;
+declare function getNodeName(node: GraphQLESTreeNode<ASTNode>): string;
+
+export { ARRAY_DEFAULT_OPTIONS, CWD, CaseStyle, REPORT_ON_FIRST_CHARACTER, TYPES_KINDS, VIRTUAL_DOCUMENT_REGEX, camelCase, convertCase, displayNodeName, englishJoinWords, getLocation, getNodeName, getTypeName, logger, normalizePath, pascalCase, requireGraphQLSchemaFromContext, requireSiblingsOperations, truthy };

package/esm/utils.js

@@ -0,0 +1,144 @@
+import "./chunk-U3TKCM4X.js";
+import { Kind } from "graphql";
+import lowerCase from "lodash.lowercase";
+function requireSiblingsOperations(ruleId, context) {
+  const { siblingOperations } = context.sourceCode.parserServices;
+  if (!siblingOperations.available)
+    throw new Error(
+      `Rule \`${ruleId}\` requires graphql-config \`documents\` field to be set and loaded. See https://the-guild.dev/graphql/config/docs/user/documents for more info`
+    );
+  return siblingOperations;
+}
+function requireGraphQLSchemaFromContext(ruleId, context) {
+  const { schema } = context.sourceCode.parserServices;
+  if (!schema)
+    throw new Error(
+      `Rule \`${ruleId}\` requires graphql-config \`schema\` field to be set and loaded. See https://the-guild.dev/graphql/config/docs/user/schema for more info`
+    );
+  return schema;
+}
+const chalk = {
+  red: (str) => `\x1B[31m${str}\x1B[39m`,
+  yellow: (str) => `\x1B[33m${str}\x1B[39m`
+}, logger = {
+  error: (...args) => (
+    // eslint-disable-next-line no-console
+    console.error(chalk.red("error"), "[graphql-eslint]", ...args)
+  ),
+  warn: (...args) => (
+    // eslint-disable-next-line no-console
+    console.warn(chalk.yellow("warning"), "[graphql-eslint]", ...args)
+  )
+}, normalizePath = (path) => (path || "").replace(/\\/g, "/"), VIRTUAL_DOCUMENT_REGEX = /\/\d+_document.graphql$/, CWD = process.cwd(), getTypeName = (node) => "type" in node ? getTypeName(node.type) : "name" in node && node.name ? node.name.value : "", TYPES_KINDS = [
+  Kind.OBJECT_TYPE_DEFINITION,
+  Kind.INTERFACE_TYPE_DEFINITION,
+  Kind.ENUM_TYPE_DEFINITION,
+  Kind.SCALAR_TYPE_DEFINITION,
+  Kind.INPUT_OBJECT_TYPE_DEFINITION,
+  Kind.UNION_TYPE_DEFINITION
+], pascalCase = (str) => lowerCase(str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(""), camelCase = (str) => {
+  const result = pascalCase(str);
+  return result.charAt(0).toLowerCase() + result.slice(1);
+}, convertCase = (style, str) => {
+  switch (style) {
+    case "camelCase":
+      return camelCase(str);
+    case "PascalCase":
+      return pascalCase(str);
+    case "snake_case":
+      return lowerCase(str).replace(/ /g, "_");
+    case "UPPER_CASE":
+      return lowerCase(str).replace(/ /g, "_").toUpperCase();
+    case "kebab-case":
+      return lowerCase(str).replace(/ /g, "-");
+  }
+};
+function getLocation(start, fieldName = "") {
+  const { line, column } = start;
+  return {
+    start: {
+      line,
+      column
+    },
+    end: {
+      line,
+      column: column + fieldName.length
+    }
+  };
+}
+const REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 }, ARRAY_DEFAULT_OPTIONS = {
+  type: "array",
+  uniqueItems: !0,
+  minItems: 1,
+  items: {
+    type: "string"
+  }
+}, englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words);
+function truthy(value) {
+  return !!value;
+}
+const DisplayNodeNameMap = {
+  [Kind.OBJECT_TYPE_DEFINITION]: "type",
+  [Kind.OBJECT_TYPE_EXTENSION]: "type",
+  [Kind.INTERFACE_TYPE_DEFINITION]: "interface",
+  [Kind.INTERFACE_TYPE_EXTENSION]: "interface",
+  [Kind.ENUM_TYPE_DEFINITION]: "enum",
+  [Kind.ENUM_TYPE_EXTENSION]: "enum",
+  [Kind.SCALAR_TYPE_DEFINITION]: "scalar",
+  [Kind.INPUT_OBJECT_TYPE_DEFINITION]: "input",
+  [Kind.INPUT_OBJECT_TYPE_EXTENSION]: "input",
+  [Kind.UNION_TYPE_DEFINITION]: "union",
+  [Kind.UNION_TYPE_EXTENSION]: "union",
+  [Kind.DIRECTIVE_DEFINITION]: "directive",
+  [Kind.FIELD_DEFINITION]: "field",
+  [Kind.ENUM_VALUE_DEFINITION]: "enum value",
+  [Kind.INPUT_VALUE_DEFINITION]: "input value",
+  [Kind.ARGUMENT]: "argument",
+  [Kind.VARIABLE]: "variable",
+  [Kind.FRAGMENT_DEFINITION]: "fragment",
+  [Kind.OPERATION_DEFINITION]: "operation",
+  [Kind.FIELD]: "field"
+};
+function displayNodeName(node) {
+  return `${node.kind === Kind.OPERATION_DEFINITION ? node.operation : DisplayNodeNameMap[node.kind]} "${"alias" in node && node.alias?.value || "name" in node && node.name?.value}"`;
+}
+function getNodeName(node) {
+  switch (node.kind) {
+    case Kind.OBJECT_TYPE_DEFINITION:
+    case Kind.OBJECT_TYPE_EXTENSION:
+    case Kind.INTERFACE_TYPE_DEFINITION:
+    case Kind.ENUM_TYPE_DEFINITION:
+    case Kind.SCALAR_TYPE_DEFINITION:
+    case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+    case Kind.UNION_TYPE_DEFINITION:
+    case Kind.DIRECTIVE_DEFINITION:
+      return displayNodeName(node);
+    case Kind.FIELD_DEFINITION:
+    case Kind.INPUT_VALUE_DEFINITION:
+    case Kind.ENUM_VALUE_DEFINITION:
+      return `${displayNodeName(node)} in ${displayNodeName(node.parent)}`;
+    case Kind.OPERATION_DEFINITION:
+      return node.name ? displayNodeName(node) : node.operation;
+  }
+  return "";
+}
+export {
+  ARRAY_DEFAULT_OPTIONS,
+  CWD,
+  REPORT_ON_FIRST_CHARACTER,
+  TYPES_KINDS,
+  VIRTUAL_DOCUMENT_REGEX,
+  camelCase,
+  convertCase,
+  displayNodeName,
+  englishJoinWords,
+  getLocation,
+  getNodeName,
+  getTypeName,
+  logger,
+  normalizePath,
+  pascalCase,
+  requireGraphQLSchemaFromContext,
+  requireSiblingsOperations,
+  truthy
+};