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

package/cjs/rules/selection-set-depth.js

@@ -1,41 +1,70 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rule = void 0;
-const tslib_1 = require("tslib");
-const graphql_1 = require("graphql");
-const graphql_depth_limit_1 = tslib_1.__importDefault(require("graphql-depth-limit"));
-const utils_js_1 = require("../utils.js");
-const RULE_ID = 'selection-set-depth';
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var selection_set_depth_exports = {};
+__export(selection_set_depth_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(selection_set_depth_exports);
+var import_graphql = require("graphql");
+var import_graphql_depth_limit = __toESM(require("graphql-depth-limit"));
+var import_utils = require("../utils.js");
+const RULE_ID = "selection-set-depth";
 const schema = {
-    type: 'array',
-    minItems: 1,
-    maxItems: 1,
-    items: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['maxDepth'],
-        properties: {
-            maxDepth: {
-                type: 'number',
-            },
-            ignore: utils_js_1.ARRAY_DEFAULT_OPTIONS,
-        },
-    },
+  type: "array",
+  minItems: 1,
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    required: ["maxDepth"],
+    properties: {
+      maxDepth: {
+        type: "number"
+      },
+      ignore: import_utils.ARRAY_DEFAULT_OPTIONS
+    }
+  }
 };
-exports.rule = {
-    meta: {
-        type: 'suggestion',
-        hasSuggestions: true,
-        docs: {
-            category: 'Operations',
-            description: 'Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://npmjs.com/package/graphql-depth-limit).',
-            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-            requiresSiblings: true,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    usage: [{ maxDepth: 1 }],
-                    code: `
+const rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: true,
+    docs: {
+      category: "Operations",
+      description: "Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://npmjs.com/package/graphql-depth-limit).",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSiblings: true,
+      examples: [
+        {
+          title: "Incorrect",
+          usage: [{ maxDepth: 1 }],
+          code: `
             query deep2 {
               viewer { # Level 0
                 albums { # Level 1
@@ -43,12 +72,12 @@ exports.rule = {
                 }
               }
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    usage: [{ maxDepth: 4 }],
-                    code: `
+          `
+        },
+        {
+          title: "Correct",
+          usage: [{ maxDepth: 4 }],
+          code: `
             query deep2 {
               viewer { # Level 0
                 albums { # Level 1
@@ -56,12 +85,12 @@ exports.rule = {
                 }
               }
             }
-          `,
-                },
-                {
-                    title: 'Correct (ignored field)',
-                    usage: [{ maxDepth: 1, ignore: ['albums'] }],
-                    code: `
+          `
+        },
+        {
+          title: "Correct (ignored field)",
+          usage: [{ maxDepth: 1, ignore: ["albums"] }],
+          code: `
             query deep2 {
               viewer { # Level 0
                 albums { # Level 1
@@ -69,67 +98,78 @@ exports.rule = {
                 }
               }
             }
-          `,
-                },
-            ],
-            recommended: true,
-            configOptions: [{ maxDepth: 7 }],
-        },
-        schema,
+          `
+        }
+      ],
+      recommended: true,
+      configOptions: [{ maxDepth: 7 }]
     },
-    create(context) {
-        let siblings = null;
+    schema
+  },
+  create(context) {
+    let siblings = null;
+    try {
+      siblings = (0, import_utils.requireSiblingsOperations)(RULE_ID, context);
+    } catch {
+      import_utils.logger.warn(
+        `Rule "${RULE_ID}" works best with siblings operations loaded. For more info: https://bit.ly/graphql-eslint-operations`
+      );
+    }
+    const { maxDepth, ignore = [] } = context.options[0];
+    const checkFn = (0, import_graphql_depth_limit.default)(maxDepth, { ignore });
+    return {
+      "OperationDefinition, FragmentDefinition"(node) {
         try {
-            siblings = (0, utils_js_1.requireSiblingsOperations)(RULE_ID, context);
-        }
-        catch (_a) {
-            utils_js_1.logger.warn(`Rule "${RULE_ID}" works best with siblings operations loaded. For more info: https://bit.ly/graphql-eslint-operations`);
-        }
-        const { maxDepth, ignore = [] } = context.options[0];
-        const checkFn = (0, graphql_depth_limit_1.default)(maxDepth, { ignore });
-        return {
-            'OperationDefinition, FragmentDefinition'(node) {
-                try {
-                    const rawNode = node.rawNode();
-                    const fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [];
-                    const document = {
-                        kind: graphql_1.Kind.DOCUMENT,
-                        definitions: [rawNode, ...fragmentsInUse],
-                    };
-                    checkFn({
-                        getDocument: () => document,
-                        reportError(error) {
-                            const { line, column } = error.locations[0];
-                            const ancestors = context.getAncestors();
-                            const token = ancestors[0].tokens.find(token => token.loc.start.line === line && token.loc.start.column === column - 1);
-                            context.report({
-                                loc: {
-                                    line,
-                                    column: column - 1,
-                                },
-                                message: error.message,
-                                // Don't provide suggestions for fragment that can be in a separate file
-                                ...(token && {
-                                    suggest: [
-                                        {
-                                            desc: 'Remove selections',
-                                            fix(fixer) {
-                                                const sourceCode = context.getSourceCode();
-                                                const foundNode = sourceCode.getNodeByRangeIndex(token.range[0]);
-                                                const parentNode = foundNode.parent.parent;
-                                                return fixer.remove(foundNode.kind === 'Name' ? parentNode.parent : parentNode);
-                                            },
-                                        },
-                                    ],
-                                }),
-                            });
-                        },
-                    });
-                }
-                catch (e) {
-                    utils_js_1.logger.warn(`Rule "${RULE_ID}" check failed due to a missing siblings operations. For more info: https://bit.ly/graphql-eslint-operations`, e);
+          const rawNode = node.rawNode();
+          const fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [];
+          const document = {
+            kind: import_graphql.Kind.DOCUMENT,
+            definitions: [rawNode, ...fragmentsInUse]
+          };
+          checkFn({
+            getDocument: () => document,
+            reportError(error) {
+              const { line, column } = error.locations[0];
+              const ancestors = context.getAncestors();
+              const token = ancestors[0].tokens.find(
+                (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
+              );
+              context.report({
+                loc: {
+                  line,
+                  column: column - 1
+                },
+                message: error.message,
+                // Don't provide suggestions for fragment that can be in a separate file
+                ...token && {
+                  suggest: [
+                    {
+                      desc: "Remove selections",
+                      fix(fixer) {
+                        const sourceCode = context.getSourceCode();
+                        const foundNode = sourceCode.getNodeByRangeIndex(token.range[0]);
+                        const parentNode = foundNode.parent.parent;
+                        return fixer.remove(
+                          foundNode.kind === "Name" ? parentNode.parent : parentNode
+                        );
+                      }
+                    }
+                  ]
                 }
-            },
-        };
-    },
+              });
+            }
+          });
+        } catch (e) {
+          import_utils.logger.warn(
+            `Rule "${RULE_ID}" check failed due to a missing siblings operations. For more info: https://bit.ly/graphql-eslint-operations`,
+            e
+          );
+        }
+      }
+    };
+  }
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/{typings → cjs}/rules/strict-id-in-types.d.ts

@@ -1,5 +1,12 @@
 import { FromSchema } from 'json-schema-to-ts';
-import { GraphQLESLintRule } from '../types.js';
+import { i as GraphQLESLintRule } from '../types-e3367e3c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.js';
+
 declare const schema: {
     readonly type: "array";
     readonly maxItems: 1;
@@ -52,6 +59,7 @@ declare const schema: {
         };
     };
 };
-export type RuleOptions = FromSchema<typeof schema>;
-export declare const rule: GraphQLESLintRule<RuleOptions>;
-export {};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };

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

@@ -1,61 +1,83 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rule = void 0;
-const graphql_1 = require("graphql");
-const utils_js_1 = require("../utils.js");
-const RULE_ID = 'strict-id-in-types';
+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: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }), 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");
+var import_utils = require("../utils.js");
+const RULE_ID = "strict-id-in-types";
 const schema = {
-    type: 'array',
-    maxItems: 1,
-    items: {
-        type: 'object',
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      acceptedIdNames: {
+        ...import_utils.ARRAY_DEFAULT_OPTIONS,
+        default: ["id"]
+      },
+      acceptedIdTypes: {
+        ...import_utils.ARRAY_DEFAULT_OPTIONS,
+        default: ["ID"]
+      },
+      exceptions: {
+        type: "object",
         additionalProperties: false,
         properties: {
-            acceptedIdNames: {
-                ...utils_js_1.ARRAY_DEFAULT_OPTIONS,
-                default: ['id'],
-            },
-            acceptedIdTypes: {
-                ...utils_js_1.ARRAY_DEFAULT_OPTIONS,
-                default: ['ID'],
-            },
-            exceptions: {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    types: {
-                        ...utils_js_1.ARRAY_DEFAULT_OPTIONS,
-                        description: 'This is used to exclude types with names that match one of the specified values.',
-                    },
-                    suffixes: {
-                        ...utils_js_1.ARRAY_DEFAULT_OPTIONS,
-                        description: 'This is used to exclude types with names with suffixes that match one of the specified values.',
-                    },
-                },
-            },
-        },
-    },
+          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."
+          }
+        }
+      }
+    }
+  }
 };
-exports.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 */ `
+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!
@@ -76,18 +98,21 @@ exports.rule = {
               id: ID!
               _id: ID!
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    usage: [
-                        {
-                            acceptedIdNames: ['id', '_id'],
-                            acceptedIdTypes: ['ID'],
-                            exceptions: { types: ['Error'], suffixes: ['Payload'] },
-                        },
-                    ],
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [
+            {
+              acceptedIdNames: ["id", "_id"],
+              acceptedIdTypes: ["ID"],
+              exceptions: { types: ["Error"], suffixes: ["Payload"] }
+            }
+          ],
+          code: (
+            /* GraphQL */
+            `
             type User {
               id: ID!
             }
@@ -103,62 +128,58 @@ exports.rule = {
             type Error {
               message: String!
             }
-          `,
-                },
-            ],
-        },
-        schema,
-    },
-    create(context) {
-        const options = {
-            acceptedIdNames: ['id'],
-            acceptedIdTypes: ['ID'],
-            exceptions: {},
-            ...context.options[0],
-        };
-        const schema = (0, utils_js_1.requireGraphQLSchemaFromContext)(RULE_ID, context);
-        const rootTypeNames = [
-            schema.getQueryType(),
-            schema.getMutationType(),
-            schema.getSubscriptionType(),
-        ]
-            .filter(utils_js_1.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 || _a === void 0 ? void 0 : _a.includes(typeName)) ||
-                    ((_b = options.exceptions.suffixes) === null || _b === void 0 ? void 0 : _b.some(suffix => typeName.endsWith(suffix)));
-                if (shouldIgnoreNode) {
-                    return;
-                }
-                const validIds = (_c = node.fields) === null || _c === void 0 ? void 0 : _c.filter(field => {
-                    const fieldNode = field.rawNode();
-                    const isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value);
-                    // To be a valid type, it must be non-null and one of the accepted types.
-                    let isValidIdType = false;
-                    if (fieldNode.type.kind === graphql_1.Kind.NON_NULL_TYPE &&
-                        fieldNode.type.type.kind === graphql_1.Kind.NAMED_TYPE) {
-                        isValidIdType = options.acceptedIdTypes.includes(fieldNode.type.type.name.value);
-                    }
-                    return isValidIdName && isValidIdType;
-                });
-                // Usually, there should be only one unique identifier field per type.
-                // Some clients allow multiple fields to be used. If more people need this,
-                // we can extend this rule later.
-                if ((validIds === null || validIds === void 0 ? 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: `${(0, utils_js_1.displayNodeName)(node)} must have exactly one non-nullable unique identifier.
-Accepted name${pluralNamesSuffix}: ${(0, utils_js_1.englishJoinWords)(options.acceptedIdNames)}.
-Accepted type${pluralTypesSuffix}: ${(0, utils_js_1.englishJoinWords)(options.acceptedIdTypes)}.`,
-                    });
-                }
-            },
-        };
+          `
+          )
+        }
+      ]
     },
+    schema
+  },
+  create(context) {
+    const options = {
+      acceptedIdNames: ["id"],
+      acceptedIdTypes: ["ID"],
+      exceptions: {},
+      ...context.options[0]
+    };
+    const schema2 = (0, import_utils.requireGraphQLSchemaFromContext)(RULE_ID, context);
+    const rootTypeNames = [
+      schema2.getQueryType(),
+      schema2.getMutationType(),
+      schema2.getSubscriptionType()
+    ].filter(import_utils.truthy).map((type) => type.name);
+    const selector = `ObjectTypeDefinition[name.value!=/^(${rootTypeNames.join("|")})$/]`;
+    return {
+      [selector](node) {
+        const typeName = node.name.value;
+        const shouldIgnoreNode = options.exceptions.types?.includes(typeName) || options.exceptions.suffixes?.some((suffix) => typeName.endsWith(suffix));
+        if (shouldIgnoreNode) {
+          return;
+        }
+        const validIds = node.fields?.filter((field) => {
+          const fieldNode = field.rawNode();
+          const isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value);
+          let isValidIdType = false;
+          if (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);
+          }
+          return isValidIdName && isValidIdType;
+        });
+        if (validIds?.length !== 1) {
+          const pluralNamesSuffix = options.acceptedIdNames.length > 1 ? "s" : "";
+          const 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-fragment-name.d.ts

@@ -0,0 +1,13 @@
+import { ExecutableDefinitionNode } from 'graphql';
+import { GraphQLESTreeNode } from '../estree-converter/types.js';
+import { g as GraphQLESLintRuleContext, i as GraphQLESLintRule } from '../types-e3367e3c.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 };