@tanstack/eslint-plugin-query 5.95.2 → 5.96.1

package/build/modern/index.cjs

@@ -4,8 +4,8 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name8 in all)
-    __defProp(target, name8, { get: all[name8], enumerable: true });
+  for (var name9 in all)
+    __defProp(target, name9, { get: all[name9], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -44,11 +44,11 @@ var ASTUtils = {
   isIdentifier(node) {
     return node.type === import_utils.AST_NODE_TYPES.Identifier;
   },
-  isIdentifierWithName(node, name8) {
-    return ASTUtils.isIdentifier(node) && node.name === name8;
+  isIdentifierWithName(node, name9) {
+    return ASTUtils.isIdentifier(node) && node.name === name9;
   },
-  isIdentifierWithOneOfNames(node, name8) {
-    return ASTUtils.isIdentifier(node) && name8.includes(node.name);
+  isIdentifierWithOneOfNames(node, name9) {
+    return ASTUtils.isIdentifier(node) && name9.includes(node.name);
   },
   isProperty(node) {
     return node.type === import_utils.AST_NODE_TYPES.Property;
@@ -418,8 +418,8 @@ var ExhaustiveDepsUtils = {
     const roots = /* @__PURE__ */ new Set();
     const paths = /* @__PURE__ */ new Set();
     const visitorKeys = sourceCode.visitorKeys;
-    function addRoot(name8) {
-      const cleaned = ExhaustiveDepsUtils.normalizeChain(name8);
+    function addRoot(name9) {
+      const cleaned = ExhaustiveDepsUtils.normalizeChain(name9);
       roots.add(cleaned);
       paths.add(cleaned);
     }
@@ -1345,6 +1345,257 @@ var rule7 = createPropertyOrderRule(
   sortRules2
 );
 
+// src/rules/prefer-query-options/prefer-query-options.rule.ts
+var import_utils11 = require("@typescript-eslint/utils");
+var name8 = "prefer-query-options";
+var queryHooks2 = [
+  "useQuery",
+  "useInfiniteQuery",
+  "useSuspenseQuery",
+  "useSuspenseInfiniteQuery",
+  "usePrefetchQuery",
+  "usePrefetchInfiniteQuery"
+];
+var queriesHooks = ["useQueries", "useSuspenseQueries"];
+var filterHooks = ["useIsFetching"];
+var queryClientOptionMethods = [
+  "fetchQuery",
+  "prefetchQuery",
+  "fetchInfiniteQuery",
+  "prefetchInfiniteQuery",
+  "ensureQueryData",
+  "ensureInfiniteQueryData"
+];
+var queryClientQueryKeyMethods = [
+  "getQueryData",
+  "setQueryData",
+  "getQueryState",
+  "setQueryDefaults",
+  "getQueryDefaults"
+];
+var queryClientFilterMethods = [
+  "invalidateQueries",
+  "cancelQueries",
+  "refetchQueries",
+  "removeQueries",
+  "resetQueries",
+  "isFetching",
+  "getQueriesData",
+  "setQueriesData"
+];
+var queryOptionsBuilders = ["queryOptions", "infiniteQueryOptions"];
+var createRule7 = import_utils11.ESLintUtils.RuleCreator(getDocsUrl);
+var rule8 = createRule7({
+  name: name8,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prefer using queryOptions() to co-locate queryKey and queryFn",
+      recommended: "strict"
+    },
+    messages: {
+      preferQueryOptions: "Prefer using queryOptions() or infiniteQueryOptions() to co-locate queryKey and queryFn.",
+      preferQueryOptionsQueryKey: "Prefer referencing a queryKey from a queryOptions() result instead of typing it manually."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: detectTanstackQueryImports((context, _, helpers) => {
+    function reportInlineQueryOptions(node) {
+      if (ASTUtils.isObjectExpression(node) && hasInlineQueryOptions(node)) {
+        context.report({
+          node,
+          messageId: "preferQueryOptions"
+        });
+      }
+    }
+    function reportInlineFilterQueryKey(node) {
+      if (ASTUtils.isObjectExpression(node) && hasInlineFilterQueryKey(node)) {
+        context.report({
+          node,
+          messageId: "preferQueryOptionsQueryKey"
+        });
+      }
+    }
+    return {
+      CallExpression: (node) => {
+        if (ASTUtils.isIdentifier(node.callee)) {
+          const importedName = getTanstackImportName(
+            context,
+            helpers,
+            node.callee
+          );
+          if (importedName === null) {
+            return;
+          }
+          if (queryOptionsBuilders.includes(importedName)) {
+            return;
+          }
+          const options2 = node.arguments[0];
+          if (options2 === void 0) {
+            return;
+          }
+          if (queryHooks2.includes(importedName)) {
+            reportInlineQueryOptions(options2);
+            return;
+          }
+          if (queriesHooks.includes(importedName) && ASTUtils.isObjectExpression(options2)) {
+            const queries = ASTUtils.findPropertyWithIdentifierKey(
+              options2.properties,
+              "queries"
+            )?.value;
+            if (queries !== void 0) {
+              getQueryObjects(queries).forEach((query) => {
+                reportInlineQueryOptions(query);
+              });
+            }
+            return;
+          }
+          if (filterHooks.includes(importedName)) {
+            reportInlineFilterQueryKey(options2);
+          }
+          return;
+        }
+        if (node.callee.type !== import_utils11.AST_NODE_TYPES.MemberExpression || !ASTUtils.isIdentifier(node.callee.property) || !isTanstackQueryClient(node.callee.object, context, helpers)) {
+          return;
+        }
+        const method = node.callee.property.name;
+        const options = node.arguments[0];
+        if (options === void 0) {
+          return;
+        }
+        if (queryClientOptionMethods.includes(method)) {
+          reportInlineQueryOptions(options);
+          return;
+        }
+        if (queryClientQueryKeyMethods.includes(method) && isInlineArrayExpression(options)) {
+          context.report({
+            node: options,
+            messageId: "preferQueryOptionsQueryKey"
+          });
+          return;
+        }
+        if (queryClientFilterMethods.includes(method)) {
+          reportInlineFilterQueryKey(options);
+        }
+      }
+    };
+  })
+});
+function hasInlineQueryOptions(node) {
+  return ASTUtils.findPropertyWithIdentifierKey(node.properties, "queryKey") !== void 0 || ASTUtils.findPropertyWithIdentifierKey(node.properties, "queryFn") !== void 0;
+}
+function hasInlineFilterQueryKey(node) {
+  const queryKey = ASTUtils.findPropertyWithIdentifierKey(
+    node.properties,
+    "queryKey"
+  )?.value;
+  return queryKey !== void 0 && isInlineArrayExpression(queryKey);
+}
+function isInlineArrayExpression(node) {
+  return unwrapTypeAssertions(node).type === import_utils11.AST_NODE_TYPES.ArrayExpression;
+}
+function getReturnedObjectExpressions(node) {
+  if (ASTUtils.isObjectExpression(node)) {
+    return [node];
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils11.AST_NODE_TYPES.FunctionExpression) {
+    return getReturnedObjectExpressions(node.body);
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.BlockStatement) {
+    return node.body.flatMap((statement) => {
+      if (statement.type === import_utils11.AST_NODE_TYPES.ReturnStatement && statement.argument !== null) {
+        return getReturnedObjectExpressions(statement.argument);
+      }
+      return [];
+    });
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.ConditionalExpression) {
+    return [
+      ...getReturnedObjectExpressions(node.consequent),
+      ...getReturnedObjectExpressions(node.alternate)
+    ];
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.LogicalExpression) {
+    return [
+      ...getReturnedObjectExpressions(node.left),
+      ...getReturnedObjectExpressions(node.right)
+    ];
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.SequenceExpression) {
+    return node.expressions.flatMap(
+      (expression) => getReturnedObjectExpressions(expression)
+    );
+  }
+  return [];
+}
+function getQueryObjects(node) {
+  if (node.type === import_utils11.AST_NODE_TYPES.ArrayExpression) {
+    return node.elements.flatMap((element) => {
+      if (element !== null && ASTUtils.isObjectExpression(element)) {
+        return [element];
+      }
+      return [];
+    });
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils11.AST_NODE_TYPES.MemberExpression && ASTUtils.isIdentifierWithName(node.callee.property, "map")) {
+    const mapper = node.arguments[0];
+    if (mapper?.type === import_utils11.AST_NODE_TYPES.ArrowFunctionExpression || mapper?.type === import_utils11.AST_NODE_TYPES.FunctionExpression) {
+      return getReturnedObjectExpressions(mapper);
+    }
+  }
+  return [];
+}
+function isTanstackQueryClient(node, context, helpers) {
+  const source = resolveQueryClientSource(node, context);
+  if (source.type === import_utils11.AST_NODE_TYPES.CallExpression && ASTUtils.isIdentifier(source.callee)) {
+    return getTanstackImportName(context, helpers, source.callee) === "useQueryClient";
+  }
+  if (source.type === import_utils11.AST_NODE_TYPES.NewExpression && ASTUtils.isIdentifier(source.callee)) {
+    return getTanstackImportName(context, helpers, source.callee) === "QueryClient";
+  }
+  return false;
+}
+function getTanstackImportName(context, helpers, node) {
+  if (!helpers.isTanstackQueryImport(node)) {
+    return null;
+  }
+  const definition = context.sourceCode.getScope(node).references.find((reference) => reference.identifier === node)?.resolved?.defs[0]?.node;
+  if (definition?.type !== import_utils11.AST_NODE_TYPES.ImportSpecifier || definition.imported.type !== import_utils11.AST_NODE_TYPES.Identifier) {
+    return null;
+  }
+  return definition.imported.name;
+}
+function resolveQueryClientSource(node, context) {
+  const visitedNodes = /* @__PURE__ */ new Set();
+  while (!visitedNodes.has(node)) {
+    visitedNodes.add(node);
+    if (node.type === import_utils11.AST_NODE_TYPES.ChainExpression) {
+      node = node.expression;
+      continue;
+    }
+    node = unwrapTypeAssertions(node);
+    if (node.type !== import_utils11.AST_NODE_TYPES.Identifier) {
+      return node;
+    }
+    const expression = ASTUtils.getReferencedExpressionByIdentifier({
+      context,
+      node
+    });
+    if (expression === null) {
+      return node;
+    }
+    node = expression;
+  }
+  return node;
+}
+function unwrapTypeAssertions(node) {
+  while (node.type === import_utils11.AST_NODE_TYPES.TSAsExpression || node.type === import_utils11.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils11.AST_NODE_TYPES.TSTypeAssertion) {
+    node = node.expression;
+  }
+  return node;
+}
+
 // src/rules.ts
 var rules = {
   [name]: rule,
@@ -1353,10 +1604,24 @@ var rules = {
   [name4]: rule4,
   [name5]: rule5,
   [name6]: rule6,
-  [name7]: rule7
+  [name7]: rule7,
+  [name8]: rule8
 };
 
 // src/index.ts
+var recommendedRules = {
+  "@tanstack/query/exhaustive-deps": "error",
+  "@tanstack/query/no-rest-destructuring": "warn",
+  "@tanstack/query/stable-query-client": "error",
+  "@tanstack/query/no-unstable-deps": "error",
+  "@tanstack/query/infinite-query-property-order": "error",
+  "@tanstack/query/no-void-query-fn": "error",
+  "@tanstack/query/mutation-property-order": "error"
+};
+var recommendedStrictRules = {
+  ...recommendedRules,
+  "@tanstack/query/prefer-query-options": "error"
+};
 var plugin = {
   meta: {
     name: "@tanstack/eslint-plugin-query"
@@ -1364,15 +1629,11 @@ var plugin = {
   configs: {
     recommended: {
       plugins: ["@tanstack/query"],
-      rules: {
-        "@tanstack/query/exhaustive-deps": "error",
-        "@tanstack/query/no-rest-destructuring": "warn",
-        "@tanstack/query/stable-query-client": "error",
-        "@tanstack/query/no-unstable-deps": "error",
-        "@tanstack/query/infinite-query-property-order": "error",
-        "@tanstack/query/no-void-query-fn": "error",
-        "@tanstack/query/mutation-property-order": "error"
-      }
+      rules: recommendedRules
+    },
+    recommendedStrict: {
+      plugins: ["@tanstack/query"],
+      rules: recommendedStrictRules
     },
     "flat/recommended": [
       {
@@ -1381,21 +1642,24 @@ var plugin = {
           "@tanstack/query": {}
           // Assigned after plugin object created
         },
-        rules: {
-          "@tanstack/query/exhaustive-deps": "error",
-          "@tanstack/query/no-rest-destructuring": "warn",
-          "@tanstack/query/stable-query-client": "error",
-          "@tanstack/query/no-unstable-deps": "error",
-          "@tanstack/query/infinite-query-property-order": "error",
-          "@tanstack/query/no-void-query-fn": "error",
-          "@tanstack/query/mutation-property-order": "error"
-        }
+        rules: recommendedRules
+      }
+    ],
+    "flat/recommended-strict": [
+      {
+        name: "tanstack/query/flat/recommended-strict",
+        plugins: {
+          "@tanstack/query": {}
+          // Assigned after plugin object created
+        },
+        rules: recommendedStrictRules
       }
     ]
   },
   rules
 };
 plugin.configs["flat/recommended"][0].plugins["@tanstack/query"] = plugin;
+plugin.configs["flat/recommended-strict"][0].plugins["@tanstack/query"] = plugin;
 var index_default = plugin;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {