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

package/cjs/rules/strict-id-in-types.d.ts

@@ -0,0 +1,66 @@
+import { FromSchema } from 'json-schema-to-ts';
+import { GraphQLESLintRule } from '../types.js';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import '../siblings.js';
+import '@graphql-tools/utils';
+import '../estree-converter/types.js';
+import 'graphql-config';
+
+declare const schema: {
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly acceptedIdNames: {
+                readonly default: readonly ["id"];
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly acceptedIdTypes: {
+                readonly default: readonly ["ID"];
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly exceptions: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly types: {
+                        readonly description: "This is used to exclude types with names that match one of the specified values.";
+                        readonly type: "array";
+                        readonly uniqueItems: true;
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly suffixes: {
+                        readonly description: "This is used to exclude types with names with suffixes that match one of the specified values.";
+                        readonly type: "array";
+                        readonly uniqueItems: true;
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };

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

@@ -0,0 +1,168 @@
+"use strict";
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var strict_id_in_types_exports = {};
+__export(strict_id_in_types_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(strict_id_in_types_exports);
+var import_graphql = require("graphql"), import_utils = require("../utils.js");
+const RULE_ID = "strict-id-in-types", schema = {
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: !1,
+    properties: {
+      acceptedIdNames: {
+        ...import_utils.ARRAY_DEFAULT_OPTIONS,
+        default: ["id"]
+      },
+      acceptedIdTypes: {
+        ...import_utils.ARRAY_DEFAULT_OPTIONS,
+        default: ["ID"]
+      },
+      exceptions: {
+        type: "object",
+        additionalProperties: !1,
+        properties: {
+          types: {
+            ...import_utils.ARRAY_DEFAULT_OPTIONS,
+            description: "This is used to exclude types with names that match one of the specified values."
+          },
+          suffixes: {
+            ...import_utils.ARRAY_DEFAULT_OPTIONS,
+            description: "This is used to exclude types with names with suffixes that match one of the specified values."
+          }
+        }
+      }
+    }
+  }
+}, 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: !0,
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: !0,
+      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]
+    }, schema2 = (0, import_utils.requireGraphQLSchemaFromContext)(RULE_ID, context);
+    return {
+      [`ObjectTypeDefinition[name.value!=/^(${[
+        schema2.getQueryType(),
+        schema2.getMutationType(),
+        schema2.getSubscriptionType()
+      ].filter(import_utils.truthy).map((type) => type.name).join("|")})$/]`](node) {
+        const typeName = node.name.value;
+        if (options.exceptions.types?.includes(typeName) || options.exceptions.suffixes?.some((suffix) => typeName.endsWith(suffix)))
+          return;
+        if (node.fields?.filter((field) => {
+          const fieldNode = field.rawNode(), isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value);
+          let isValidIdType = !1;
+          return fieldNode.type.kind === import_graphql.Kind.NON_NULL_TYPE && fieldNode.type.type.kind === import_graphql.Kind.NAMED_TYPE && (isValidIdType = options.acceptedIdTypes.includes(fieldNode.type.type.name.value)), isValidIdName && isValidIdType;
+        })?.length !== 1) {
+          const pluralNamesSuffix = options.acceptedIdNames.length > 1 ? "s" : "", pluralTypesSuffix = options.acceptedIdTypes.length > 1 ? "s" : "";
+          context.report({
+            node: node.name,
+            message: `${(0, import_utils.displayNodeName)(node)} must have exactly one non-nullable unique identifier.
+Accepted name${pluralNamesSuffix}: ${(0, import_utils.englishJoinWords)(options.acceptedIdNames)}.
+Accepted type${pluralTypesSuffix}: ${(0, import_utils.englishJoinWords)(options.acceptedIdTypes)}.`
+          });
+        }
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/unique-enum-value-names.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLESLintRule } from '../types.js';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import '../siblings.js';
+import '@graphql-tools/utils';
+import '../estree-converter/types.js';
+import 'graphql-config';
+
+declare const rule: GraphQLESLintRule;
+
+export { rule };

package/cjs/rules/unique-enum-value-names.js

@@ -0,0 +1,91 @@
+"use strict";
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var unique_enum_value_names_exports = {};
+__export(unique_enum_value_names_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(unique_enum_value_names_exports);
+var import_graphql = require("graphql"), import_utils = require("../utils.js");
+const rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    docs: {
+      url: "https://the-guild.dev/graphql/eslint/rules/unique-enum-value-names",
+      category: "Schema",
+      recommended: !0,
+      description: `A GraphQL enum type is only valid if all its values are uniquely named.
+> This rule disallows case-insensitive enum values duplicates too.`,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            enum MyEnum {
+              Value
+              VALUE
+              ValuE
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            enum MyEnum {
+              Value1
+              Value2
+              Value3
+            }
+          `
+          )
+        }
+      ]
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      [[import_graphql.Kind.ENUM_TYPE_DEFINITION, import_graphql.Kind.ENUM_TYPE_EXTENSION].join(",")](node) {
+        const duplicates = node.values?.filter(
+          (item, index, array) => array.findIndex((v) => v.name.value.toLowerCase() === item.name.value.toLowerCase()) !== index
+        );
+        for (const duplicate of duplicates || []) {
+          const enumName = duplicate.name.value;
+          context.report({
+            node: duplicate.name,
+            message: `Unexpected case-insensitive enum values duplicates for ${(0, import_utils.getNodeName)(
+              duplicate
+            )}`,
+            suggest: [
+              {
+                desc: `Remove \`${enumName}\` enum value`,
+                fix: (fixer) => fixer.remove(duplicate)
+              }
+            ]
+          });
+        }
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/unique-fragment-name.d.ts

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

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

@@ -0,0 +1,106 @@
+"use strict";
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var unique_fragment_name_exports = {};
+__export(unique_fragment_name_exports, {
+  checkNode: () => checkNode,
+  rule: () => rule
+});
+module.exports = __toCommonJS(unique_fragment_name_exports);
+var import_node_path = require("node:path"), import_graphql = require("graphql"), import_utils = require("../utils.js");
+const RULE_ID = "unique-fragment-name", checkNode = (context, node, ruleId) => {
+  const documentName = node.name.value, siblings = (0, import_utils.requireSiblingsOperations)(ruleId, context), siblingDocuments = node.kind === import_graphql.Kind.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName), filepath = context.filename, conflictingDocuments = siblingDocuments.filter((f) => {
+    const isSameName = f.document.name?.value === documentName, isSamePath = (0, import_utils.normalizePath)(f.filePath) === (0, import_utils.normalizePath)(filepath);
+    return isSameName && !isSamePath;
+  });
+  conflictingDocuments.length > 0 && context.report({
+    messageId: ruleId,
+    data: {
+      documentName,
+      summary: conflictingDocuments.map((f) => `	${(0, import_node_path.relative)(import_utils.CWD, f.filePath.replace(import_utils.VIRTUAL_DOCUMENT_REGEX, ""))}`).join(`
+`)
+    },
+    // @ts-expect-error name will exist
+    node: node.name
+  });
+}, 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: !0,
+      recommended: !0,
+      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:
+{{ summary }}`
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      FragmentDefinition(node) {
+        checkNode(context, node, RULE_ID);
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkNode,
+  rule
+});

package/cjs/rules/unique-operation-name.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLESLintRule } from '../types.js';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import '../siblings.js';
+import '@graphql-tools/utils';
+import '../estree-converter/types.js';
+import 'graphql-config';
+
+declare const rule: GraphQLESLintRule;
+
+export { rule };

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

@@ -0,0 +1,93 @@
+"use strict";
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var unique_operation_name_exports = {};
+__export(unique_operation_name_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(unique_operation_name_exports);
+var import_unique_fragment_name = require("./unique-fragment-name.js");
+const RULE_ID = "unique-operation-name", 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: !0,
+      recommended: !0,
+      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:
+{{ summary }}`
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      "OperationDefinition[name!=undefined]"(node) {
+        (0, import_unique_fragment_name.checkNode)(context, node, RULE_ID);
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/schema.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLProjectConfig } from 'graphql-config';
+import { Schema } from './types.js';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import './siblings.js';
+import '@graphql-tools/utils';
+import './estree-converter/types.js';
+
+declare function getSchema(project: GraphQLProjectConfig): Schema;
+
+export { getSchema };

package/cjs/schema.js

@@ -0,0 +1,52 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var schema_exports = {};
+__export(schema_exports, {
+  getSchema: () => getSchema
+});
+module.exports = __toCommonJS(schema_exports);
+var import_debug = __toESM(require("debug")), import_fast_glob = __toESM(require("fast-glob")), import_graphql = require("graphql"), import_cache = require("./cache.js");
+const schemaCache = new import_cache.ModuleCache(), debug = (0, import_debug.default)("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 import_graphql.GraphQLSchema);
+    const schemaPaths = import_fast_glob.default.sync(project.schema, { absolute: !0 });
+    debug("Schema pointers %O", schemaPaths);
+  }
+  return schemaCache.set(schemaKey, schema), schema;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSchema
+});

package/{sibling-operations.d.ts → cjs/siblings.d.ts}

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