@tanstack/eslint-plugin-query 5.100.13 → 5.101.0

package/build/modern/rules.cjs

@@ -915,12 +915,42 @@ var import_utils7 = require("@typescript-eslint/utils");
 
 // src/rules/no-rest-destructuring/no-rest-destructuring.utils.ts
 var import_utils6 = require("@typescript-eslint/utils");
+var QUERY_RESULT_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "UseBaseQueryResult",
+  "UseQueryResult",
+  "UseSuspenseQueryResult",
+  "DefinedUseQueryResult",
+  "UseInfiniteQueryResult",
+  "UseSuspenseInfiniteQueryResult",
+  "DefinedUseInfiniteQueryResult",
+  "QueryObserverResult",
+  "InfiniteQueryObserverResult"
+]);
+function isQueryResultType(type) {
+  if (type.aliasSymbol && QUERY_RESULT_TYPE_NAMES.has(type.aliasSymbol.name)) {
+    return true;
+  }
+  const symbol = type.getSymbol();
+  if (symbol && QUERY_RESULT_TYPE_NAMES.has(symbol.name)) {
+    return true;
+  }
+  return type.isUnion() && type.types.some(isQueryResultType);
+}
 var NoRestDestructuringUtils = {
   isObjectRestDestructuring(node) {
     if (node.type !== import_utils6.AST_NODE_TYPES.ObjectPattern) {
       return false;
     }
     return node.properties.some((p) => p.type === import_utils6.AST_NODE_TYPES.RestElement);
+  },
+  isQueryResultCall(node, parserServices) {
+    if (!parserServices?.program || !parserServices.esTreeNodeToTSNodeMap) {
+      return false;
+    }
+    const checker = parserServices.program.getTypeChecker();
+    const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.callee);
+    const signatures = checker.getTypeAtLocation(tsNode).getCallSignatures();
+    return signatures.some((sig) => isQueryResultType(sig.getReturnType()));
   }
 };
 
@@ -953,11 +983,22 @@ var rule3 = createRule3({
     const queryResultVariables = /* @__PURE__ */ new Set();
     return {
       CallExpression: (node) => {
-        if (!ASTUtils.isIdentifierWithOneOfNames(node.callee, queryHooks) || node.parent.type !== import_utils7.AST_NODE_TYPES.VariableDeclarator || !helpers.isTanstackQueryImport(node.callee)) {
+        if (node.parent.type !== import_utils7.AST_NODE_TYPES.VariableDeclarator) {
           return;
         }
         const returnValue = node.parent.id;
-        if (node.callee.name !== "useQueries" && node.callee.name !== "useSuspenseQueries") {
+        const isDirectHook = ASTUtils.isIdentifierWithOneOfNames(node.callee, queryHooks) && helpers.isTanstackQueryImport(node.callee);
+        if (!isDirectHook) {
+          const canReportQueryResult = returnValue.type === import_utils7.AST_NODE_TYPES.Identifier || NoRestDestructuringUtils.isObjectRestDestructuring(returnValue);
+          if (!canReportQueryResult || !NoRestDestructuringUtils.isQueryResultCall(
+            node,
+            context.sourceCode.parserServices
+          )) {
+            return;
+          }
+        }
+        const calleeName = ASTUtils.isIdentifier(node.callee) ? node.callee.name : null;
+        if (calleeName !== "useQueries" && calleeName !== "useSuspenseQueries") {
           if (NoRestDestructuringUtils.isObjectRestDestructuring(returnValue)) {
             return context.report({
               node: node.parent,
@@ -1037,7 +1078,10 @@ var rule4 = createRule4({
   defaultOptions: [],
   create: detectTanstackQueryImports((context, _options, helpers) => {
     const trackedVariables = {};
+    const trackedCustomHooks = {};
     const hookAliasMap = {};
+    const pendingVariableDeclarators = [];
+    const pendingDependencyChecks = [];
     function getReactHook(node) {
       if (node.callee.type === "Identifier") {
         const calleeName = node.callee.name;
@@ -1065,6 +1109,9 @@ var rule4 = createRule4({
         }
       }
     }
+    function isCustomHookName(hookName) {
+      return /^use[A-Z0-9]/.test(hookName);
+    }
     function hasCombineProperty(callExpression) {
       if (callExpression.arguments.length === 0) return false;
       const firstArg = callExpression.arguments[0];
@@ -1074,6 +1121,59 @@ var rule4 = createRule4({
         (prop) => prop.type === import_utils8.AST_NODE_TYPES.Property && prop.key.type === import_utils8.AST_NODE_TYPES.Identifier && prop.key.name === "combine"
       );
     }
+    function getDirectQueryHook(callExpression) {
+      if (callExpression.callee.type !== import_utils8.AST_NODE_TYPES.Identifier || !allHookNames.includes(callExpression.callee.name) || !helpers.isTanstackQueryImport(callExpression.callee)) {
+        return void 0;
+      }
+      if ((callExpression.callee.name === "useQueries" || callExpression.callee.name === "useSuspenseQueries") && hasCombineProperty(callExpression)) {
+        return void 0;
+      }
+      return callExpression.callee.name;
+    }
+    function getTrackedQueryHook(callExpression) {
+      const directQueryHook = getDirectQueryHook(callExpression);
+      if (directQueryHook !== void 0) {
+        return directQueryHook;
+      }
+      if (callExpression.callee.type === import_utils8.AST_NODE_TYPES.Identifier) {
+        return trackedCustomHooks[callExpression.callee.name];
+      }
+      return void 0;
+    }
+    function getReturnedQueryHook(body) {
+      if (body.type === import_utils8.AST_NODE_TYPES.CallExpression) {
+        return getDirectQueryHook(body);
+      }
+      if (body.type !== import_utils8.AST_NODE_TYPES.BlockStatement) {
+        return void 0;
+      }
+      const returnStatements = body.body.filter(
+        (statement) => statement.type === import_utils8.AST_NODE_TYPES.ReturnStatement
+      );
+      if (returnStatements.length !== 1) {
+        return void 0;
+      }
+      const returnArgument = returnStatements[0]?.argument;
+      if (returnArgument?.type === import_utils8.AST_NODE_TYPES.CallExpression) {
+        return getDirectQueryHook(returnArgument);
+      }
+      return void 0;
+    }
+    function checkDependencyArray(reactHook, depsArray) {
+      depsArray.elements.forEach((dep) => {
+        if (dep !== null && dep.type === import_utils8.AST_NODE_TYPES.Identifier && trackedVariables[dep.name] !== void 0) {
+          const queryHook = trackedVariables[dep.name];
+          context.report({
+            node: dep,
+            messageId: "noUnstableDeps",
+            data: {
+              queryHook,
+              reactHook
+            }
+          });
+        }
+      });
+    }
     return {
       ImportDeclaration(node) {
         if (node.specifiers.length > 0 && node.importKind === "value" && node.source.value === "React") {
@@ -1084,32 +1184,48 @@ var rule4 = createRule4({
           });
         }
       },
+      FunctionDeclaration(node) {
+        if (node.id === null || !isCustomHookName(node.id.name)) {
+          return;
+        }
+        const queryHook = getReturnedQueryHook(node.body);
+        if (queryHook !== void 0) {
+          trackedCustomHooks[node.id.name] = queryHook;
+        }
+      },
       VariableDeclarator(node) {
-        if (node.init !== null && node.init.type === import_utils8.AST_NODE_TYPES.CallExpression && node.init.callee.type === import_utils8.AST_NODE_TYPES.Identifier && allHookNames.includes(node.init.callee.name) && helpers.isTanstackQueryImport(node.init.callee)) {
-          if ((node.init.callee.name === "useQueries" || node.init.callee.name === "useSuspenseQueries") && hasCombineProperty(node.init)) {
-            return;
+        if (node.id.type === import_utils8.AST_NODE_TYPES.Identifier && isCustomHookName(node.id.name) && node.init !== null && (node.init.type === import_utils8.AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === import_utils8.AST_NODE_TYPES.FunctionExpression)) {
+          const queryHook = getReturnedQueryHook(node.init.body);
+          if (queryHook !== void 0) {
+            trackedCustomHooks[node.id.name] = queryHook;
           }
-          collectVariableNames(node.id, node.init.callee.name);
+        }
+        if (node.init !== null && node.init.type === import_utils8.AST_NODE_TYPES.CallExpression) {
+          pendingVariableDeclarators.push(node);
         }
       },
       CallExpression: (node) => {
         const reactHook = getReactHook(node);
         if (reactHook !== void 0 && node.arguments.length > 1 && node.arguments[1]?.type === import_utils8.AST_NODE_TYPES.ArrayExpression) {
-          const depsArray = node.arguments[1].elements;
-          depsArray.forEach((dep) => {
-            if (dep !== null && dep.type === import_utils8.AST_NODE_TYPES.Identifier && trackedVariables[dep.name] !== void 0) {
-              const queryHook = trackedVariables[dep.name];
-              context.report({
-                node: dep,
-                messageId: "noUnstableDeps",
-                data: {
-                  queryHook,
-                  reactHook
-                }
-              });
-            }
+          pendingDependencyChecks.push({
+            reactHook,
+            depsArray: node.arguments[1]
           });
         }
+      },
+      "Program:exit"() {
+        pendingVariableDeclarators.forEach((node) => {
+          if (node.init?.type !== import_utils8.AST_NODE_TYPES.CallExpression) {
+            return;
+          }
+          const queryHook = getTrackedQueryHook(node.init);
+          if (queryHook !== void 0) {
+            collectVariableNames(node.id, queryHook);
+          }
+        });
+        pendingDependencyChecks.forEach(({ reactHook, depsArray }) => {
+          checkDependencyArray(reactHook, depsArray);
+        });
       }
     };
   })