@tanstack/eslint-plugin-query 5.91.4 → 5.94.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/eslint-plugin-query",
-  "version": "5.91.4",
+  "version": "5.94.4",
   "description": "ESLint plugin for TanStack Query",
   "author": "Eliya Cohen",
   "license": "MIT",
@@ -51,7 +51,7 @@
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.4.0"
   },
   "peerDependenciesMeta": {
     "typescript": {
@@ -63,15 +63,14 @@
     "compile": "tsc --build",
     "test:eslint": "eslint --concurrency=auto ./src",
     "test:types": "npm-run-all --serial test:types:*",
-    "test:types:ts50": "node ../../node_modules/typescript50/lib/tsc.js --build",
-    "test:types:ts51": "node ../../node_modules/typescript51/lib/tsc.js --build",
-    "test:types:ts52": "node ../../node_modules/typescript52/lib/tsc.js --build",
-    "test:types:ts53": "node ../../node_modules/typescript53/lib/tsc.js --build",
     "test:types:ts54": "node ../../node_modules/typescript54/lib/tsc.js --build",
     "test:types:ts55": "node ../../node_modules/typescript55/lib/tsc.js --build",
     "test:types:ts56": "node ../../node_modules/typescript56/lib/tsc.js --build",
     "test:types:ts57": "node ../../node_modules/typescript57/lib/tsc.js --build",
+    "test:types:ts58": "node ../../node_modules/typescript58/lib/tsc.js --build",
+    "test:types:ts59": "node ../../node_modules/typescript59/lib/tsc.js --build",
     "test:types:tscurrent": "tsc --build",
+    "test:types:ts60": "node ../../node_modules/typescript60/lib/tsc.js --build",
     "test:lib": "vitest",
     "test:lib:dev": "pnpm run test:lib --watch",
     "test:build": "publint --strict && attw --pack",

package/src/rules/exhaustive-deps/exhaustive-deps.rule.ts

@@ -86,25 +86,27 @@ export const rule = createRule({
           }),
         )
 
-        const existingKeys = ASTUtils.getNestedIdentifiers(queryKeyNode).map(
-          (identifier) =>
-            ASTUtils.mapKeyNodeToBaseText(identifier, context.sourceCode),
-        )
+        const queryKeyDeps = ExhaustiveDepsUtils.collectQueryKeyDeps({
+          sourceCode: context.sourceCode,
+          scopeManager,
+          queryKeyNode,
+        })
 
         const missingRefs = relevantRefs
           .map((ref) => ({
             ref: ref,
-            text: ASTUtils.mapKeyNodeToBaseText(
-              ref.identifier,
-              context.sourceCode,
-            ),
+            text: ASTUtils.isAncestorIsCallee(ref.identifier)
+              ? ref.identifier.name
+              : ASTUtils.mapKeyNodeToBaseText(
+                  ref.identifier,
+                  context.sourceCode,
+                ),
           }))
           .filter(({ ref, text }) => {
             return (
               !ref.isTypeReference &&
-              !ASTUtils.isAncestorIsCallee(ref.identifier) &&
-              !existingKeys.some((existingKey) => existingKey === text) &&
-              !existingKeys.includes(text.split(/[?.]/)[0] ?? '')
+              !queryKeyDeps.has(text) &&
+              !queryKeyDeps.has(text.split(/[?.]/)[0] ?? '')
             )
           })
           .map(({ ref, text }) => ({
@@ -116,9 +118,7 @@ export const rule = createRule({
 
         if (uniqueMissingRefs.length > 0) {
           const missingAsText = uniqueMissingRefs
-            .map((ref) =>
-              ASTUtils.mapKeyNodeToText(ref.identifier, context.sourceCode),
-            )
+            .map((ref) => ref.text)
             .join(', ')
 
           const queryKeyValue = context.sourceCode.getText(queryKeyNode)

package/src/rules/exhaustive-deps/exhaustive-deps.utils.ts

@@ -12,6 +12,20 @@ export const ExhaustiveDepsUtils = {
   }) {
     const { sourceCode, reference, scopeManager, node, filename } = params
     const component = ASTUtils.getFunctionAncestor(sourceCode, node)
+    const queryFnScope = scopeManager.acquire(node)
+
+    if (queryFnScope === null) {
+      return false
+    }
+
+    let currentScope = reference.resolved?.scope ?? null
+    while (currentScope !== null) {
+      if (currentScope === queryFnScope) {
+        return false
+      }
+
+      currentScope = currentScope.upper
+    }
 
     if (component !== undefined) {
       if (
@@ -51,4 +65,149 @@ export const ExhaustiveDepsUtils = {
       node.operator === 'instanceof'
     )
   },
+
+  collectQueryKeyDeps(params: {
+    sourceCode: Readonly<TSESLint.SourceCode>
+    scopeManager: TSESLint.Scope.ScopeManager
+    queryKeyNode: TSESTree.Node
+  }): Set<string> {
+    const { sourceCode, scopeManager, queryKeyNode } = params
+    const deps = new Set<string>()
+    const visitorKeys = sourceCode.visitorKeys
+
+    function add(identifier: TSESTree.Identifier) {
+      deps.add(ASTUtils.mapKeyNodeToBaseText(identifier, sourceCode))
+    }
+
+    function visitChildren(node: TSESTree.Node): void {
+      const keys = (visitorKeys[node.type] ?? []) as ReadonlyArray<
+        keyof TSESTree.Node
+      >
+
+      for (const key of keys) {
+        const value = node[key]
+
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            if (ExhaustiveDepsUtils.isNode(item)) {
+              visit(item)
+            }
+          }
+          continue
+        }
+
+        if (ExhaustiveDepsUtils.isNode(value)) {
+          visit(value)
+        }
+      }
+    }
+
+    function visit(node: TSESTree.Node | null | undefined): void {
+      if (!node) return
+
+      switch (node.type) {
+        case AST_NODE_TYPES.Identifier:
+          add(node)
+          return
+        case AST_NODE_TYPES.ArrowFunctionExpression:
+        case AST_NODE_TYPES.FunctionExpression:
+          for (const reference of ExhaustiveDepsUtils.collectExternalRefsInFunction(
+            {
+              functionNode: node,
+              scopeManager: scopeManager,
+            },
+          )) {
+            if (reference.identifier.type === AST_NODE_TYPES.Identifier) {
+              add(reference.identifier)
+            }
+          }
+          return
+        case AST_NODE_TYPES.Property:
+          visit(node.value)
+          return
+        case AST_NODE_TYPES.MemberExpression:
+          if (
+            node.parent.type === AST_NODE_TYPES.CallExpression &&
+            node.parent.callee === node &&
+            node.object.type === AST_NODE_TYPES.Identifier
+          ) {
+            deps.add(node.object.name)
+          } else {
+            visit(node.object)
+          }
+          return
+        case AST_NODE_TYPES.CallExpression:
+          node.arguments.forEach((argument) => visit(argument))
+          if (
+            node.callee.type === AST_NODE_TYPES.MemberExpression ||
+            node.callee.type === AST_NODE_TYPES.ChainExpression ||
+            node.callee.type === AST_NODE_TYPES.TSNonNullExpression
+          ) {
+            visit(node.callee)
+          }
+          return
+      }
+
+      visitChildren(node)
+    }
+
+    visit(queryKeyNode)
+
+    return deps
+  },
+
+  isNode(value: unknown): value is TSESTree.Node {
+    return (
+      typeof value === 'object' &&
+      value !== null &&
+      'type' in value &&
+      typeof value.type === 'string'
+    )
+  },
+
+  collectExternalRefsInFunction(params: {
+    functionNode: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression
+    scopeManager: TSESLint.Scope.ScopeManager
+  }): Array<TSESLint.Scope.Reference> {
+    const { functionNode, scopeManager } = params
+    const functionScope = scopeManager.acquire(functionNode)
+
+    if (functionScope === null) {
+      return []
+    }
+
+    const externalRefs: Array<TSESLint.Scope.Reference> = []
+
+    function collect(scope: TSESLint.Scope.Scope) {
+      for (const reference of scope.references) {
+        if (!reference.isRead() || reference.resolved === null) {
+          continue
+        }
+
+        let currentScope: TSESLint.Scope.Scope | null = reference.resolved.scope
+        let declaredInsideFunction = false
+
+        while (currentScope !== null) {
+          if (currentScope === functionScope) {
+            declaredInsideFunction = true
+            break
+          }
+
+          currentScope = currentScope.upper
+        }
+
+        if (!declaredInsideFunction) {
+          externalRefs.push(reference)
+        }
+      }
+
+      for (const childScope of scope.childScopes) {
+        collect(childScope)
+      }
+    }
+
+    collect(functionScope)
+
+    return externalRefs
+  },
 }

package/src/utils/ast-utils.ts

@@ -192,7 +192,19 @@ export const ASTUtils = {
       return []
     }
 
-    const references = scope.references
+    const collectReferences = (
+      currentScope: TSESLint.Scope.Scope,
+    ): Array<TSESLint.Scope.Reference> => {
+      const references = [...currentScope.references]
+
+      for (const childScope of currentScope.childScopes) {
+        references.push(...collectReferences(childScope))
+      }
+
+      return references
+    }
+
+    const references = collectReferences(scope)
       .filter((x) => x.isRead() && !scope.set.has(x.identifier.name))
       .map((x) => {
         const referenceNode = ASTUtils.traverseUpOnly(x.identifier, [