@graphql-eslint/eslint-plugin 3.19.3-alpha-20230702093957-98f7783 → 3.20.0-alpha-20230703154330-0d51273

package/cjs/rules/require-id-when-available.js

@@ -1,46 +1,68 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rule = void 0;
-const utils_1 = require("@graphql-tools/utils");
-const graphql_1 = require("graphql");
-const index_js_1 = require("../estree-converter/index.js");
-const utils_js_1 = require("../utils.js");
-const RULE_ID = 'require-id-when-available';
-const DEFAULT_ID_FIELD_NAME = 'id';
+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 require_id_when_available_exports = {};
+__export(require_id_when_available_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(require_id_when_available_exports);
+var import_utils = require("@graphql-tools/utils");
+var import_graphql = require("graphql");
+var import_estree_converter = require("../estree-converter/index.js");
+var import_utils2 = require("../utils.js");
+const RULE_ID = "require-id-when-available";
+const DEFAULT_ID_FIELD_NAME = "id";
 const schema = {
-    definitions: {
-        asString: {
-            type: 'string',
-        },
-        asArray: utils_js_1.ARRAY_DEFAULT_OPTIONS,
-    },
-    type: 'array',
-    maxItems: 1,
-    items: {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-            fieldName: {
-                oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asArray' }],
-                default: DEFAULT_ID_FIELD_NAME,
-            },
-        },
+  definitions: {
+    asString: {
+      type: "string"
     },
+    asArray: import_utils2.ARRAY_DEFAULT_OPTIONS
+  },
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      fieldName: {
+        oneOf: [{ $ref: "#/definitions/asString" }, { $ref: "#/definitions/asArray" }],
+        default: DEFAULT_ID_FIELD_NAME
+      }
+    }
+  }
 };
-exports.rule = {
-    meta: {
-        type: 'suggestion',
-        hasSuggestions: true,
-        docs: {
-            category: 'Operations',
-            description: 'Enforce selecting specific fields when they are available on the GraphQL type.',
-            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-            requiresSchema: true,
-            requiresSiblings: true,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
+const rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: true,
+    docs: {
+      category: "Operations",
+      description: "Enforce selecting specific fields when they are available on the GraphQL type.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: true,
+      requiresSiblings: true,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
             # In your schema
             type User {
               id: ID!
@@ -53,11 +75,14 @@ exports.rule = {
                 name
               }
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
             # In your schema
             type User {
               id: ID!
@@ -78,141 +103,139 @@ exports.rule = {
                 id: name
               }
             }
-          `,
-                },
-            ],
-            recommended: true,
-        },
-        messages: {
-            [RULE_ID]: "Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.\nInclude it in your selection set{{ addition }}.",
-        },
-        schema,
+          `
+          )
+        }
+      ],
+      recommended: true
     },
-    create(context) {
-        const schema = (0, utils_js_1.requireGraphQLSchemaFromContext)(RULE_ID, context);
-        const siblings = (0, utils_js_1.requireSiblingsOperations)(RULE_ID, context);
-        const { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {};
-        const idNames = (0, utils_1.asArray)(fieldName);
-        // Check selections only in OperationDefinition,
-        // skip selections of OperationDefinition and InlineFragment
-        const selector = 'OperationDefinition SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]';
-        const typeInfo = new graphql_1.TypeInfo(schema);
-        function checkFragments(node) {
-            for (const selection of node.selections) {
-                if (selection.kind !== graphql_1.Kind.FRAGMENT_SPREAD) {
-                    continue;
-                }
-                const [foundSpread] = siblings.getFragment(selection.name.value);
-                if (!foundSpread) {
-                    continue;
-                }
-                const checkedFragmentSpreads = new Set();
-                const visitor = (0, graphql_1.visitWithTypeInfo)(typeInfo, {
-                    SelectionSet(node, key, _parent) {
-                        const parent = _parent;
-                        if (parent.kind === graphql_1.Kind.FRAGMENT_DEFINITION) {
-                            checkedFragmentSpreads.add(parent.name.value);
-                        }
-                        else if (parent.kind !== graphql_1.Kind.INLINE_FRAGMENT) {
-                            checkSelections(node, typeInfo.getType(), selection.loc.start, parent, checkedFragmentSpreads);
-                        }
-                    },
-                });
-                (0, graphql_1.visit)(foundSpread.document, visitor);
+    messages: {
+      [RULE_ID]: "Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.\nInclude it in your selection set{{ addition }}."
+    },
+    schema
+  },
+  create(context) {
+    const schema2 = (0, import_utils2.requireGraphQLSchemaFromContext)(RULE_ID, context);
+    const siblings = (0, import_utils2.requireSiblingsOperations)(RULE_ID, context);
+    const { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {};
+    const idNames = (0, import_utils.asArray)(fieldName);
+    const selector = "OperationDefinition SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]";
+    const typeInfo = new import_graphql.TypeInfo(schema2);
+    function checkFragments(node) {
+      for (const selection of node.selections) {
+        if (selection.kind !== import_graphql.Kind.FRAGMENT_SPREAD) {
+          continue;
+        }
+        const [foundSpread] = siblings.getFragment(selection.name.value);
+        if (!foundSpread) {
+          continue;
+        }
+        const checkedFragmentSpreads = /* @__PURE__ */ new Set();
+        const visitor = (0, import_graphql.visitWithTypeInfo)(typeInfo, {
+          SelectionSet(node2, key, _parent) {
+            const parent = _parent;
+            if (parent.kind === import_graphql.Kind.FRAGMENT_DEFINITION) {
+              checkedFragmentSpreads.add(parent.name.value);
+            } else if (parent.kind !== import_graphql.Kind.INLINE_FRAGMENT) {
+              checkSelections(
+                node2,
+                typeInfo.getType(),
+                selection.loc.start,
+                parent,
+                checkedFragmentSpreads
+              );
+            }
+          }
+        });
+        (0, import_graphql.visit)(foundSpread.document, visitor);
+      }
+    }
+    function checkSelections(node, type, loc, parent, checkedFragmentSpreads = /* @__PURE__ */ new Set()) {
+      const rawType = (0, import_estree_converter.getBaseType)(type);
+      if (rawType instanceof import_graphql.GraphQLObjectType || rawType instanceof import_graphql.GraphQLInterfaceType) {
+        checkFields(rawType);
+      } else if (rawType instanceof import_graphql.GraphQLUnionType) {
+        for (const selection of node.selections) {
+          if (selection.kind === import_graphql.Kind.INLINE_FRAGMENT) {
+            const types = rawType.getTypes();
+            const t = types.find((t2) => t2.name === selection.typeCondition.name.value);
+            if (t) {
+              checkFields(t);
             }
+          }
+        }
+      }
+      function checkFields(rawType2) {
+        const fields = rawType2.getFields();
+        const hasIdFieldInType = idNames.some((name) => fields[name]);
+        if (!hasIdFieldInType) {
+          return;
         }
-        function checkSelections(node, type, 
-        // Fragment can be placed in separate file
-        // Provide actual fragment spread location instead of location in fragment
-        loc, 
-        // Can't access to node.parent in GraphQL AST.Node, so pass as argument
-        parent, checkedFragmentSpreads = new Set()) {
-            const rawType = (0, index_js_1.getBaseType)(type);
-            if (rawType instanceof graphql_1.GraphQLObjectType || rawType instanceof graphql_1.GraphQLInterfaceType) {
-                checkFields(rawType);
+        function hasIdField({ selections }) {
+          return selections.some((selection) => {
+            if (selection.kind === import_graphql.Kind.FIELD) {
+              if (selection.alias && idNames.includes(selection.alias.value)) {
+                return true;
+              }
+              return idNames.includes(selection.name.value);
             }
-            else if (rawType instanceof graphql_1.GraphQLUnionType) {
-                for (const selection of node.selections) {
-                    if (selection.kind === graphql_1.Kind.INLINE_FRAGMENT) {
-                        const types = rawType.getTypes();
-                        const t = types.find(t => t.name === selection.typeCondition.name.value);
-                        if (t) {
-                            checkFields(t);
-                        }
-                    }
-                }
+            if (selection.kind === import_graphql.Kind.INLINE_FRAGMENT) {
+              return hasIdField(selection.selectionSet);
             }
-            function checkFields(rawType) {
-                const fields = rawType.getFields();
-                const hasIdFieldInType = idNames.some(name => fields[name]);
-                if (!hasIdFieldInType) {
-                    return;
-                }
-                function hasIdField({ selections }) {
-                    return selections.some(selection => {
-                        if (selection.kind === graphql_1.Kind.FIELD) {
-                            if (selection.alias && idNames.includes(selection.alias.value)) {
-                                return true;
-                            }
-                            return idNames.includes(selection.name.value);
-                        }
-                        if (selection.kind === graphql_1.Kind.INLINE_FRAGMENT) {
-                            return hasIdField(selection.selectionSet);
-                        }
-                        if (selection.kind === graphql_1.Kind.FRAGMENT_SPREAD) {
-                            const [foundSpread] = siblings.getFragment(selection.name.value);
-                            if (foundSpread) {
-                                const fragmentSpread = foundSpread.document;
-                                checkedFragmentSpreads.add(fragmentSpread.name.value);
-                                return hasIdField(fragmentSpread.selectionSet);
-                            }
-                        }
-                        return false;
-                    });
-                }
-                const hasId = hasIdField(node);
-                checkFragments(node);
-                if (hasId) {
-                    return;
-                }
-                const pluralSuffix = idNames.length > 1 ? 's' : '';
-                const fieldName = (0, utils_js_1.englishJoinWords)(idNames.map(name => `\`${(parent.alias || parent.name).value}.${name}\``));
-                const addition = checkedFragmentSpreads.size === 0
-                    ? ''
-                    : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? 's' : ''} ${(0, utils_js_1.englishJoinWords)([...checkedFragmentSpreads].map(name => `\`${name}\``))}`;
-                const problem = {
-                    loc,
-                    messageId: RULE_ID,
-                    data: {
-                        pluralSuffix,
-                        fieldName,
-                        addition,
-                    },
-                };
-                // Don't provide suggestions for selections in fragments as fragment can be in a separate file
-                if ('type' in node) {
-                    problem.suggest = idNames.map(idName => ({
-                        desc: `Add \`${idName}\` selection`,
-                        fix: fixer => {
-                            let insertNode = node.selections[0];
-                            insertNode =
-                                insertNode.kind === graphql_1.Kind.INLINE_FRAGMENT
-                                    ? insertNode.selectionSet.selections[0]
-                                    : insertNode;
-                            return fixer.insertTextBefore(insertNode, `${idName} `);
-                        },
-                    }));
-                }
-                context.report(problem);
+            if (selection.kind === import_graphql.Kind.FRAGMENT_SPREAD) {
+              const [foundSpread] = siblings.getFragment(selection.name.value);
+              if (foundSpread) {
+                const fragmentSpread = foundSpread.document;
+                checkedFragmentSpreads.add(fragmentSpread.name.value);
+                return hasIdField(fragmentSpread.selectionSet);
+              }
             }
+            return false;
+          });
         }
-        return {
-            [selector](node) {
-                const typeInfo = node.typeInfo();
-                if (typeInfo.gqlType) {
-                    checkSelections(node, typeInfo.gqlType, node.loc.start, node.parent);
-                }
-            },
+        const hasId = hasIdField(node);
+        checkFragments(node);
+        if (hasId) {
+          return;
+        }
+        const pluralSuffix = idNames.length > 1 ? "s" : "";
+        const fieldName2 = (0, import_utils2.englishJoinWords)(
+          idNames.map((name) => `\`${(parent.alias || parent.name).value}.${name}\``)
+        );
+        const addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${(0, import_utils2.englishJoinWords)([...checkedFragmentSpreads].map((name) => `\`${name}\``))}`;
+        const problem = {
+          loc,
+          messageId: RULE_ID,
+          data: {
+            pluralSuffix,
+            fieldName: fieldName2,
+            addition
+          }
         };
-    },
+        if ("type" in node) {
+          problem.suggest = idNames.map((idName) => ({
+            desc: `Add \`${idName}\` selection`,
+            fix: (fixer) => {
+              let insertNode = node.selections[0];
+              insertNode = insertNode.kind === import_graphql.Kind.INLINE_FRAGMENT ? insertNode.selectionSet.selections[0] : insertNode;
+              return fixer.insertTextBefore(insertNode, `${idName} `);
+            }
+          }));
+        }
+        context.report(problem);
+      }
+    }
+    return {
+      [selector](node) {
+        const typeInfo2 = node.typeInfo();
+        if (typeInfo2.gqlType) {
+          checkSelections(node, typeInfo2.gqlType, node.loc.start, node.parent);
+        }
+      }
+    };
+  }
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/require-import-fragment.d.ts

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

package/cjs/rules/require-import-fragment.js

@@ -1,115 +1,165 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rule = void 0;
-const tslib_1 = require("tslib");
-const path_1 = tslib_1.__importDefault(require("path"));
-const utils_js_1 = require("../utils.js");
-const RULE_ID = 'require-import-fragment';
-const SUGGESTION_ID = 'add-import-expression';
-exports.rule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            category: 'Operations',
-            description: 'Require fragments to be imported via an import expression.',
-            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
+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 require_import_fragment_exports = {};
+__export(require_import_fragment_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(require_import_fragment_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("../utils.js");
+const RULE_ID = "require-import-fragment";
+const SUGGESTION_ID = "add-import-expression";
+const rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Operations",
+      description: "Require fragments to be imported via an import expression.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
             query {
               user {
                 ...UserFields
               }
             }
-          `,
-                },
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
             # import 'post-fields.fragment.graphql'
             query {
               user {
                 ...UserFields
               }
             }
-          `,
-                },
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
             # import UserFields from 'post-fields.fragment.graphql'
             query {
               user {
                 ...UserFields
               }
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
             # import UserFields from 'user-fields.fragment.graphql'
             query {
               user {
                 ...UserFields
               }
             }
-          `,
-                },
-            ],
-            requiresSiblings: true,
-            isDisabledForAllConfig: true,
-        },
-        hasSuggestions: true,
-        messages: {
-            [RULE_ID]: 'Expected "{{fragmentName}}" fragment to be imported.',
-            [SUGGESTION_ID]: 'Add import expression for "{{fragmentName}}".',
-        },
-        schema: [],
+          `
+          )
+        }
+      ],
+      requiresSiblings: true,
+      isDisabledForAllConfig: true
     },
-    create(context) {
-        const comments = context.getSourceCode().getAllComments();
-        const siblings = (0, utils_js_1.requireSiblingsOperations)(RULE_ID, context);
-        const filePath = context.getFilename();
-        return {
-            'FragmentSpread > .name'(node) {
-                var _a;
-                const fragmentName = node.value;
-                const fragmentsFromSiblings = siblings.getFragment(fragmentName);
-                for (const comment of comments) {
-                    if (comment.type !== 'Line')
-                        continue;
-                    // 1. could start with extra whitespace
-                    // 2. match both named/default import
-                    const isPossibleImported = new RegExp(`^\\s*import\\s+(${fragmentName}\\s+from\\s+)?['"]`).test(comment.value);
-                    if (!isPossibleImported)
-                        continue;
-                    const extractedImportPath = (_a = comment.value.match(/(["'])((?:\1|.)*?)\1/)) === null || _a === void 0 ? void 0 : _a[2];
-                    if (!extractedImportPath)
-                        continue;
-                    const importPath = path_1.default.join(path_1.default.dirname(filePath), extractedImportPath);
-                    const hasInSiblings = fragmentsFromSiblings.some(source => source.filePath === importPath);
-                    if (hasInSiblings)
-                        return;
-                }
-                const fragmentInSameFile = fragmentsFromSiblings.some(source => source.filePath === filePath);
-                if (fragmentInSameFile)
-                    return;
-                const suggestedFilePaths = fragmentsFromSiblings.length
-                    ? fragmentsFromSiblings.map(o => path_1.default.relative(path_1.default.dirname(filePath), o.filePath))
-                    : ['CHANGE_ME.graphql'];
-                context.report({
-                    node,
-                    messageId: RULE_ID,
-                    data: { fragmentName },
-                    suggest: suggestedFilePaths.map(suggestedPath => ({
-                        messageId: SUGGESTION_ID,
-                        data: { fragmentName },
-                        fix: fixer => fixer.insertTextBeforeRange([0, 0], `# import ${fragmentName} from '${suggestedPath}'\n`),
-                    })),
-                });
-            },
-        };
+    hasSuggestions: true,
+    messages: {
+      [RULE_ID]: 'Expected "{{fragmentName}}" fragment to be imported.',
+      [SUGGESTION_ID]: 'Add import expression for "{{fragmentName}}".'
     },
+    schema: []
+  },
+  create(context) {
+    const comments = context.getSourceCode().getAllComments();
+    const siblings = (0, import_utils.requireSiblingsOperations)(RULE_ID, context);
+    const filePath = context.getFilename();
+    return {
+      "FragmentSpread > .name"(node) {
+        const fragmentName = node.value;
+        const fragmentsFromSiblings = siblings.getFragment(fragmentName);
+        for (const comment of comments) {
+          if (comment.type !== "Line")
+            continue;
+          const isPossibleImported = new RegExp(
+            `^\\s*import\\s+(${fragmentName}\\s+from\\s+)?['"]`
+          ).test(comment.value);
+          if (!isPossibleImported)
+            continue;
+          const extractedImportPath = comment.value.match(/(["'])((?:\1|.)*?)\1/)?.[2];
+          if (!extractedImportPath)
+            continue;
+          const importPath = import_path.default.join(import_path.default.dirname(filePath), extractedImportPath);
+          const hasInSiblings = fragmentsFromSiblings.some(
+            (source) => source.filePath === importPath
+          );
+          if (hasInSiblings)
+            return;
+        }
+        const fragmentInSameFile = fragmentsFromSiblings.some(
+          (source) => source.filePath === filePath
+        );
+        if (fragmentInSameFile)
+          return;
+        const suggestedFilePaths = fragmentsFromSiblings.length ? fragmentsFromSiblings.map((o) => import_path.default.relative(import_path.default.dirname(filePath), o.filePath)) : ["CHANGE_ME.graphql"];
+        context.report({
+          node,
+          messageId: RULE_ID,
+          data: { fragmentName },
+          suggest: suggestedFilePaths.map((suggestedPath) => ({
+            messageId: SUGGESTION_ID,
+            data: { fragmentName },
+            fix: (fixer) => fixer.insertTextBeforeRange(
+              [0, 0],
+              `# import ${fragmentName} from '${suggestedPath}'
+`
+            )
+          }))
+        });
+      }
+    };
+  }
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});