@tanstack/eslint-plugin-query 5.94.5 → 5.95.0

package/build/modern/index.cjs

@@ -131,21 +131,6 @@ var ASTUtils = {
     }
     return identifiers;
   },
-  isAncestorIsCallee(identifier) {
-    let previousNode = identifier;
-    let currentNode = identifier.parent;
-    while (currentNode !== void 0) {
-      if (currentNode.type === import_utils.AST_NODE_TYPES.CallExpression && currentNode.callee === previousNode) {
-        return true;
-      }
-      if (currentNode.type !== import_utils.AST_NODE_TYPES.MemberExpression) {
-        return false;
-      }
-      previousNode = currentNode;
-      currentNode = currentNode.parent;
-    }
-    return false;
-  },
   traverseUpOnly(identifier, allowedNodeTypes) {
     const parent = identifier.parent;
     if (parent !== void 0 && allowedNodeTypes.includes(parent.type)) {
@@ -366,7 +351,7 @@ var ExhaustiveDepsUtils = {
     const { sourceCode, reference, scopeManager, node, filename } = params;
     const component = ASTUtils.getFunctionAncestor(sourceCode, node);
     const queryFnScope = scopeManager.acquire(node);
-    if (queryFnScope === null) {
+    if (queryFnScope === null || reference.isValueReference === false) {
       return false;
     }
     let currentScope = reference.resolved?.scope ?? null;
@@ -398,15 +383,57 @@ var ExhaustiveDepsUtils = {
     }
     return reference.identifier.name !== "undefined" && reference.identifier.parent.type !== import_utils3.AST_NODE_TYPES.NewExpression && !ExhaustiveDepsUtils.isInstanceOfKind(reference.identifier.parent);
   },
-  isInstanceOfKind(node) {
-    return node.type === import_utils3.AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof";
+  /**
+   * Given required refs and existing queryKey entries, compute missing dependency paths
+   * respecting allowlisted variables and types.
+   */
+  computeFilteredMissingPaths(params) {
+    const {
+      requiredRefs,
+      allowlistedVariables,
+      existingRootIdentifiers,
+      existingFullPaths
+    } = params;
+    const missingPaths = /* @__PURE__ */ new Set();
+    for (const { root, path, allowlistedByType } of requiredRefs) {
+      if (existingRootIdentifiers.has(root)) continue;
+      if (allowlistedVariables.has(root)) continue;
+      if (existingFullPaths.has(path)) continue;
+      if (allowlistedByType) continue;
+      missingPaths.add(path);
+    }
+    for (const path of missingPaths) {
+      const root = path.split(".")[0];
+      if (root !== path && root !== void 0 && missingPaths.has(root)) {
+        missingPaths.delete(path);
+      }
+    }
+    return Array.from(missingPaths);
   },
+  /**
+   * Extract existing queryKey deps as root identifiers and full member paths.
+   */
   collectQueryKeyDeps(params) {
     const { sourceCode, scopeManager, queryKeyNode } = params;
-    const deps = /* @__PURE__ */ new Set();
+    const roots = /* @__PURE__ */ new Set();
+    const paths = /* @__PURE__ */ new Set();
     const visitorKeys = sourceCode.visitorKeys;
-    function add(identifier) {
-      deps.add(ASTUtils.mapKeyNodeToBaseText(identifier, sourceCode));
+    function addRoot(name8) {
+      const cleaned = ExhaustiveDepsUtils.normalizeChain(name8);
+      roots.add(cleaned);
+      paths.add(cleaned);
+    }
+    function addFull(text) {
+      const cleaned = ExhaustiveDepsUtils.normalizeChain(text);
+      paths.add(cleaned);
+    }
+    function addRefPath(refPath) {
+      if (!refPath) return;
+      if (refPath.coversRootMembers) {
+        addRoot(refPath.root);
+        return;
+      }
+      addFull(refPath.path);
     }
     function visitChildren(node) {
       const keys = visitorKeys[node.type] ?? [];
@@ -428,9 +455,15 @@ var ExhaustiveDepsUtils = {
     function visit(node) {
       if (!node) return;
       switch (node.type) {
-        case import_utils3.AST_NODE_TYPES.Identifier:
-          add(node);
+        case import_utils3.AST_NODE_TYPES.Identifier: {
+          addRefPath(
+            ExhaustiveDepsUtils.computeRefPath({
+              identifier: node,
+              sourceCode
+            })
+          );
           return;
+        }
         case import_utils3.AST_NODE_TYPES.ArrowFunctionExpression:
         case import_utils3.AST_NODE_TYPES.FunctionExpression:
           for (const reference of ExhaustiveDepsUtils.collectExternalRefsInFunction(
@@ -439,9 +472,15 @@ var ExhaustiveDepsUtils = {
               scopeManager
             }
           )) {
-            if (reference.identifier.type === import_utils3.AST_NODE_TYPES.Identifier) {
-              add(reference.identifier);
+            if (reference.identifier.type !== import_utils3.AST_NODE_TYPES.Identifier) {
+              continue;
             }
+            addRefPath(
+              ExhaustiveDepsUtils.computeRefPath({
+                identifier: reference.identifier,
+                sourceCode
+              })
+            );
           }
           return;
         case import_utils3.AST_NODE_TYPES.Property:
@@ -449,26 +488,96 @@ var ExhaustiveDepsUtils = {
           return;
         case import_utils3.AST_NODE_TYPES.MemberExpression:
           if (node.parent.type === import_utils3.AST_NODE_TYPES.CallExpression && node.parent.callee === node && node.object.type === import_utils3.AST_NODE_TYPES.Identifier) {
-            deps.add(node.object.name);
+            addRoot(node.object.name);
           } else {
             visit(node.object);
           }
           return;
         case import_utils3.AST_NODE_TYPES.CallExpression:
           node.arguments.forEach((argument) => visit(argument));
-          if (node.callee.type === import_utils3.AST_NODE_TYPES.MemberExpression || node.callee.type === import_utils3.AST_NODE_TYPES.ChainExpression || node.callee.type === import_utils3.AST_NODE_TYPES.TSNonNullExpression) {
-            visit(node.callee);
+          switch (node.callee.type) {
+            case import_utils3.AST_NODE_TYPES.Identifier:
+            case import_utils3.AST_NODE_TYPES.MemberExpression:
+            case import_utils3.AST_NODE_TYPES.ChainExpression:
+            case import_utils3.AST_NODE_TYPES.TSNonNullExpression:
+              visit(node.callee);
+              break;
           }
           return;
       }
       visitChildren(node);
     }
     visit(queryKeyNode);
-    return deps;
+    return { roots, paths };
   },
   isNode(value) {
     return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
   },
+  /**
+   * Checks whether the resolved variable is allowlisted by its type annotation
+   */
+  variableIsAllowlistedByType(params) {
+    const { allowlistedTypes, variable } = params;
+    if (allowlistedTypes.size === 0) return false;
+    if (!variable) return false;
+    for (const id of variable.identifiers) {
+      if (id.typeAnnotation) {
+        const typeIdentifiers = /* @__PURE__ */ new Set();
+        ExhaustiveDepsUtils.collectTypeIdentifiers(
+          id.typeAnnotation.typeAnnotation,
+          typeIdentifiers
+        );
+        for (const typeIdentifier of typeIdentifiers) {
+          if (allowlistedTypes.has(typeIdentifier)) return true;
+        }
+      }
+    }
+    return false;
+  },
+  isInstanceOfKind(node) {
+    return node.type === import_utils3.AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof";
+  },
+  /**
+   * Normalizes a chain by removing optional chaining operators
+   *
+   * Example: `a?.b.c!` -> `a.b.c`
+   */
+  normalizeChain(text) {
+    return text.replace(/(?:\?(\.)|!)/g, "$1");
+  },
+  /**
+   * Computes the reference path for an identifier
+   *
+   * Example: `a.b.c!` -> `{ path: 'a.b.c', root: 'a' }`
+   */
+  computeRefPath(params) {
+    const { identifier, sourceCode } = params;
+    const fullChainNode = ASTUtils.traverseUpOnly(identifier, [
+      import_utils3.AST_NODE_TYPES.MemberExpression,
+      import_utils3.AST_NODE_TYPES.TSNonNullExpression,
+      import_utils3.AST_NODE_TYPES.Identifier
+    ]);
+    const fullText = ExhaustiveDepsUtils.normalizeChain(
+      sourceCode.getText(fullChainNode)
+    );
+    const parent = fullChainNode.parent;
+    let dependencyPath = fullText;
+    let coversRootMembers = fullText === identifier.name;
+    if (parent && parent.type === import_utils3.AST_NODE_TYPES.CallExpression && parent.callee === fullChainNode) {
+      const segments = fullText.split(".");
+      if (segments.length > 1) {
+        dependencyPath = segments.slice(0, -1).join(".");
+      }
+      coversRootMembers = false;
+    }
+    dependencyPath = dependencyPath.split(".")[0] === "" ? identifier.name : dependencyPath;
+    const root = dependencyPath.split(".")[0];
+    return {
+      path: dependencyPath,
+      root: root ?? identifier.name,
+      coversRootMembers: coversRootMembers && dependencyPath === root
+    };
+  },
   collectExternalRefsInFunction(params) {
     const { functionNode, scopeManager } = params;
     const functionScope = scopeManager.acquire(functionNode);
@@ -500,6 +609,52 @@ var ExhaustiveDepsUtils = {
     }
     collect(functionScope);
     return externalRefs;
+  },
+  /**
+   * Recursively collects type identifiers from a type annotation
+   */
+  collectTypeIdentifiers(typeNode, out) {
+    switch (typeNode.type) {
+      case import_utils3.AST_NODE_TYPES.TSTypeReference: {
+        if (typeNode.typeName.type === import_utils3.AST_NODE_TYPES.Identifier) {
+          out.add(typeNode.typeName.name);
+        }
+        break;
+      }
+      case import_utils3.AST_NODE_TYPES.TSUnionType:
+      case import_utils3.AST_NODE_TYPES.TSIntersectionType: {
+        typeNode.types.forEach(
+          (t) => ExhaustiveDepsUtils.collectTypeIdentifiers(t, out)
+        );
+        break;
+      }
+      case import_utils3.AST_NODE_TYPES.TSArrayType: {
+        ExhaustiveDepsUtils.collectTypeIdentifiers(typeNode.elementType, out);
+        break;
+      }
+      case import_utils3.AST_NODE_TYPES.TSTupleType: {
+        typeNode.elementTypes.forEach(
+          (et) => ExhaustiveDepsUtils.collectTypeIdentifiers(et, out)
+        );
+        break;
+      }
+    }
+  },
+  /**
+   * Gets the function expression nodes from a queryFn property, handling conditional expressions.
+   * When neither branch is skipToken, returns both branches so all deps are scanned.
+   */
+  getQueryFnNodes(queryFn) {
+    if (queryFn.value.type !== import_utils3.AST_NODE_TYPES.ConditionalExpression) {
+      return [queryFn.value];
+    }
+    if (queryFn.value.consequent.type === import_utils3.AST_NODE_TYPES.Identifier && queryFn.value.consequent.name === "skipToken") {
+      return [queryFn.value.alternate];
+    }
+    if (queryFn.value.alternate.type === import_utils3.AST_NODE_TYPES.Identifier && queryFn.value.alternate.name === "skipToken") {
+      return [queryFn.value.consequent];
+    }
+    return [queryFn.value.consequent, queryFn.value.alternate];
   }
 };
 
@@ -522,22 +677,34 @@ var rule = createRule({
     },
     hasSuggestions: true,
     fixable: "code",
-    schema: []
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowlist: {
+            type: "object",
+            properties: {
+              variables: { type: "array", items: { type: "string" } },
+              types: { type: "array", items: { type: "string" } }
+            },
+            additionalProperties: false
+          }
+        },
+        additionalProperties: false
+      }
+    ]
   },
   defaultOptions: [],
   create: detectTanstackQueryImports((context) => {
     return {
-      Property: (node) => {
-        if (!ASTUtils.isObjectExpression(node.parent) || !ASTUtils.isIdentifierWithName(node.key, QUERY_KEY)) {
-          return;
-        }
+      ObjectExpression: (node) => {
         const scopeManager = context.sourceCode.scopeManager;
         const queryKey = ASTUtils.findPropertyWithIdentifierKey(
-          node.parent.properties,
+          node.properties,
           QUERY_KEY
         );
         const queryFn = ASTUtils.findPropertyWithIdentifierKey(
-          node.parent.properties,
+          node.properties,
           QUERY_FN
         );
         if (scopeManager === null || queryKey === void 0 || queryFn === void 0 || !ASTUtils.isNodeOfOneOf(queryFn.value, [
@@ -551,73 +718,104 @@ var rule = createRule({
           queryKey.value,
           context
         );
-        const externalRefs = ASTUtils.getExternalRefs({
-          scopeManager,
-          sourceCode: context.sourceCode,
-          node: getQueryFnRelevantNode(queryFn)
-        });
-        const relevantRefs = externalRefs.filter(
-          (reference) => ExhaustiveDepsUtils.isRelevantReference({
-            sourceCode: context.sourceCode,
-            reference,
+        const queryFnNodes = ExhaustiveDepsUtils.getQueryFnNodes(queryFn);
+        const externalRefs = queryFnNodes.flatMap(
+          (fnNode) => ASTUtils.getExternalRefs({
             scopeManager,
-            node: getQueryFnRelevantNode(queryFn),
-            filename: context.filename
+            sourceCode: context.sourceCode,
+            node: fnNode
           })
         );
+        const relevantRefs = externalRefs.filter(
+          (reference) => queryFnNodes.some(
+            (fnNode) => ExhaustiveDepsUtils.isRelevantReference({
+              sourceCode: context.sourceCode,
+              reference,
+              scopeManager,
+              node: fnNode,
+              filename: context.filename
+            })
+          )
+        );
+        const ruleOptions = context.options.at(0);
+        const allowlistedVariables = new Set(
+          ruleOptions?.allowlist?.variables ?? []
+        );
+        const allowlistedTypes = new Set(ruleOptions?.allowlist?.types ?? []);
+        const requiredRefs = relevantRefs.flatMap((ref) => {
+          if (ref.identifier.type !== import_utils4.AST_NODE_TYPES.Identifier) return [];
+          const refPath = ExhaustiveDepsUtils.computeRefPath({
+            identifier: ref.identifier,
+            sourceCode: context.sourceCode
+          });
+          if (refPath === null) return [];
+          return [
+            {
+              ...refPath,
+              allowlistedByType: ExhaustiveDepsUtils.variableIsAllowlistedByType({
+                allowlistedTypes,
+                variable: ref.resolved ?? null
+              })
+            }
+          ];
+        });
+        if (requiredRefs.length === 0) return;
         const queryKeyDeps = ExhaustiveDepsUtils.collectQueryKeyDeps({
           sourceCode: context.sourceCode,
           scopeManager,
           queryKeyNode
         });
-        const missingRefs = relevantRefs.map((ref) => ({
-          ref,
-          text: ASTUtils.isAncestorIsCallee(ref.identifier) ? ref.identifier.name : ASTUtils.mapKeyNodeToBaseText(
-            ref.identifier,
-            context.sourceCode
-          )
-        })).filter(({ ref, text }) => {
-          return !ref.isTypeReference && !queryKeyDeps.has(text) && !queryKeyDeps.has(text.split(/[?.]/)[0] ?? "");
-        }).map(({ ref, text }) => ({
-          identifier: ref.identifier,
-          text
-        }));
-        const uniqueMissingRefs = uniqueBy(missingRefs, (x) => x.text);
-        if (uniqueMissingRefs.length > 0) {
-          const missingAsText = uniqueMissingRefs.map((ref) => ref.text).join(", ");
-          const queryKeyValue = context.sourceCode.getText(queryKeyNode);
-          const existingWithMissing = queryKeyValue === "[]" ? `[${missingAsText}]` : queryKeyValue.replace(/\]$/, `, ${missingAsText}]`);
-          const suggestions = [];
-          if (queryKeyNode.type === import_utils4.AST_NODE_TYPES.ArrayExpression) {
-            suggestions.push({
-              messageId: "fixTo",
-              data: { result: existingWithMissing },
-              fix(fixer) {
-                return fixer.replaceText(queryKeyNode, existingWithMissing);
-              }
-            });
-          }
-          context.report({
-            node,
-            messageId: "missingDeps",
-            data: {
-              deps: uniqueMissingRefs.map((ref) => ref.text).join(", ")
-            },
-            suggest: suggestions
-          });
-        }
+        const missingPaths = ExhaustiveDepsUtils.computeFilteredMissingPaths({
+          requiredRefs,
+          allowlistedVariables,
+          existingRootIdentifiers: queryKeyDeps.roots,
+          existingFullPaths: queryKeyDeps.paths
+        });
+        if (missingPaths.length === 0) return;
+        const missingAsText = missingPaths.join(", ");
+        const suggestions = buildSuggestions({
+          queryKeyNode,
+          missingPaths,
+          missingAsText,
+          sourceCode: context.sourceCode
+        });
+        context.report({
+          node,
+          messageId: "missingDeps",
+          data: { deps: missingAsText },
+          suggest: suggestions
+        });
       }
     };
   })
 });
-function getQueryFnRelevantNode(queryFn) {
-  if (queryFn.value.type !== import_utils4.AST_NODE_TYPES.ConditionalExpression) {
-    return queryFn.value;
+function buildSuggestions(params) {
+  const { queryKeyNode, missingPaths, missingAsText, sourceCode } = params;
+  if (queryKeyNode.type !== import_utils4.AST_NODE_TYPES.ArrayExpression) {
+    return [];
   }
-  if (queryFn.value.consequent.type === import_utils4.AST_NODE_TYPES.Identifier && queryFn.value.consequent.name === "skipToken") {
-    return queryFn.value.alternate;
+  const closingBracket = sourceCode.getLastToken(queryKeyNode);
+  if (!closingBracket) return [];
+  const existingElements = queryKeyNode.elements.filter((el) => el !== null).map((el) => sourceCode.getText(el));
+  const resultText = `[${[...existingElements, ...missingPaths].join(", ")}]`;
+  if (queryKeyNode.elements.length === 0) {
+    return [
+      {
+        messageId: "fixTo",
+        data: { result: resultText },
+        fix: (fixer) => fixer.replaceText(queryKeyNode, resultText)
+      }
+    ];
   }
-  return queryFn.value.consequent;
+  const tokenBefore = sourceCode.getTokenBefore(closingBracket);
+  const separator = tokenBefore?.value === "," ? " " : ", ";
+  return [
+    {
+      messageId: "fixTo",
+      data: { result: resultText },
+      fix: (fixer) => fixer.insertTextBefore(closingBracket, `${separator}${missingAsText}`)
+    }
+  ];
 }
 function dereferenceVariablesAndTypeAssertions(queryKeyNode, context) {
   const visitedNodes = /* @__PURE__ */ new Set();