@tanstack/eslint-plugin-query 5.94.5 → 5.95.1

package/build/legacy/_tsup-dts-rollup.d.cts

@@ -22,7 +22,6 @@ export declare const ASTUtils: {
     isPropertyWithIdentifierKey(node: TSESTree.Node, key: string): node is TSESTree.Property;
     findPropertyWithIdentifierKey(properties: Array<TSESTree.ObjectLiteralElement>, key: string): TSESTree.Property | undefined;
     getNestedIdentifiers(node: TSESTree.Node): Array<TSESTree.Identifier>;
-    isAncestorIsCallee(identifier: TSESTree.Node): boolean;
     traverseUpOnly(identifier: TSESTree.Node, allowedNodeTypes: Array<AST_NODE_TYPES>): TSESTree.Node;
     isDeclaredInNode(params: {
         functionNode: TSESTree.Node;
@@ -86,17 +85,72 @@ export declare const ExhaustiveDepsUtils: {
         node: TSESTree.Node;
         filename: string;
     }): boolean;
-    isInstanceOfKind(node: TSESTree.Node): boolean;
+    /**
+     * Given required refs and existing queryKey entries, compute missing dependency paths
+     * respecting allowlisted variables and types.
+     */
+    computeFilteredMissingPaths(params: {
+        requiredRefs: Array<{
+            path: string;
+            root: string;
+            allowlistedByType: boolean;
+        }>;
+        allowlistedVariables: Set<string>;
+        existingRootIdentifiers: Set<string>;
+        existingFullPaths: Set<string>;
+    }): Array<string>;
+    /**
+     * Extract existing queryKey deps as root identifiers and full member paths.
+     */
     collectQueryKeyDeps(params: {
         sourceCode: Readonly<TSESLint.SourceCode>;
         scopeManager: TSESLint.Scope.ScopeManager;
         queryKeyNode: TSESTree.Node;
-    }): Set<string>;
+    }): {
+        roots: Set<string>;
+        paths: Set<string>;
+    };
     isNode(value: unknown): value is TSESTree.Node;
+    /**
+     * Checks whether the resolved variable is allowlisted by its type annotation
+     */
+    variableIsAllowlistedByType(params: {
+        allowlistedTypes: Set<string>;
+        variable: TSESLint.Scope.Variable | null;
+    }): boolean;
+    isInstanceOfKind(node: TSESTree.Node): boolean;
+    /**
+     * Normalizes a chain by removing optional chaining operators
+     *
+     * Example: `a?.b.c!` -> `a.b.c`
+     */
+    normalizeChain(text: string): string;
+    /**
+     * Computes the reference path for an identifier
+     *
+     * Example: `a.b.c!` -> `{ path: 'a.b.c', root: 'a' }`
+     */
+    computeRefPath(params: {
+        identifier: TSESTree.Identifier;
+        sourceCode: Readonly<TSESLint.SourceCode>;
+    }): {
+        path: string;
+        root: string;
+        coversRootMembers: boolean;
+    } | null;
     collectExternalRefsInFunction(params: {
         functionNode: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;
         scopeManager: TSESLint.Scope.ScopeManager;
     }): Array<TSESLint.Scope.Reference>;
+    /**
+     * Recursively collects type identifiers from a type annotation
+     */
+    collectTypeIdentifiers(typeNode: TSESTree.TypeNode, out: Set<string>): void;
+    /**
+     * Gets the function expression nodes from a queryFn property, handling conditional expressions.
+     * When neither branch is skipToken, returns both branches so all deps are scanned.
+     */
+    getQueryFnNodes(queryFn: TSESTree.Property): Array<TSESTree.Node>;
 };
 
 export declare function expectArrayEqualIgnoreOrder<T>(a: Array<T>, b: Array<T>): void;

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

@@ -22,7 +22,6 @@ export declare const ASTUtils: {
     isPropertyWithIdentifierKey(node: TSESTree.Node, key: string): node is TSESTree.Property;
     findPropertyWithIdentifierKey(properties: Array<TSESTree.ObjectLiteralElement>, key: string): TSESTree.Property | undefined;
     getNestedIdentifiers(node: TSESTree.Node): Array<TSESTree.Identifier>;
-    isAncestorIsCallee(identifier: TSESTree.Node): boolean;
     traverseUpOnly(identifier: TSESTree.Node, allowedNodeTypes: Array<AST_NODE_TYPES>): TSESTree.Node;
     isDeclaredInNode(params: {
         functionNode: TSESTree.Node;
@@ -86,17 +85,72 @@ export declare const ExhaustiveDepsUtils: {
         node: TSESTree.Node;
         filename: string;
     }): boolean;
-    isInstanceOfKind(node: TSESTree.Node): boolean;
+    /**
+     * Given required refs and existing queryKey entries, compute missing dependency paths
+     * respecting allowlisted variables and types.
+     */
+    computeFilteredMissingPaths(params: {
+        requiredRefs: Array<{
+            path: string;
+            root: string;
+            allowlistedByType: boolean;
+        }>;
+        allowlistedVariables: Set<string>;
+        existingRootIdentifiers: Set<string>;
+        existingFullPaths: Set<string>;
+    }): Array<string>;
+    /**
+     * Extract existing queryKey deps as root identifiers and full member paths.
+     */
     collectQueryKeyDeps(params: {
         sourceCode: Readonly<TSESLint.SourceCode>;
         scopeManager: TSESLint.Scope.ScopeManager;
         queryKeyNode: TSESTree.Node;
-    }): Set<string>;
+    }): {
+        roots: Set<string>;
+        paths: Set<string>;
+    };
     isNode(value: unknown): value is TSESTree.Node;
+    /**
+     * Checks whether the resolved variable is allowlisted by its type annotation
+     */
+    variableIsAllowlistedByType(params: {
+        allowlistedTypes: Set<string>;
+        variable: TSESLint.Scope.Variable | null;
+    }): boolean;
+    isInstanceOfKind(node: TSESTree.Node): boolean;
+    /**
+     * Normalizes a chain by removing optional chaining operators
+     *
+     * Example: `a?.b.c!` -> `a.b.c`
+     */
+    normalizeChain(text: string): string;
+    /**
+     * Computes the reference path for an identifier
+     *
+     * Example: `a.b.c!` -> `{ path: 'a.b.c', root: 'a' }`
+     */
+    computeRefPath(params: {
+        identifier: TSESTree.Identifier;
+        sourceCode: Readonly<TSESLint.SourceCode>;
+    }): {
+        path: string;
+        root: string;
+        coversRootMembers: boolean;
+    } | null;
     collectExternalRefsInFunction(params: {
         functionNode: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;
         scopeManager: TSESLint.Scope.ScopeManager;
     }): Array<TSESLint.Scope.Reference>;
+    /**
+     * Recursively collects type identifiers from a type annotation
+     */
+    collectTypeIdentifiers(typeNode: TSESTree.TypeNode, out: Set<string>): void;
+    /**
+     * Gets the function expression nodes from a queryFn property, handling conditional expressions.
+     * When neither branch is skipToken, returns both branches so all deps are scanned.
+     */
+    getQueryFnNodes(queryFn: TSESTree.Property): Array<TSESTree.Node>;
 };
 
 export declare function expectArrayEqualIgnoreOrder<T>(a: Array<T>, b: Array<T>): void;

package/build/legacy/{chunk-HD2KSEKJ.js → chunk-T44AUBX4.js}

@@ -104,21 +104,6 @@ var ASTUtils = {
     }
     return identifiers;
   },
-  isAncestorIsCallee(identifier) {
-    let previousNode = identifier;
-    let currentNode = identifier.parent;
-    while (currentNode !== void 0) {
-      if (currentNode.type === AST_NODE_TYPES.CallExpression && currentNode.callee === previousNode) {
-        return true;
-      }
-      if (currentNode.type !== AST_NODE_TYPES.MemberExpression) {
-        return false;
-      }
-      previousNode = currentNode;
-      currentNode = currentNode.parent;
-    }
-    return false;
-  },
   traverseUpOnly(identifier, allowedNodeTypes) {
     const parent = identifier.parent;
     if (parent !== void 0 && allowedNodeTypes.includes(parent.type)) {
@@ -343,7 +328,7 @@ var ExhaustiveDepsUtils = {
     const { sourceCode, reference, scopeManager, node, filename } = params;
     const component = ASTUtils.getFunctionAncestor(sourceCode, node);
     const queryFnScope = scopeManager.acquire(node);
-    if (queryFnScope === null) {
+    if (queryFnScope === null || reference.isValueReference === false) {
       return false;
     }
     let currentScope = ((_a = reference.resolved) == null ? void 0 : _a.scope) ?? null;
@@ -375,15 +360,57 @@ var ExhaustiveDepsUtils = {
     }
     return reference.identifier.name !== "undefined" && reference.identifier.parent.type !== AST_NODE_TYPES2.NewExpression && !ExhaustiveDepsUtils.isInstanceOfKind(reference.identifier.parent);
   },
-  isInstanceOfKind(node) {
-    return node.type === AST_NODE_TYPES2.BinaryExpression && node.operator === "instanceof";
+  /**
+   * Given required refs and existing queryKey entries, compute missing dependency paths
+   * respecting allowlisted variables and types.
+   */
+  computeFilteredMissingPaths(params) {
+    const {
+      requiredRefs,
+      allowlistedVariables,
+      existingRootIdentifiers,
+      existingFullPaths
+    } = params;
+    const missingPaths = /* @__PURE__ */ new Set();
+    for (const { root, path, allowlistedByType } of requiredRefs) {
+      if (existingRootIdentifiers.has(root)) continue;
+      if (allowlistedVariables.has(root)) continue;
+      if (existingFullPaths.has(path)) continue;
+      if (allowlistedByType) continue;
+      missingPaths.add(path);
+    }
+    for (const path of missingPaths) {
+      const root = path.split(".")[0];
+      if (root !== path && root !== void 0 && missingPaths.has(root)) {
+        missingPaths.delete(path);
+      }
+    }
+    return Array.from(missingPaths);
   },
+  /**
+   * Extract existing queryKey deps as root identifiers and full member paths.
+   */
   collectQueryKeyDeps(params) {
     const { sourceCode, scopeManager, queryKeyNode } = params;
-    const deps = /* @__PURE__ */ new Set();
+    const roots = /* @__PURE__ */ new Set();
+    const paths = /* @__PURE__ */ new Set();
     const visitorKeys = sourceCode.visitorKeys;
-    function add(identifier) {
-      deps.add(ASTUtils.mapKeyNodeToBaseText(identifier, sourceCode));
+    function addRoot(name8) {
+      const cleaned = ExhaustiveDepsUtils.normalizeChain(name8);
+      roots.add(cleaned);
+      paths.add(cleaned);
+    }
+    function addFull(text) {
+      const cleaned = ExhaustiveDepsUtils.normalizeChain(text);
+      paths.add(cleaned);
+    }
+    function addRefPath(refPath) {
+      if (!refPath) return;
+      if (refPath.coversRootMembers) {
+        addRoot(refPath.root);
+        return;
+      }
+      addFull(refPath.path);
     }
     function visitChildren(node) {
       const keys = visitorKeys[node.type] ?? [];
@@ -405,9 +432,15 @@ var ExhaustiveDepsUtils = {
     function visit(node) {
       if (!node) return;
       switch (node.type) {
-        case AST_NODE_TYPES2.Identifier:
-          add(node);
+        case AST_NODE_TYPES2.Identifier: {
+          addRefPath(
+            ExhaustiveDepsUtils.computeRefPath({
+              identifier: node,
+              sourceCode
+            })
+          );
           return;
+        }
         case AST_NODE_TYPES2.ArrowFunctionExpression:
         case AST_NODE_TYPES2.FunctionExpression:
           for (const reference of ExhaustiveDepsUtils.collectExternalRefsInFunction(
@@ -416,9 +449,15 @@ var ExhaustiveDepsUtils = {
               scopeManager
             }
           )) {
-            if (reference.identifier.type === AST_NODE_TYPES2.Identifier) {
-              add(reference.identifier);
+            if (reference.identifier.type !== AST_NODE_TYPES2.Identifier) {
+              continue;
             }
+            addRefPath(
+              ExhaustiveDepsUtils.computeRefPath({
+                identifier: reference.identifier,
+                sourceCode
+              })
+            );
           }
           return;
         case AST_NODE_TYPES2.Property:
@@ -426,26 +465,96 @@ var ExhaustiveDepsUtils = {
           return;
         case AST_NODE_TYPES2.MemberExpression:
           if (node.parent.type === AST_NODE_TYPES2.CallExpression && node.parent.callee === node && node.object.type === AST_NODE_TYPES2.Identifier) {
-            deps.add(node.object.name);
+            addRoot(node.object.name);
           } else {
             visit(node.object);
           }
           return;
         case AST_NODE_TYPES2.CallExpression:
           node.arguments.forEach((argument) => visit(argument));
-          if (node.callee.type === AST_NODE_TYPES2.MemberExpression || node.callee.type === AST_NODE_TYPES2.ChainExpression || node.callee.type === AST_NODE_TYPES2.TSNonNullExpression) {
-            visit(node.callee);
+          switch (node.callee.type) {
+            case AST_NODE_TYPES2.Identifier:
+            case AST_NODE_TYPES2.MemberExpression:
+            case AST_NODE_TYPES2.ChainExpression:
+            case AST_NODE_TYPES2.TSNonNullExpression:
+              visit(node.callee);
+              break;
           }
           return;
       }
       visitChildren(node);
     }
     visit(queryKeyNode);
-    return deps;
+    return { roots, paths };
   },
   isNode(value) {
     return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
   },
+  /**
+   * Checks whether the resolved variable is allowlisted by its type annotation
+   */
+  variableIsAllowlistedByType(params) {
+    const { allowlistedTypes, variable } = params;
+    if (allowlistedTypes.size === 0) return false;
+    if (!variable) return false;
+    for (const id of variable.identifiers) {
+      if (id.typeAnnotation) {
+        const typeIdentifiers = /* @__PURE__ */ new Set();
+        ExhaustiveDepsUtils.collectTypeIdentifiers(
+          id.typeAnnotation.typeAnnotation,
+          typeIdentifiers
+        );
+        for (const typeIdentifier of typeIdentifiers) {
+          if (allowlistedTypes.has(typeIdentifier)) return true;
+        }
+      }
+    }
+    return false;
+  },
+  isInstanceOfKind(node) {
+    return node.type === AST_NODE_TYPES2.BinaryExpression && node.operator === "instanceof";
+  },
+  /**
+   * Normalizes a chain by removing optional chaining operators
+   *
+   * Example: `a?.b.c!` -> `a.b.c`
+   */
+  normalizeChain(text) {
+    return text.replace(/(?:\?(\.)|!)/g, "$1");
+  },
+  /**
+   * Computes the reference path for an identifier
+   *
+   * Example: `a.b.c!` -> `{ path: 'a.b.c', root: 'a' }`
+   */
+  computeRefPath(params) {
+    const { identifier, sourceCode } = params;
+    const fullChainNode = ASTUtils.traverseUpOnly(identifier, [
+      AST_NODE_TYPES2.MemberExpression,
+      AST_NODE_TYPES2.TSNonNullExpression,
+      AST_NODE_TYPES2.Identifier
+    ]);
+    const fullText = ExhaustiveDepsUtils.normalizeChain(
+      sourceCode.getText(fullChainNode)
+    );
+    const parent = fullChainNode.parent;
+    let dependencyPath = fullText;
+    let coversRootMembers = fullText === identifier.name;
+    if (parent && parent.type === AST_NODE_TYPES2.CallExpression && parent.callee === fullChainNode) {
+      const segments = fullText.split(".");
+      if (segments.length > 1) {
+        dependencyPath = segments.slice(0, -1).join(".");
+      }
+      coversRootMembers = false;
+    }
+    dependencyPath = dependencyPath.split(".")[0] === "" ? identifier.name : dependencyPath;
+    const root = dependencyPath.split(".")[0];
+    return {
+      path: dependencyPath,
+      root: root ?? identifier.name,
+      coversRootMembers: coversRootMembers && dependencyPath === root
+    };
+  },
   collectExternalRefsInFunction(params) {
     const { functionNode, scopeManager } = params;
     const functionScope = scopeManager.acquire(functionNode);
@@ -477,6 +586,52 @@ var ExhaustiveDepsUtils = {
     }
     collect(functionScope);
     return externalRefs;
+  },
+  /**
+   * Recursively collects type identifiers from a type annotation
+   */
+  collectTypeIdentifiers(typeNode, out) {
+    switch (typeNode.type) {
+      case AST_NODE_TYPES2.TSTypeReference: {
+        if (typeNode.typeName.type === AST_NODE_TYPES2.Identifier) {
+          out.add(typeNode.typeName.name);
+        }
+        break;
+      }
+      case AST_NODE_TYPES2.TSUnionType:
+      case AST_NODE_TYPES2.TSIntersectionType: {
+        typeNode.types.forEach(
+          (t) => ExhaustiveDepsUtils.collectTypeIdentifiers(t, out)
+        );
+        break;
+      }
+      case AST_NODE_TYPES2.TSArrayType: {
+        ExhaustiveDepsUtils.collectTypeIdentifiers(typeNode.elementType, out);
+        break;
+      }
+      case AST_NODE_TYPES2.TSTupleType: {
+        typeNode.elementTypes.forEach(
+          (et) => ExhaustiveDepsUtils.collectTypeIdentifiers(et, out)
+        );
+        break;
+      }
+    }
+  },
+  /**
+   * Gets the function expression nodes from a queryFn property, handling conditional expressions.
+   * When neither branch is skipToken, returns both branches so all deps are scanned.
+   */
+  getQueryFnNodes(queryFn) {
+    if (queryFn.value.type !== AST_NODE_TYPES2.ConditionalExpression) {
+      return [queryFn.value];
+    }
+    if (queryFn.value.consequent.type === AST_NODE_TYPES2.Identifier && queryFn.value.consequent.name === "skipToken") {
+      return [queryFn.value.alternate];
+    }
+    if (queryFn.value.alternate.type === AST_NODE_TYPES2.Identifier && queryFn.value.alternate.name === "skipToken") {
+      return [queryFn.value.consequent];
+    }
+    return [queryFn.value.consequent, queryFn.value.alternate];
   }
 };
 
@@ -499,22 +654,35 @@ var rule = createRule({
     },
     hasSuggestions: true,
     fixable: "code",
-    schema: []
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowlist: {
+            type: "object",
+            properties: {
+              variables: { type: "array", items: { type: "string" } },
+              types: { type: "array", items: { type: "string" } }
+            },
+            additionalProperties: false
+          }
+        },
+        additionalProperties: false
+      }
+    ]
   },
   defaultOptions: [],
   create: detectTanstackQueryImports((context) => {
     return {
-      Property: (node) => {
-        if (!ASTUtils.isObjectExpression(node.parent) || !ASTUtils.isIdentifierWithName(node.key, QUERY_KEY)) {
-          return;
-        }
+      ObjectExpression: (node) => {
+        var _a, _b;
         const scopeManager = context.sourceCode.scopeManager;
         const queryKey = ASTUtils.findPropertyWithIdentifierKey(
-          node.parent.properties,
+          node.properties,
           QUERY_KEY
         );
         const queryFn = ASTUtils.findPropertyWithIdentifierKey(
-          node.parent.properties,
+          node.properties,
           QUERY_FN
         );
         if (scopeManager === null || queryKey === void 0 || queryFn === void 0 || !ASTUtils.isNodeOfOneOf(queryFn.value, [
@@ -528,73 +696,104 @@ var rule = createRule({
           queryKey.value,
           context
         );
-        const externalRefs = ASTUtils.getExternalRefs({
-          scopeManager,
-          sourceCode: context.sourceCode,
-          node: getQueryFnRelevantNode(queryFn)
-        });
-        const relevantRefs = externalRefs.filter(
-          (reference) => ExhaustiveDepsUtils.isRelevantReference({
-            sourceCode: context.sourceCode,
-            reference,
+        const queryFnNodes = ExhaustiveDepsUtils.getQueryFnNodes(queryFn);
+        const externalRefs = queryFnNodes.flatMap(
+          (fnNode) => ASTUtils.getExternalRefs({
             scopeManager,
-            node: getQueryFnRelevantNode(queryFn),
-            filename: context.filename
+            sourceCode: context.sourceCode,
+            node: fnNode
           })
         );
+        const relevantRefs = externalRefs.filter(
+          (reference) => queryFnNodes.some(
+            (fnNode) => ExhaustiveDepsUtils.isRelevantReference({
+              sourceCode: context.sourceCode,
+              reference,
+              scopeManager,
+              node: fnNode,
+              filename: context.filename
+            })
+          )
+        );
+        const ruleOptions = context.options.at(0);
+        const allowlistedVariables = new Set(
+          ((_a = ruleOptions == null ? void 0 : ruleOptions.allowlist) == null ? void 0 : _a.variables) ?? []
+        );
+        const allowlistedTypes = new Set(((_b = ruleOptions == null ? void 0 : ruleOptions.allowlist) == null ? void 0 : _b.types) ?? []);
+        const requiredRefs = relevantRefs.flatMap((ref) => {
+          if (ref.identifier.type !== AST_NODE_TYPES3.Identifier) return [];
+          const refPath = ExhaustiveDepsUtils.computeRefPath({
+            identifier: ref.identifier,
+            sourceCode: context.sourceCode
+          });
+          if (refPath === null) return [];
+          return [
+            {
+              ...refPath,
+              allowlistedByType: ExhaustiveDepsUtils.variableIsAllowlistedByType({
+                allowlistedTypes,
+                variable: ref.resolved ?? null
+              })
+            }
+          ];
+        });
+        if (requiredRefs.length === 0) return;
         const queryKeyDeps = ExhaustiveDepsUtils.collectQueryKeyDeps({
           sourceCode: context.sourceCode,
           scopeManager,
           queryKeyNode
         });
-        const missingRefs = relevantRefs.map((ref) => ({
-          ref,
-          text: ASTUtils.isAncestorIsCallee(ref.identifier) ? ref.identifier.name : ASTUtils.mapKeyNodeToBaseText(
-            ref.identifier,
-            context.sourceCode
-          )
-        })).filter(({ ref, text }) => {
-          return !ref.isTypeReference && !queryKeyDeps.has(text) && !queryKeyDeps.has(text.split(/[?.]/)[0] ?? "");
-        }).map(({ ref, text }) => ({
-          identifier: ref.identifier,
-          text
-        }));
-        const uniqueMissingRefs = uniqueBy(missingRefs, (x) => x.text);
-        if (uniqueMissingRefs.length > 0) {
-          const missingAsText = uniqueMissingRefs.map((ref) => ref.text).join(", ");
-          const queryKeyValue = context.sourceCode.getText(queryKeyNode);
-          const existingWithMissing = queryKeyValue === "[]" ? `[${missingAsText}]` : queryKeyValue.replace(/\]$/, `, ${missingAsText}]`);
-          const suggestions = [];
-          if (queryKeyNode.type === AST_NODE_TYPES3.ArrayExpression) {
-            suggestions.push({
-              messageId: "fixTo",
-              data: { result: existingWithMissing },
-              fix(fixer) {
-                return fixer.replaceText(queryKeyNode, existingWithMissing);
-              }
-            });
-          }
-          context.report({
-            node,
-            messageId: "missingDeps",
-            data: {
-              deps: uniqueMissingRefs.map((ref) => ref.text).join(", ")
-            },
-            suggest: suggestions
-          });
-        }
+        const missingPaths = ExhaustiveDepsUtils.computeFilteredMissingPaths({
+          requiredRefs,
+          allowlistedVariables,
+          existingRootIdentifiers: queryKeyDeps.roots,
+          existingFullPaths: queryKeyDeps.paths
+        });
+        if (missingPaths.length === 0) return;
+        const missingAsText = missingPaths.join(", ");
+        const suggestions = buildSuggestions({
+          queryKeyNode,
+          missingPaths,
+          missingAsText,
+          sourceCode: context.sourceCode
+        });
+        context.report({
+          node,
+          messageId: "missingDeps",
+          data: { deps: missingAsText },
+          suggest: suggestions
+        });
       }
     };
   })
 });
-function getQueryFnRelevantNode(queryFn) {
-  if (queryFn.value.type !== AST_NODE_TYPES3.ConditionalExpression) {
-    return queryFn.value;
+function buildSuggestions(params) {
+  const { queryKeyNode, missingPaths, missingAsText, sourceCode } = params;
+  if (queryKeyNode.type !== AST_NODE_TYPES3.ArrayExpression) {
+    return [];
   }
-  if (queryFn.value.consequent.type === AST_NODE_TYPES3.Identifier && queryFn.value.consequent.name === "skipToken") {
-    return queryFn.value.alternate;
+  const closingBracket = sourceCode.getLastToken(queryKeyNode);
+  if (!closingBracket) return [];
+  const existingElements = queryKeyNode.elements.filter((el) => el !== null).map((el) => sourceCode.getText(el));
+  const resultText = `[${[...existingElements, ...missingPaths].join(", ")}]`;
+  if (queryKeyNode.elements.length === 0) {
+    return [
+      {
+        messageId: "fixTo",
+        data: { result: resultText },
+        fix: (fixer) => fixer.replaceText(queryKeyNode, resultText)
+      }
+    ];
   }
-  return queryFn.value.consequent;
+  const tokenBefore = sourceCode.getTokenBefore(closingBracket);
+  const separator = (tokenBefore == null ? void 0 : tokenBefore.value) === "," ? " " : ", ";
+  return [
+    {
+      messageId: "fixTo",
+      data: { result: resultText },
+      fix: (fixer) => fixer.insertTextBefore(closingBracket, `${separator}${missingAsText}`)
+    }
+  ];
 }
 function dereferenceVariablesAndTypeAssertions(queryKeyNode, context) {
   const visitedNodes = /* @__PURE__ */ new Set();
@@ -1142,4 +1341,4 @@ var rules = {
 export {
   rules
 };
-//# sourceMappingURL=chunk-HD2KSEKJ.js.map
+//# sourceMappingURL=chunk-T44AUBX4.js.map