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

package/esm/rules/strict-id-in-types.js

@@ -0,0 +1,169 @@
+import "../chunk-BMTV3EA2.js";
+import { Kind } from "graphql";
+import {
+  ARRAY_DEFAULT_OPTIONS,
+  displayNodeName,
+  englishJoinWords,
+  requireGraphQLSchemaFromContext,
+  truthy
+} from "../utils.js";
+const RULE_ID = "strict-id-in-types";
+const schema = {
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      acceptedIdNames: {
+        ...ARRAY_DEFAULT_OPTIONS,
+        default: ["id"]
+      },
+      acceptedIdTypes: {
+        ...ARRAY_DEFAULT_OPTIONS,
+        default: ["ID"]
+      },
+      exceptions: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          types: {
+            ...ARRAY_DEFAULT_OPTIONS,
+            description: "This is used to exclude types with names that match one of the specified values."
+          },
+          suffixes: {
+            ...ARRAY_DEFAULT_OPTIONS,
+            description: "This is used to exclude types with names with suffixes that match one of the specified values."
+          }
+        }
+      }
+    }
+  }
+};
+const rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.",
+      category: "Schema",
+      recommended: true,
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: true,
+      examples: [
+        {
+          title: "Incorrect",
+          usage: [
+            {
+              acceptedIdNames: ["id", "_id"],
+              acceptedIdTypes: ["ID"],
+              exceptions: { suffixes: ["Payload"] }
+            }
+          ],
+          code: (
+            /* GraphQL */
+            `
+            # Incorrect field name
+            type InvalidFieldName {
+              key: ID!
+            }
+
+            # Incorrect field type
+            type InvalidFieldType {
+              id: String!
+            }
+
+            # Incorrect exception suffix
+            type InvalidSuffixResult {
+              data: String!
+            }
+
+            # Too many unique identifiers. Must only contain one.
+            type InvalidFieldName {
+              id: ID!
+              _id: ID!
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [
+            {
+              acceptedIdNames: ["id", "_id"],
+              acceptedIdTypes: ["ID"],
+              exceptions: { types: ["Error"], suffixes: ["Payload"] }
+            }
+          ],
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              id: ID!
+            }
+
+            type Post {
+              _id: ID!
+            }
+
+            type CreateUserPayload {
+              data: String!
+            }
+
+            type Error {
+              message: String!
+            }
+          `
+          )
+        }
+      ]
+    },
+    schema
+  },
+  create(context) {
+    const options = {
+      acceptedIdNames: ["id"],
+      acceptedIdTypes: ["ID"],
+      exceptions: {},
+      ...context.options[0]
+    };
+    const schema2 = requireGraphQLSchemaFromContext(RULE_ID, context);
+    const rootTypeNames = [
+      schema2.getQueryType(),
+      schema2.getMutationType(),
+      schema2.getSubscriptionType()
+    ].filter(truthy).map((type) => type.name);
+    const selector = `ObjectTypeDefinition[name.value!=/^(${rootTypeNames.join("|")})$/]`;
+    return {
+      [selector](node) {
+        var _a, _b, _c;
+        const typeName = node.name.value;
+        const shouldIgnoreNode = ((_a = options.exceptions.types) == null ? void 0 : _a.includes(typeName)) || ((_b = options.exceptions.suffixes) == null ? void 0 : _b.some((suffix) => typeName.endsWith(suffix)));
+        if (shouldIgnoreNode) {
+          return;
+        }
+        const validIds = (_c = node.fields) == null ? void 0 : _c.filter((field) => {
+          const fieldNode = field.rawNode();
+          const isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value);
+          let isValidIdType = false;
+          if (fieldNode.type.kind === Kind.NON_NULL_TYPE && fieldNode.type.type.kind === Kind.NAMED_TYPE) {
+            isValidIdType = options.acceptedIdTypes.includes(fieldNode.type.type.name.value);
+          }
+          return isValidIdName && isValidIdType;
+        });
+        if ((validIds == null ? void 0 : validIds.length) !== 1) {
+          const pluralNamesSuffix = options.acceptedIdNames.length > 1 ? "s" : "";
+          const pluralTypesSuffix = options.acceptedIdTypes.length > 1 ? "s" : "";
+          context.report({
+            node: node.name,
+            message: `${displayNodeName(node)} must have exactly one non-nullable unique identifier.
+Accepted name${pluralNamesSuffix}: ${englishJoinWords(options.acceptedIdNames)}.
+Accepted type${pluralTypesSuffix}: ${englishJoinWords(options.acceptedIdTypes)}.`
+          });
+        }
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/unique-fragment-name.d.mts

@@ -0,0 +1,13 @@
+import { ExecutableDefinitionNode } from 'graphql';
+import { GraphQLESTreeNode } from '../estree-converter/types.mjs';
+import { c as GraphQLESLintRuleContext, f as GraphQLESLintRule } from '../types-ace77d86.js';
+import 'eslint';
+import 'estree';
+import '@graphql-tools/utils';
+import 'graphql-config';
+import 'json-schema-to-ts';
+
+declare const checkNode: (context: GraphQLESLintRuleContext, node: GraphQLESTreeNode<ExecutableDefinitionNode>, ruleId: string) => void;
+declare const rule: GraphQLESLintRule;
+
+export { checkNode, rule };

package/esm/rules/unique-fragment-name.js

@@ -0,0 +1,94 @@
+import "../chunk-BMTV3EA2.js";
+import { relative } from "path";
+import { Kind } from "graphql";
+import { CWD, normalizePath, requireSiblingsOperations, VIRTUAL_DOCUMENT_REGEX } from "../utils.js";
+const RULE_ID = "unique-fragment-name";
+const checkNode = (context, node, ruleId) => {
+  const documentName = node.name.value;
+  const siblings = requireSiblingsOperations(ruleId, context);
+  const siblingDocuments = node.kind === Kind.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName);
+  const filepath = context.getFilename();
+  const conflictingDocuments = siblingDocuments.filter((f) => {
+    var _a;
+    const isSameName = ((_a = f.document.name) == null ? void 0 : _a.value) === documentName;
+    const isSamePath = normalizePath(f.filePath) === normalizePath(filepath);
+    return isSameName && !isSamePath;
+  });
+  if (conflictingDocuments.length > 0) {
+    context.report({
+      messageId: ruleId,
+      data: {
+        documentName,
+        summary: conflictingDocuments.map((f) => `	${relative(CWD, f.filePath.replace(VIRTUAL_DOCUMENT_REGEX, ""))}`).join("\n")
+      },
+      // @ts-expect-error name will exist
+      node: node.name
+    });
+  }
+};
+const rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Operations",
+      description: "Enforce unique fragment names across your project.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSiblings: true,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            # user.fragment.graphql
+            fragment UserFields on User {
+              id
+              name
+              fullName
+            }
+
+            # user-fields.graphql
+            fragment UserFields on User {
+              id
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            # user.fragment.graphql
+            fragment AllUserFields on User {
+              id
+              name
+              fullName
+            }
+
+            # user-fields.graphql
+            fragment UserFields on User {
+              id
+            }
+          `
+          )
+        }
+      ]
+    },
+    messages: {
+      [RULE_ID]: 'Fragment named "{{ documentName }}" already defined in:\n{{ summary }}'
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      FragmentDefinition(node) {
+        checkNode(context, node, RULE_ID);
+      }
+    };
+  }
+};
+export {
+  checkNode,
+  rule
+};

package/esm/rules/unique-operation-name.d.mts

@@ -0,0 +1,12 @@
+import { f as GraphQLESLintRule } from '../types-ace77d86.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 rule: GraphQLESLintRule;
+
+export { rule };

package/esm/rules/unique-operation-name.js

@@ -0,0 +1,72 @@
+import "../chunk-BMTV3EA2.js";
+import { checkNode } from "./unique-fragment-name.js";
+const RULE_ID = "unique-operation-name";
+const rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Operations",
+      description: "Enforce unique operation names across your project.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSiblings: true,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            # foo.query.graphql
+            query user {
+              user {
+                id
+              }
+            }
+
+            # bar.query.graphql
+            query user {
+              me {
+                id
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            # foo.query.graphql
+            query user {
+              user {
+                id
+              }
+            }
+
+            # bar.query.graphql
+            query me {
+              me {
+                id
+              }
+            }
+          `
+          )
+        }
+      ]
+    },
+    messages: {
+      [RULE_ID]: 'Operation named "{{ documentName }}" already defined in:\n{{ summary }}'
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      "OperationDefinition[name!=undefined]"(node) {
+        checkNode(context, node, RULE_ID);
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/schema.d.mts

@@ -0,0 +1,12 @@
+import { GraphQLProjectConfig } from 'graphql-config';
+import { P as ParserOptions, S as Schema } from './types-ace77d86.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import './estree-converter/types.mjs';
+
+declare function getSchema(project: GraphQLProjectConfig, schemaOptions?: ParserOptions['schemaOptions']): Schema;
+
+export { getSchema };

package/esm/schema.js

@@ -0,0 +1,32 @@
+import "./chunk-BMTV3EA2.js";
+import debugFactory from "debug";
+import fg from "fast-glob";
+import { GraphQLSchema } from "graphql";
+import { ModuleCache } from "./cache.js";
+const schemaCache = new ModuleCache();
+const debug = debugFactory("graphql-eslint:schema");
+function getSchema(project, schemaOptions) {
+  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", {
+    ...schemaOptions,
+    pluckConfig: project.extensions.pluckConfig
+  });
+  if (debug.enabled) {
+    debug("Schema loaded: %o", schema instanceof GraphQLSchema);
+    const schemaPaths = fg.sync(project.schema, { absolute: true });
+    debug("Schema pointers %O", schemaPaths);
+  }
+  schemaCache.set(schemaKey, schema);
+  return schema;
+}
+export {
+  getSchema
+};

package/esm/siblings.d.mts

@@ -0,0 +1,8 @@
+import 'graphql';
+import 'graphql-config';
+export { F as FragmentSource, h as OperationSource, g as SiblingOperations, i as getSiblings } from './types-ace77d86.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'json-schema-to-ts';
+import './estree-converter/types.mjs';

package/esm/siblings.js

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

package/esm/types-ace77d86.d.ts

@@ -0,0 +1,107 @@
+import { GraphQLParseOptions } from '@graphql-tools/utils';
+import { Linter, Rule, AST } from 'eslint';
+import * as ESTree from 'estree';
+import { FragmentDefinitionNode, OperationDefinitionNode, SelectionSetNode, OperationTypeNode, GraphQLSchema, ASTKindToNode } from 'graphql';
+import { GraphQLProjectConfig, IExtensions, IGraphQLProject } from 'graphql-config';
+import { JSONSchema } from 'json-schema-to-ts';
+import { GraphQLESTreeNode } from './estree-converter/types.mjs';
+
+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(project?: GraphQLProjectConfig, documents?: ParserOptions['documents']): SiblingOperations;
+
+type Schema = GraphQLSchema | null;
+type Pointer = string | string[];
+interface ParserOptions {
+    schema?: Pointer | Record<string, {
+        headers: Record<string, string>;
+    }>;
+    documents?: Pointer;
+    extensions?: IExtensions;
+    include?: Pointer;
+    exclude?: Pointer;
+    projects?: Record<string, IGraphQLProject>;
+    schemaOptions?: Omit<GraphQLParseOptions, 'assumeValidSDL'> & {
+        headers: Record<string, string>;
+    };
+    graphQLParserOptions?: Omit<GraphQLParseOptions, 'noLocation'>;
+    skipGraphQLConfig?: boolean;
+    filePath: string;
+    /** @deprecated Use `documents` instead */
+    operations?: Pointer;
+}
+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>;
+
+export { CategoryType as C, FragmentSource as F, GraphQLESLintParseResult as G, OmitRecursively as O, ParserOptions as P, ReportDescriptor as R, Schema as S, ValueOf as V, Pointer as a, ParserServices as b, GraphQLESLintRuleContext as c, RuleDocsInfo as d, GraphQLESLintRuleListener as e, GraphQLESLintRule as f, SiblingOperations as g, OperationSource as h, getSiblings as i };

package/esm/types.d.mts

@@ -0,0 +1,8 @@
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+export { C as CategoryType, G as GraphQLESLintParseResult, f as GraphQLESLintRule, c as GraphQLESLintRuleContext, e as GraphQLESLintRuleListener, O as OmitRecursively, P as ParserOptions, b as ParserServices, a as Pointer, R as ReportDescriptor, d as RuleDocsInfo, S as Schema, V as ValueOf } from './types-ace77d86.js';
+import './estree-converter/types.mjs';