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

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

@@ -1,43 +1,58 @@
-import { asArray } from '@graphql-tools/utils';
-import { GraphQLInterfaceType, GraphQLObjectType, GraphQLUnionType, Kind, TypeInfo, visit, visitWithTypeInfo, } from 'graphql';
-import { getBaseType } from '../estree-converter/index.js';
-import { ARRAY_DEFAULT_OPTIONS, englishJoinWords, requireGraphQLSchemaFromContext, requireSiblingsOperations, } from '../utils.js';
-const RULE_ID = 'require-id-when-available';
-const DEFAULT_ID_FIELD_NAME = 'id';
+import { asArray } from "@graphql-tools/utils";
+import {
+  GraphQLInterfaceType,
+  GraphQLObjectType,
+  GraphQLUnionType,
+  Kind,
+  TypeInfo,
+  visit,
+  visitWithTypeInfo
+} from "graphql";
+import { getBaseType } from "../estree-converter/index.js";
+import {
+  ARRAY_DEFAULT_OPTIONS,
+  englishJoinWords,
+  requireGraphQLSchemaFromContext,
+  requireSiblingsOperations
+} from "../utils.js";
+const RULE_ID = "require-id-when-available";
+const DEFAULT_ID_FIELD_NAME = "id";
 const schema = {
-    definitions: {
-        asString: {
-            type: 'string',
-        },
-        asArray: 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: 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
+      }
+    }
+  }
 };
-export 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 */ `
+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!
@@ -50,11 +65,14 @@ export const rule = {
                 name
               }
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
             # In your schema
             type User {
               id: ID!
@@ -75,141 +93,138 @@ export const 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
+    },
+    messages: {
+      [RULE_ID]: "Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.\nInclude it in your selection set{{ addition }}."
     },
-    create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
-        const siblings = requireSiblingsOperations(RULE_ID, context);
-        const { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {};
-        const idNames = asArray(fieldName);
-        // Check selections only in OperationDefinition,
-        // skip selections of OperationDefinition and InlineFragment
-        const selector = 'OperationDefinition SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]';
-        const typeInfo = new TypeInfo(schema);
-        function checkFragments(node) {
-            for (const selection of node.selections) {
-                if (selection.kind !== Kind.FRAGMENT_SPREAD) {
-                    continue;
-                }
-                const [foundSpread] = siblings.getFragment(selection.name.value);
-                if (!foundSpread) {
-                    continue;
-                }
-                const checkedFragmentSpreads = new Set();
-                const visitor = visitWithTypeInfo(typeInfo, {
-                    SelectionSet(node, key, _parent) {
-                        const parent = _parent;
-                        if (parent.kind === Kind.FRAGMENT_DEFINITION) {
-                            checkedFragmentSpreads.add(parent.name.value);
-                        }
-                        else if (parent.kind !== Kind.INLINE_FRAGMENT) {
-                            checkSelections(node, typeInfo.getType(), selection.loc.start, parent, checkedFragmentSpreads);
-                        }
-                    },
-                });
-                visit(foundSpread.document, visitor);
+    schema
+  },
+  create(context) {
+    const schema2 = requireGraphQLSchemaFromContext(RULE_ID, context);
+    const siblings = requireSiblingsOperations(RULE_ID, context);
+    const { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {};
+    const idNames = asArray(fieldName);
+    const selector = "OperationDefinition SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]";
+    const typeInfo = new TypeInfo(schema2);
+    function checkFragments(node) {
+      for (const selection of node.selections) {
+        if (selection.kind !== Kind.FRAGMENT_SPREAD) {
+          continue;
+        }
+        const [foundSpread] = siblings.getFragment(selection.name.value);
+        if (!foundSpread) {
+          continue;
+        }
+        const checkedFragmentSpreads = /* @__PURE__ */ new Set();
+        const visitor = visitWithTypeInfo(typeInfo, {
+          SelectionSet(node2, key, _parent) {
+            const parent = _parent;
+            if (parent.kind === Kind.FRAGMENT_DEFINITION) {
+              checkedFragmentSpreads.add(parent.name.value);
+            } else if (parent.kind !== Kind.INLINE_FRAGMENT) {
+              checkSelections(
+                node2,
+                typeInfo.getType(),
+                selection.loc.start,
+                parent,
+                checkedFragmentSpreads
+              );
             }
+          }
+        });
+        visit(foundSpread.document, visitor);
+      }
+    }
+    function checkSelections(node, type, loc, parent, checkedFragmentSpreads = /* @__PURE__ */ new Set()) {
+      const rawType = getBaseType(type);
+      if (rawType instanceof GraphQLObjectType || rawType instanceof GraphQLInterfaceType) {
+        checkFields(rawType);
+      } else if (rawType instanceof GraphQLUnionType) {
+        for (const selection of node.selections) {
+          if (selection.kind === 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 = getBaseType(type);
-            if (rawType instanceof GraphQLObjectType || rawType instanceof GraphQLInterfaceType) {
-                checkFields(rawType);
+        function hasIdField({ selections }) {
+          return selections.some((selection) => {
+            if (selection.kind === Kind.FIELD) {
+              if (selection.alias && idNames.includes(selection.alias.value)) {
+                return true;
+              }
+              return idNames.includes(selection.name.value);
             }
-            else if (rawType instanceof GraphQLUnionType) {
-                for (const selection of node.selections) {
-                    if (selection.kind === 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 === 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 === Kind.FIELD) {
-                            if (selection.alias && idNames.includes(selection.alias.value)) {
-                                return true;
-                            }
-                            return idNames.includes(selection.name.value);
-                        }
-                        if (selection.kind === Kind.INLINE_FRAGMENT) {
-                            return hasIdField(selection.selectionSet);
-                        }
-                        if (selection.kind === 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 = englishJoinWords(idNames.map(name => `\`${(parent.alias || parent.name).value}.${name}\``));
-                const addition = checkedFragmentSpreads.size === 0
-                    ? ''
-                    : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? 's' : ''} ${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 === Kind.INLINE_FRAGMENT
-                                    ? insertNode.selectionSet.selections[0]
-                                    : insertNode;
-                            return fixer.insertTextBefore(insertNode, `${idName} `);
-                        },
-                    }));
-                }
-                context.report(problem);
+            if (selection.kind === 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;
         }
-        return {
-            [selector](node) {
-                const typeInfo = node.typeInfo();
-                if (typeInfo.gqlType) {
-                    checkSelections(node, typeInfo.gqlType, node.loc.start, node.parent);
-                }
-            },
+        const pluralSuffix = idNames.length > 1 ? "s" : "";
+        const fieldName2 = englishJoinWords(
+          idNames.map((name) => `\`${(parent.alias || parent.name).value}.${name}\``)
+        );
+        const addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${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 === 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);
+        }
+      }
+    };
+  }
+};
+export {
+  rule
 };

package/esm/rules/require-import-fragment.d.mts

@@ -0,0 +1,12 @@
+import { i as GraphQLESLintRule } from '../types-2e1afd7c.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/require-import-fragment.js

@@ -1,111 +1,131 @@
-import path from 'path';
-import { requireSiblingsOperations } from '../utils.js';
-const RULE_ID = 'require-import-fragment';
-const SUGGESTION_ID = 'add-import-expression';
-export 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 */ `
+import path from "path";
+import { requireSiblingsOperations } from "../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 = 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.join(path.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.relative(path.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 = 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 = path.join(path.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.relative(path.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}'
+`
+            )
+          }))
+        });
+      }
+    };
+  }
+};
+export {
+  rule
 };

package/esm/rules/require-nullable-fields-with-oneof.d.mts

@@ -0,0 +1,12 @@
+import { i as GraphQLESLintRule } from '../types-2e1afd7c.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 };