feat(eslint-plugin-query): enhance no-rest-destructuring rule to detect spread operations

Author: Newbie012

packages/eslint-plugin-query/src/__tests__/no-rest-destructuring.test.ts

@@ -365,5 +365,30 @@ ruleTester.run('no-rest-destructuring', rule, {
       `,
       errors: [{ messageId: 'objectRestDestructure' }],
     },
+    {
+      name: 'useQuery result is spread in return statement',
+      code: normalizeIndent`
+        import { useQuery } from '@tanstack/react-query'
+
+        function Component() {
+          const query = useQuery()
+          return { ...query, data: query.data[0] }
+        }
+      `,
+      errors: [{ messageId: 'objectRestDestructure' }],
+    },
+    {
+      name: 'useQuery result is spread in object expression',
+      code: normalizeIndent`
+        import { useQuery } from '@tanstack/react-query'
+
+        function Component() {
+          const query = useQuery()
+          const result = { ...query, data: query.data[0] }
+          return result
+        }
+      `,
+      errors: [{ messageId: 'objectRestDestructure' }],
+    },
   ],
 })

packages/eslint-plugin-query/src/rules/no-rest-destructuring/no-rest-destructuring.rule.ts

@@ -34,33 +34,46 @@ export const rule = createRule({
   defaultOptions: [],
 
   create: detectTanstackQueryImports((context, _, helpers) => {
+    // Track variables that hold query results
+    const queryResultVariables = new Set<string>()
+
     return {
       CallExpression: (node) => {
         if (
           !ASTUtils.isIdentifierWithOneOfNames(node.callee, queryHooks) ||
-          !helpers.isTanstackQueryImport(node.callee) ||
-          node.parent.type !== AST_NODE_TYPES.VariableDeclarator
+          node.parent.type !== AST_NODE_TYPES.VariableDeclarator ||
+          !helpers.isTanstackQueryImport(node.callee)
         ) {
           return
         }
 
         const returnValue = node.parent.id
+
         if (
           node.callee.name !== 'useQueries' &&
           node.callee.name !== 'useSuspenseQueries'
         ) {
           if (NoRestDestructuringUtils.isObjectRestDestructuring(returnValue)) {
-            context.report({
+            return context.report({
               node: node.parent,
               messageId: 'objectRestDestructure',
             })
           }
+
+          if (returnValue.type === AST_NODE_TYPES.Identifier) {
+            queryResultVariables.add(returnValue.name)
+          }
+
           return
         }
 
         if (returnValue.type !== AST_NODE_TYPES.ArrayPattern) {
+          if (returnValue.type === AST_NODE_TYPES.Identifier) {
+            queryResultVariables.add(returnValue.name)
+          }
           return
         }
+
         returnValue.elements.forEach((queryResult) => {
           if (queryResult === null) {
             return
@@ -73,6 +86,33 @@ export const rule = createRule({
           }
         })
       },
+
+      // Check for later destructuring of tracked variables
+      VariableDeclarator: (node) => {
+        if (
+          node.init?.type === AST_NODE_TYPES.Identifier &&
+          queryResultVariables.has(node.init.name) &&
+          NoRestDestructuringUtils.isObjectRestDestructuring(node.id)
+        ) {
+          context.report({
+            node,
+            messageId: 'objectRestDestructure',
+          })
+        }
+      },
+
+      // Check for spread operations in object expressions
+      SpreadElement: (node) => {
+        if (
+          node.argument.type === AST_NODE_TYPES.Identifier &&
+          queryResultVariables.has(node.argument.name)
+        ) {
+          context.report({
+            node,
+            messageId: 'objectRestDestructure',
+          })
+        }
+      },
     }
   }),
 })