@tanstack/eslint-plugin-query 5.71.5 → 5.72.1

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

@@ -1,184 +0,0 @@
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils'
-import { ASTUtils } from '../../utils/ast-utils'
-import { getDocsUrl } from '../../utils/get-docs-url'
-import { uniqueBy } from '../../utils/unique-by'
-import { detectTanstackQueryImports } from '../../utils/detect-react-query-imports'
-import { ExhaustiveDepsUtils } from './exhaustive-deps.utils'
-import type { TSESLint, TSESTree } from '@typescript-eslint/utils'
-import type { ExtraRuleDocs } from '../../types'
-
-const QUERY_KEY = 'queryKey'
-const QUERY_FN = 'queryFn'
-
-export const name = 'exhaustive-deps'
-
-const createRule = ESLintUtils.RuleCreator<ExtraRuleDocs>(getDocsUrl)
-
-export const rule = createRule({
-  name,
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Exhaustive deps rule for useQuery',
-      recommended: 'error',
-    },
-    messages: {
-      missingDeps: `The following dependencies are missing in your queryKey: {{deps}}`,
-      fixTo: 'Fix to {{result}}',
-    },
-    hasSuggestions: true,
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-
-  create: detectTanstackQueryImports((context) => {
-    return {
-      Property: (node) => {
-        if (
-          !ASTUtils.isObjectExpression(node.parent) ||
-          !ASTUtils.isIdentifierWithName(node.key, QUERY_KEY)
-        ) {
-          return
-        }
-
-        const scopeManager = context.sourceCode.scopeManager
-        const queryKey = ASTUtils.findPropertyWithIdentifierKey(
-          node.parent.properties,
-          QUERY_KEY,
-        )
-        const queryFn = ASTUtils.findPropertyWithIdentifierKey(
-          node.parent.properties,
-          QUERY_FN,
-        )
-
-        if (
-          scopeManager === null ||
-          queryKey === undefined ||
-          queryFn === undefined ||
-          !ASTUtils.isNodeOfOneOf(queryFn.value, [
-            AST_NODE_TYPES.ArrowFunctionExpression,
-            AST_NODE_TYPES.FunctionExpression,
-            AST_NODE_TYPES.ConditionalExpression,
-          ])
-        ) {
-          return
-        }
-
-        let queryKeyNode = queryKey.value
-
-        if (
-          queryKeyNode.type === AST_NODE_TYPES.TSAsExpression &&
-          queryKeyNode.expression.type === AST_NODE_TYPES.ArrayExpression
-        ) {
-          queryKeyNode = queryKeyNode.expression
-        }
-
-        if (queryKeyNode.type === AST_NODE_TYPES.Identifier) {
-          const expression = ASTUtils.getReferencedExpressionByIdentifier({
-            context,
-            node: queryKeyNode,
-          })
-
-          if (expression?.type === AST_NODE_TYPES.ArrayExpression) {
-            queryKeyNode = expression
-          }
-        }
-
-        const externalRefs = ASTUtils.getExternalRefs({
-          scopeManager,
-          sourceCode: context.sourceCode,
-          node: getQueryFnRelevantNode(queryFn),
-        })
-
-        const relevantRefs = externalRefs.filter((reference) =>
-          ExhaustiveDepsUtils.isRelevantReference({
-            sourceCode: context.sourceCode,
-            reference,
-            scopeManager,
-            node: getQueryFnRelevantNode(queryFn),
-          }),
-        )
-
-        const existingKeys = ASTUtils.getNestedIdentifiers(queryKeyNode).map(
-          (identifier) =>
-            ASTUtils.mapKeyNodeToBaseText(identifier, context.sourceCode),
-        )
-
-        const missingRefs = relevantRefs
-          .map((ref) => ({
-            ref: ref,
-            text: 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] ?? '')
-            )
-          })
-          .map(({ ref, text }) => ({
-            identifier: ref.identifier,
-            text: text,
-          }))
-
-        const uniqueMissingRefs = uniqueBy(missingRefs, (x) => x.text)
-
-        if (uniqueMissingRefs.length > 0) {
-          const missingAsText = uniqueMissingRefs
-            .map((ref) =>
-              ASTUtils.mapKeyNodeToText(ref.identifier, context.sourceCode),
-            )
-            .join(', ')
-
-          const queryKeyValue = context.sourceCode.getText(queryKeyNode)
-
-          const existingWithMissing =
-            queryKeyValue === '[]'
-              ? `[${missingAsText}]`
-              : queryKeyValue.replace(/\]$/, `, ${missingAsText}]`)
-
-          const suggestions: TSESLint.ReportSuggestionArray<string> = []
-
-          if (queryKeyNode.type === AST_NODE_TYPES.ArrayExpression) {
-            suggestions.push({
-              messageId: 'fixTo',
-              data: { result: existingWithMissing },
-              fix(fixer) {
-                return fixer.replaceText(queryKeyNode, existingWithMissing)
-              },
-            })
-          }
-
-          context.report({
-            node: node,
-            messageId: 'missingDeps',
-            data: {
-              deps: uniqueMissingRefs.map((ref) => ref.text).join(', '),
-            },
-            suggest: suggestions,
-          })
-        }
-      },
-    }
-  }),
-})
-
-function getQueryFnRelevantNode(queryFn: TSESTree.Property) {
-  if (queryFn.value.type !== AST_NODE_TYPES.ConditionalExpression) {
-    return queryFn.value
-  }
-
-  if (
-    queryFn.value.consequent.type === AST_NODE_TYPES.Identifier &&
-    queryFn.value.consequent.name === 'skipToken'
-  ) {
-    return queryFn.value.alternate
-  }
-
-  return queryFn.value.consequent
-}

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

@@ -1,41 +0,0 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/utils'
-import { ASTUtils } from '../../utils/ast-utils'
-import type { TSESLint, TSESTree } from '@typescript-eslint/utils'
-
-export const ExhaustiveDepsUtils = {
-  isRelevantReference(params: {
-    sourceCode: Readonly<TSESLint.SourceCode>
-    reference: TSESLint.Scope.Reference
-    scopeManager: TSESLint.Scope.ScopeManager
-    node: TSESTree.Node
-  }) {
-    const { sourceCode, reference, scopeManager, node } = params
-    const component = ASTUtils.getFunctionAncestor(sourceCode, node)
-
-    if (component === undefined) {
-      return false
-    }
-
-    if (
-      !ASTUtils.isDeclaredInNode({
-        scopeManager,
-        reference,
-        functionNode: component,
-      })
-    ) {
-      return false
-    }
-
-    return (
-      reference.identifier.name !== 'undefined' &&
-      reference.identifier.parent.type !== AST_NODE_TYPES.NewExpression &&
-      !ExhaustiveDepsUtils.isInstanceOfKind(reference.identifier.parent)
-    )
-  },
-  isInstanceOfKind(node: TSESTree.Node) {
-    return (
-      node.type === AST_NODE_TYPES.BinaryExpression &&
-      node.operator === 'instanceof'
-    )
-  },
-}

package/src/rules/infinite-query-property-order/constants.ts

@@ -1,17 +0,0 @@
-export const infiniteQueryFunctions = [
-  'infiniteQueryOptions',
-  'useInfiniteQuery',
-  'useSuspenseInfiniteQuery',
-] as const
-
-export type InfiniteQueryFunctions = (typeof infiniteQueryFunctions)[number]
-
-export const checkedProperties = [
-  'queryFn',
-  'getPreviousPageParam',
-  'getNextPageParam',
-] as const
-
-export const sortRules = [
-  [['queryFn'], ['getPreviousPageParam', 'getNextPageParam']],
-] as const

package/src/rules/infinite-query-property-order/infinite-query-property-order.rule.ts

@@ -1,107 +0,0 @@
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils'
-
-import { getDocsUrl } from '../../utils/get-docs-url'
-import { detectTanstackQueryImports } from '../../utils/detect-react-query-imports'
-import { sortDataByOrder } from './infinite-query-property-order.utils'
-import { infiniteQueryFunctions, sortRules } from './constants'
-import type { InfiniteQueryFunctions } from './constants'
-import type { ExtraRuleDocs } from '../../types'
-
-const createRule = ESLintUtils.RuleCreator<ExtraRuleDocs>(getDocsUrl)
-
-const infiniteQueryFunctionsSet = new Set(infiniteQueryFunctions)
-function isInfiniteQueryFunction(node: any): node is InfiniteQueryFunctions {
-  return infiniteQueryFunctionsSet.has(node)
-}
-
-export const name = 'infinite-query-property-order'
-
-export const rule = createRule({
-  name,
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Ensure correct order of inference sensitive properties for infinite queries',
-      recommended: 'error',
-    },
-    messages: {
-      invalidOrder: 'Invalid order of properties for `{{function}}`.',
-    },
-    schema: [],
-    hasSuggestions: true,
-    fixable: 'code',
-  },
-  defaultOptions: [],
-
-  create: detectTanstackQueryImports((context) => {
-    return {
-      CallExpression(node) {
-        if (node.callee.type !== AST_NODE_TYPES.Identifier) {
-          return
-        }
-        const infiniteQueryFunction = node.callee.name
-        if (!isInfiniteQueryFunction(infiniteQueryFunction)) {
-          return
-        }
-        const argument = node.arguments[0]
-        if (argument === undefined || argument.type !== 'ObjectExpression') {
-          return
-        }
-
-        const allProperties = argument.properties
-
-        // no need to sort if there is at max 1 property
-        if (allProperties.length < 2) {
-          return
-        }
-
-        const properties = allProperties.flatMap((p, index) => {
-          if (
-            p.type === AST_NODE_TYPES.Property &&
-            p.key.type === AST_NODE_TYPES.Identifier
-          ) {
-            return { name: p.key.name, property: p }
-          } else return { name: `_property_${index}`, property: p }
-        })
-
-        const sortedProperties = sortDataByOrder(properties, sortRules, 'name')
-        if (sortedProperties === null) {
-          return
-        }
-        context.report({
-          node: argument,
-          data: { function: node.callee.name },
-          messageId: 'invalidOrder',
-          fix(fixer) {
-            const sourceCode = context.sourceCode
-
-            const reorderedText = sortedProperties.reduce(
-              (sourceText, specifier, index) => {
-                let textBetweenProperties = ''
-                if (index < allProperties.length - 1) {
-                  textBetweenProperties = sourceCode
-                    .getText()
-                    .slice(
-                      allProperties[index]!.range[1],
-                      allProperties[index + 1]!.range[0],
-                    )
-                }
-                return (
-                  sourceText +
-                  sourceCode.getText(specifier.property) +
-                  textBetweenProperties
-                )
-              },
-              '',
-            )
-            return fixer.replaceTextRange(
-              [allProperties[0]!.range[0], allProperties.at(-1)!.range[1]],
-              reorderedText,
-            )
-          },
-        })
-      },
-    }
-  }),
-})

package/src/rules/infinite-query-property-order/infinite-query-property-order.utils.ts

@@ -1,67 +0,0 @@
-export function sortDataByOrder<T, TKey extends keyof T>(
-  data: Array<T> | ReadonlyArray<T>,
-  orderRules: ReadonlyArray<
-    Readonly<[ReadonlyArray<T[TKey]>, ReadonlyArray<T[TKey]>]>
-  >,
-  key: TKey,
-): Array<T> | null {
-  const getSubsetIndex = (
-    item: T[TKey],
-    subsets: ReadonlyArray<ReadonlyArray<T[TKey]> | Array<T[TKey]>>,
-  ): number | null => {
-    for (let i = 0; i < subsets.length; i++) {
-      if (subsets[i]?.includes(item)) {
-        return i
-      }
-    }
-    return null
-  }
-
-  const orderSets = orderRules.reduce(
-    (sets, [A, B]) => [...sets, A, B],
-    [] as Array<ReadonlyArray<T[TKey]> | Array<T[TKey]>>,
-  )
-
-  const inOrderArray = data.filter(
-    (item) => getSubsetIndex(item[key], orderSets) !== null,
-  )
-
-  let wasResorted = false as boolean
-
-  // Sort by the relative order defined by the rules
-  const sortedArray = inOrderArray.sort((a, b) => {
-    const aKey = a[key],
-      bKey = b[key]
-    const aSubsetIndex = getSubsetIndex(aKey, orderSets)
-    const bSubsetIndex = getSubsetIndex(bKey, orderSets)
-
-    // If both items belong to different subsets, sort by their subset order
-    if (
-      aSubsetIndex !== null &&
-      bSubsetIndex !== null &&
-      aSubsetIndex !== bSubsetIndex
-    ) {
-      return aSubsetIndex - bSubsetIndex
-    }
-
-    // If both items belong to the same subset or neither is in the subset, keep their relative order
-    return 0
-  })
-
-  const inOrderIterator = sortedArray.values()
-  const result = data.map((item) => {
-    if (getSubsetIndex(item[key], orderSets) !== null) {
-      const sortedItem = inOrderIterator.next().value!
-      if (sortedItem[key] !== item[key]) {
-        wasResorted = true
-      }
-      return sortedItem
-    }
-    return item
-  })
-
-  if (!wasResorted) {
-    return null
-  }
-  return result
-}

package/src/rules/no-rest-destructuring/no-rest-destructuring.rule.ts

@@ -1,115 +0,0 @@
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils'
-import { getDocsUrl } from '../../utils/get-docs-url'
-import { ASTUtils } from '../../utils/ast-utils'
-import { detectTanstackQueryImports } from '../../utils/detect-react-query-imports'
-import { NoRestDestructuringUtils } from './no-rest-destructuring.utils'
-import type { ExtraRuleDocs } from '../../types'
-
-export const name = 'no-rest-destructuring'
-
-const queryHooks = [
-  'useQuery',
-  'useQueries',
-  'useInfiniteQuery',
-  'useSuspenseQuery',
-  'useSuspenseQueries',
-  'useSuspenseInfiniteQuery',
-]
-
-const createRule = ESLintUtils.RuleCreator<ExtraRuleDocs>(getDocsUrl)
-
-export const rule = createRule({
-  name,
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallows rest destructuring in queries',
-      recommended: 'warn',
-    },
-    messages: {
-      objectRestDestructure: `Object rest destructuring on a query will observe all changes to the query, leading to excessive re-renders.`,
-    },
-    schema: [],
-  },
-  defaultOptions: [],
-
-  create: detectTanstackQueryImports((context, _, helpers) => {
-    const queryResultVariables = new Set<string>()
-
-    return {
-      CallExpression: (node) => {
-        if (
-          !ASTUtils.isIdentifierWithOneOfNames(node.callee, queryHooks) ||
-          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)) {
-            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
-          }
-          if (NoRestDestructuringUtils.isObjectRestDestructuring(queryResult)) {
-            context.report({
-              node: queryResult,
-              messageId: 'objectRestDestructure',
-            })
-          }
-        })
-      },
-
-      VariableDeclarator: (node) => {
-        if (
-          node.init?.type === AST_NODE_TYPES.Identifier &&
-          queryResultVariables.has(node.init.name) &&
-          NoRestDestructuringUtils.isObjectRestDestructuring(node.id)
-        ) {
-          context.report({
-            node,
-            messageId: 'objectRestDestructure',
-          })
-        }
-      },
-
-      SpreadElement: (node) => {
-        if (
-          node.argument.type === AST_NODE_TYPES.Identifier &&
-          queryResultVariables.has(node.argument.name)
-        ) {
-          context.report({
-            node,
-            messageId: 'objectRestDestructure',
-          })
-        }
-      },
-    }
-  }),
-})

package/src/rules/no-rest-destructuring/no-rest-destructuring.utils.ts

@@ -1,11 +0,0 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/utils'
-import type { TSESTree } from '@typescript-eslint/utils'
-
-export const NoRestDestructuringUtils = {
-  isObjectRestDestructuring(node: TSESTree.Node): boolean {
-    if (node.type !== AST_NODE_TYPES.ObjectPattern) {
-      return false
-    }
-    return node.properties.some((p) => p.type === AST_NODE_TYPES.RestElement)
-  },
-}

package/src/rules/no-unstable-deps/no-unstable-deps.rule.ts

@@ -1,129 +0,0 @@
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils'
-import { getDocsUrl } from '../../utils/get-docs-url'
-import { detectTanstackQueryImports } from '../../utils/detect-react-query-imports'
-import type { TSESTree } from '@typescript-eslint/utils'
-import type { ExtraRuleDocs } from '../../types'
-
-export const name = 'no-unstable-deps'
-
-export const reactHookNames = ['useEffect', 'useCallback', 'useMemo']
-export const useQueryHookNames = [
-  'useQuery',
-  'useSuspenseQuery',
-  'useQueries',
-  'useSuspenseQueries',
-  'useInfiniteQuery',
-  'useSuspenseInfiniteQuery',
-]
-const allHookNames = ['useMutation', ...useQueryHookNames]
-const createRule = ESLintUtils.RuleCreator<ExtraRuleDocs>(getDocsUrl)
-
-export const rule = createRule({
-  name,
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Disallow putting the result of query hooks directly in a React hook dependency array',
-      recommended: 'error',
-    },
-    messages: {
-      noUnstableDeps: `The result of {{queryHook}} is not referentially stable, so don't pass it directly into the dependencies array of {{reactHook}}. Instead, destructure the return value of {{queryHook}} and pass the destructured values into the dependency array of {{reactHook}}.`,
-    },
-    schema: [],
-  },
-  defaultOptions: [],
-
-  create: detectTanstackQueryImports((context) => {
-    const trackedVariables: Record<string, string> = {}
-    const hookAliasMap: Record<string, string> = {}
-
-    function getReactHook(node: TSESTree.CallExpression): string | undefined {
-      if (node.callee.type === 'Identifier') {
-        const calleeName = node.callee.name
-        // Check if the identifier is a known React hook or an alias
-        if (reactHookNames.includes(calleeName) || calleeName in hookAliasMap) {
-          return calleeName
-        }
-      } else if (
-        node.callee.type === 'MemberExpression' &&
-        node.callee.object.type === 'Identifier' &&
-        node.callee.object.name === 'React' &&
-        node.callee.property.type === 'Identifier' &&
-        reactHookNames.includes(node.callee.property.name)
-      ) {
-        // Member expression case: `React.useCallback`
-        return node.callee.property.name
-      }
-      return undefined
-    }
-
-    function collectVariableNames(
-      pattern: TSESTree.BindingName,
-      queryHook: string,
-    ) {
-      if (pattern.type === AST_NODE_TYPES.Identifier) {
-        trackedVariables[pattern.name] = queryHook
-      }
-    }
-
-    return {
-      ImportDeclaration(node: TSESTree.ImportDeclaration) {
-        if (
-          node.specifiers.length > 0 &&
-          node.importKind === 'value' &&
-          node.source.value === 'React'
-        ) {
-          node.specifiers.forEach((specifier) => {
-            if (
-              specifier.type === AST_NODE_TYPES.ImportSpecifier &&
-              specifier.imported.type === AST_NODE_TYPES.Identifier &&
-              reactHookNames.includes(specifier.imported.name)
-            ) {
-              // Track alias or direct import
-              hookAliasMap[specifier.local.name] = specifier.imported.name
-            }
-          })
-        }
-      },
-
-      VariableDeclarator(node) {
-        if (
-          node.init !== null &&
-          node.init.type === AST_NODE_TYPES.CallExpression &&
-          node.init.callee.type === AST_NODE_TYPES.Identifier &&
-          allHookNames.includes(node.init.callee.name)
-        ) {
-          collectVariableNames(node.id, node.init.callee.name)
-        }
-      },
-      CallExpression: (node) => {
-        const reactHook = getReactHook(node)
-        if (
-          reactHook !== undefined &&
-          node.arguments.length > 1 &&
-          node.arguments[1]?.type === AST_NODE_TYPES.ArrayExpression
-        ) {
-          const depsArray = node.arguments[1].elements
-          depsArray.forEach((dep) => {
-            if (
-              dep !== null &&
-              dep.type === AST_NODE_TYPES.Identifier &&
-              trackedVariables[dep.name] !== undefined
-            ) {
-              const queryHook = trackedVariables[dep.name]
-              context.report({
-                node: dep,
-                messageId: 'noUnstableDeps',
-                data: {
-                  queryHook,
-                  reactHook,
-                },
-              })
-            }
-          })
-        }
-      },
-    }
-  }),
-})