@tanstack/eslint-plugin-query 5.95.1 → 5.96.0

package/build/modern/_tsup-dts-rollup.d.ts

@@ -225,7 +225,9 @@ export declare const name_alias_4 = "no-unstable-deps";
 
 export declare const name_alias_5 = "no-void-query-fn";
 
-export declare const name_alias_6 = "stable-query-client";
+export declare const name_alias_6 = "prefer-query-options";
+
+export declare const name_alias_7 = "stable-query-client";
 
 export declare const NoRestDestructuringUtils: {
     isObjectRestDestructuring(node: TSESTree.Node): boolean;
@@ -243,13 +245,26 @@ declare const plugin: {
         recommended: {
             plugins: string[];
             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";
+                readonly '@tanstack/query/exhaustive-deps': "error";
+                readonly '@tanstack/query/no-rest-destructuring': "warn";
+                readonly '@tanstack/query/stable-query-client': "error";
+                readonly '@tanstack/query/no-unstable-deps': "error";
+                readonly '@tanstack/query/infinite-query-property-order': "error";
+                readonly '@tanstack/query/no-void-query-fn': "error";
+                readonly '@tanstack/query/mutation-property-order': "error";
+            };
+        };
+        recommendedStrict: {
+            plugins: string[];
+            rules: {
+                readonly '@tanstack/query/prefer-query-options': "error";
+                readonly '@tanstack/query/exhaustive-deps': "error";
+                readonly '@tanstack/query/no-rest-destructuring': "warn";
+                readonly '@tanstack/query/stable-query-client': "error";
+                readonly '@tanstack/query/no-unstable-deps': "error";
+                readonly '@tanstack/query/infinite-query-property-order': "error";
+                readonly '@tanstack/query/no-void-query-fn': "error";
+                readonly '@tanstack/query/mutation-property-order': "error";
             };
         };
         'flat/recommended': {
@@ -258,13 +273,29 @@ declare const plugin: {
                 '@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";
+                readonly '@tanstack/query/exhaustive-deps': "error";
+                readonly '@tanstack/query/no-rest-destructuring': "warn";
+                readonly '@tanstack/query/stable-query-client': "error";
+                readonly '@tanstack/query/no-unstable-deps': "error";
+                readonly '@tanstack/query/infinite-query-property-order': "error";
+                readonly '@tanstack/query/no-void-query-fn': "error";
+                readonly '@tanstack/query/mutation-property-order': "error";
+            };
+        }[];
+        'flat/recommended-strict': {
+            name: string;
+            plugins: {
+                '@tanstack/query': {};
+            };
+            rules: {
+                readonly '@tanstack/query/prefer-query-options': "error";
+                readonly '@tanstack/query/exhaustive-deps': "error";
+                readonly '@tanstack/query/no-rest-destructuring': "warn";
+                readonly '@tanstack/query/stable-query-client': "error";
+                readonly '@tanstack/query/no-unstable-deps': "error";
+                readonly '@tanstack/query/infinite-query-property-order': "error";
+                readonly '@tanstack/query/no-void-query-fn': "error";
+                readonly '@tanstack/query/mutation-property-order': "error";
             };
         }[];
     };
@@ -277,7 +308,9 @@ declare interface Plugin_2 extends Omit<ESLint.Plugin, 'rules'> {
     rules: Record<RuleKey, RuleModule<any, any, any>>;
     configs: {
         recommended: ESLint.ConfigData;
+        recommendedStrict: ESLint.ConfigData;
         'flat/recommended': Array<Linter.Config>;
+        'flat/recommended-strict': Array<Linter.Config>;
     };
 }
 export { Plugin_2 as Plugin }
@@ -312,6 +345,10 @@ export declare const rule_alias_6: ESLintUtils.RuleModule<string, readonly unkno
     name: string;
 };
 
+export declare const rule_alias_7: ESLintUtils.RuleModule<string, readonly unknown[], ExtraRuleDocs, ESLintUtils.RuleListener> & {
+    name: string;
+};
+
 declare type RuleKey = keyof typeof rules;
 
 export declare const rules: Record<string, ESLintUtils.RuleModule<string, ReadonlyArray<unknown>, ExtraRuleDocs, ESLintUtils.RuleListener>>;

package/build/modern/{chunk-XH4ABCYA.js → chunk-J3JFOQ5Q.js}

@@ -17,11 +17,11 @@ var ASTUtils = {
   isIdentifier(node) {
     return node.type === 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 === AST_NODE_TYPES.Property;
@@ -391,8 +391,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);
     }
@@ -1318,6 +1318,257 @@ var rule7 = createPropertyOrderRule(
   sortRules2
 );
 
+// src/rules/prefer-query-options/prefer-query-options.rule.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES9, ESLintUtils as ESLintUtils7 } from "@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 = ESLintUtils7.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 !== AST_NODE_TYPES9.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 === AST_NODE_TYPES9.ArrayExpression;
+}
+function getReturnedObjectExpressions(node) {
+  if (ASTUtils.isObjectExpression(node)) {
+    return [node];
+  }
+  if (node.type === AST_NODE_TYPES9.ArrowFunctionExpression || node.type === AST_NODE_TYPES9.FunctionExpression) {
+    return getReturnedObjectExpressions(node.body);
+  }
+  if (node.type === AST_NODE_TYPES9.BlockStatement) {
+    return node.body.flatMap((statement) => {
+      if (statement.type === AST_NODE_TYPES9.ReturnStatement && statement.argument !== null) {
+        return getReturnedObjectExpressions(statement.argument);
+      }
+      return [];
+    });
+  }
+  if (node.type === AST_NODE_TYPES9.ConditionalExpression) {
+    return [
+      ...getReturnedObjectExpressions(node.consequent),
+      ...getReturnedObjectExpressions(node.alternate)
+    ];
+  }
+  if (node.type === AST_NODE_TYPES9.LogicalExpression) {
+    return [
+      ...getReturnedObjectExpressions(node.left),
+      ...getReturnedObjectExpressions(node.right)
+    ];
+  }
+  if (node.type === AST_NODE_TYPES9.SequenceExpression) {
+    return node.expressions.flatMap(
+      (expression) => getReturnedObjectExpressions(expression)
+    );
+  }
+  return [];
+}
+function getQueryObjects(node) {
+  if (node.type === AST_NODE_TYPES9.ArrayExpression) {
+    return node.elements.flatMap((element) => {
+      if (element !== null && ASTUtils.isObjectExpression(element)) {
+        return [element];
+      }
+      return [];
+    });
+  }
+  if (node.type === AST_NODE_TYPES9.CallExpression && node.callee.type === AST_NODE_TYPES9.MemberExpression && ASTUtils.isIdentifierWithName(node.callee.property, "map")) {
+    const mapper = node.arguments[0];
+    if (mapper?.type === AST_NODE_TYPES9.ArrowFunctionExpression || mapper?.type === AST_NODE_TYPES9.FunctionExpression) {
+      return getReturnedObjectExpressions(mapper);
+    }
+  }
+  return [];
+}
+function isTanstackQueryClient(node, context, helpers) {
+  const source = resolveQueryClientSource(node, context);
+  if (source.type === AST_NODE_TYPES9.CallExpression && ASTUtils.isIdentifier(source.callee)) {
+    return getTanstackImportName(context, helpers, source.callee) === "useQueryClient";
+  }
+  if (source.type === AST_NODE_TYPES9.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 !== AST_NODE_TYPES9.ImportSpecifier || definition.imported.type !== AST_NODE_TYPES9.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 === AST_NODE_TYPES9.ChainExpression) {
+      node = node.expression;
+      continue;
+    }
+    node = unwrapTypeAssertions(node);
+    if (node.type !== AST_NODE_TYPES9.Identifier) {
+      return node;
+    }
+    const expression = ASTUtils.getReferencedExpressionByIdentifier({
+      context,
+      node
+    });
+    if (expression === null) {
+      return node;
+    }
+    node = expression;
+  }
+  return node;
+}
+function unwrapTypeAssertions(node) {
+  while (node.type === AST_NODE_TYPES9.TSAsExpression || node.type === AST_NODE_TYPES9.TSSatisfiesExpression || node.type === AST_NODE_TYPES9.TSTypeAssertion) {
+    node = node.expression;
+  }
+  return node;
+}
+
 // src/rules.ts
 var rules = {
   [name]: rule,
@@ -1326,10 +1577,11 @@ var rules = {
   [name4]: rule4,
   [name5]: rule5,
   [name6]: rule6,
-  [name7]: rule7
+  [name7]: rule7,
+  [name8]: rule8
 };
 
 export {
   rules
 };
-//# sourceMappingURL=chunk-XH4ABCYA.js.map
+//# sourceMappingURL=chunk-J3JFOQ5Q.js.map