@refinedev/core 4.34.0 → 4.35.0

package/dist/interfaces/mutationMode.d.ts

@@ -5,6 +5,9 @@ export declare type QueryResponse<T = BaseRecord> = GetListResponse<T> | GetOneR
 export declare type PreviousQuery<TData> = [QueryKey, TData | unknown];
 export declare type PrevContext<TData> = {
     previousQueries: PreviousQuery<TData>[];
+    /**
+     * @deprecated `QueryKeys` is deprecated in favor of `keys`. Please use `keys` instead to construct query keys for queries and mutations.
+     */
     queryKey: IQueryKeys;
 };
 export declare type Context = {

package/dist/interfaces/mutationMode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutationMode.d.ts","sourceRoot":"","sources":["../../src/interfaces/mutationMode.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,UAAU,EACV,eAAe,EACf,cAAc,EACd,UAAU,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,oBAAY,YAAY,GAAG,aAAa,GAAG,YAAY,GAAG,UAAU,CAAC;AAErE,oBAAY,aAAa,CAAC,CAAC,GAAG,UAAU,IAClC,eAAe,CAAC,CAAC,CAAC,GAClB,cAAc,CAAC,CAAC,CAAC,CAAC;AAExB,oBAAY,aAAa,CAAC,KAAK,IAAI,CAAC,QAAQ,EAAE,KAAK,GAAG,OAAO,CAAC,CAAC;AAE/D,oBAAY,WAAW,CAAC,KAAK,IAAI;IAC7B,eAAe,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;IACxC,QAAQ,EAAE,UAAU,CAAC;CACxB,CAAC;AAEF,oBAAY,OAAO,GAAG;IAClB,eAAe,EAAE,YAAY,EAAE,CAAC;CACnC,CAAC;AAEF,oBAAY,YAAY,CAAC,CAAC,GAAG,UAAU,IAAI;IACvC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACxB,QAAQ,EAAE,QAAQ,CAAC;CACtB,CAAC"}
+{"version":3,"file":"mutationMode.d.ts","sourceRoot":"","sources":["../../src/interfaces/mutationMode.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,UAAU,EACV,eAAe,EACf,cAAc,EACd,UAAU,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,oBAAY,YAAY,GAAG,aAAa,GAAG,YAAY,GAAG,UAAU,CAAC;AAErE,oBAAY,aAAa,CAAC,CAAC,GAAG,UAAU,IAClC,eAAe,CAAC,CAAC,CAAC,GAClB,cAAc,CAAC,CAAC,CAAC,CAAC;AAExB,oBAAY,aAAa,CAAC,KAAK,IAAI,CAAC,QAAQ,EAAE,KAAK,GAAG,OAAO,CAAC,CAAC;AAE/D,oBAAY,WAAW,CAAC,KAAK,IAAI;IAC7B,eAAe,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;IACxC;;OAEG;IACH,QAAQ,EAAE,UAAU,CAAC;CACxB,CAAC;AAEF,oBAAY,OAAO,GAAG;IAClB,eAAe,EAAE,YAAY,EAAE,CAAC;CACnC,CAAC;AAEF,oBAAY,YAAY,CAAC,CAAC,GAAG,UAAU,IAAI;IACvC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACxB,QAAQ,EAAE,QAAQ,CAAC;CACtB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@refinedev/core",
-  "version": "4.34.0",
+  "version": "4.35.0",
   "description": "refine is a React-based framework for building internal tools, rapidly. It ships with Ant Design System, an enterprise-level UI toolkit.",
   "private": false,
   "sideEffects": false,

package/src/contexts/refine/IRefineContext.ts

@@ -44,6 +44,7 @@ export interface IRefineOptions {
      * The project id of your refine project. Will be set automatically. Don't modify.
      */
     projectId?: string;
+    useNewQueryKeys?: boolean;
 }
 
 export interface IRefineContextOptions {
@@ -62,6 +63,7 @@ export interface IRefineContextOptions {
     textTransformers: Required<TextTransformers>;
     disableServerSideValidation: boolean;
     projectId?: string;
+    useNewQueryKeys?: boolean;
 }
 
 export interface IRefineContext {

package/src/definitions/helpers/handleRefineOptions/index.ts

@@ -87,6 +87,7 @@ export const handleRefineOptions = ({
             options?.disableServerSideValidation ??
             defaultRefineOptions.disableServerSideValidation,
         projectId: options?.projectId,
+        useNewQueryKeys: options?.useNewQueryKeys,
     };
 
     const disableTelemetryWithDefault =

package/src/definitions/helpers/index.ts

@@ -2,7 +2,7 @@ export { userFriendlySecond } from "./userFriendlySeconds";
 export { importCSVMapper } from "./importCSVMapper";
 export { userFriendlyResourceName } from "./userFriendlyResourceName";
 export { handleUseParams } from "./handleUseParams";
-export { queryKeys } from "./queryKeys";
+export { queryKeys, queryKeysReplacement } from "./queryKeys";
 export { hasPermission } from "./hasPermission";
 export { routeGenerator } from "./routeGenerator";
 export { createTreeView } from "./treeView/createTreeView";
@@ -26,3 +26,5 @@ export { handlePaginationParams } from "./handlePaginationParams";
 export { useMediaQuery } from "./useMediaQuery";
 export { generateDefaultDocumentTitle } from "./generateDocumentTitle";
 export { useUserFriendlyName } from "./useUserFriendlyName";
+export { keys, stripUndefined } from "./keys";
+export { KeyBuilder } from "./keys";

package/src/definitions/helpers/keys/index.ts

@@ -0,0 +1,336 @@
+import { BaseKey } from "src/interfaces";
+
+type ParametrizedDataActions = "list" | "infinite";
+type IdRequiredDataActions = "one";
+type IdsRequiredDataActions = "many";
+type DataMutationActions =
+    | "custom"
+    | "customMutation"
+    | "create"
+    | "createMany"
+    | "update"
+    | "updateMany"
+    | "delete"
+    | "deleteMany";
+
+type AuthActionType =
+    | "login"
+    | "logout"
+    | "identity"
+    | "register"
+    | "forgotPassword"
+    | "check"
+    | "onError"
+    | "permissions"
+    | "updatePassword";
+
+type AuditActionType = "list" | "log" | "rename";
+
+type IdType = BaseKey;
+type IdsType = IdType[];
+
+type ParamsType = any;
+
+type KeySegment = string | IdType | IdsType | ParamsType;
+
+export function arrayFindIndex<T>(array: T[], slice: T[]): number {
+    return array.findIndex(
+        (item, index) =>
+            index <= array.length - slice.length &&
+            slice.every(
+                (sliceItem, sliceIndex) =>
+                    array[index + sliceIndex] === sliceItem,
+            ),
+    );
+}
+
+export function arrayReplace<T>(
+    array: T[],
+    partToBeReplaced: T[],
+    newPart: T[],
+): T[] {
+    const newArray: T[] = [...array];
+    const startIndex = arrayFindIndex(array, partToBeReplaced);
+
+    if (startIndex !== -1) {
+        newArray.splice(startIndex, partToBeReplaced.length, ...newPart);
+    }
+
+    return newArray;
+}
+
+export function stripUndefined(segments: KeySegment[]) {
+    return segments.filter((segment) => segment !== undefined);
+}
+
+function convertToLegacy(segments: KeySegment[]) {
+    // for `list`, `many` and `one`
+    if (segments[0] === "data") {
+        // [data, dpName, resource, action, ...];
+        const newSegments = segments.slice(1);
+
+        if (newSegments[2] === "many") {
+            newSegments[2] = "getMany";
+        } else if (newSegments[2] === "infinite") {
+            newSegments[2] = "list";
+        } else if (newSegments[2] === "one") {
+            newSegments[2] = "detail";
+        } else if (newSegments[1] === "custom") {
+            const newParams = {
+                ...newSegments[2],
+            };
+            delete newParams.method;
+            delete newParams.url;
+
+            return [
+                newSegments[0],
+                newSegments[1],
+                newSegments[2].method,
+                newSegments[2].url,
+                newParams,
+            ];
+        }
+
+        return newSegments;
+    }
+    // for `audit` -> `logList`
+    if (segments[0] === "audit") {
+        // [audit, resource, action, params] (for log and list)
+        // or
+        // [audit, action, params] (for rename)
+        if (segments[2] === "list") {
+            return ["logList", segments[1], segments[3]];
+        }
+    }
+    // for `access` -> `useCan`
+    if (segments[0] === "access") {
+        // [access, resource, action, params]
+        if (segments.length === 4) {
+            return [
+                "useCan",
+                {
+                    resource: segments[1],
+                    action: segments[2],
+                    ...segments[3], // params: { params, enabled }
+                },
+            ];
+        }
+    }
+    // for `auth`
+    if (segments[0] === "auth") {
+        if (arrayFindIndex(segments, ["auth", "login"]) !== -1) {
+            return ["useLogin"];
+        }
+        if (arrayFindIndex(segments, ["auth", "logout"]) !== -1) {
+            return ["useLogout"];
+        }
+        if (arrayFindIndex(segments, ["auth", "identity"]) !== -1) {
+            return ["getUserIdentity"];
+        }
+        if (arrayFindIndex(segments, ["auth", "register"]) !== -1) {
+            return ["useRegister"];
+        }
+        if (arrayFindIndex(segments, ["auth", "forgotPassword"]) !== -1) {
+            return ["useForgotPassword"];
+        }
+        if (arrayFindIndex(segments, ["auth", "check"]) !== -1) {
+            return ["useAuthenticated", segments[2]]; // [auth, check, params]
+        }
+        if (arrayFindIndex(segments, ["auth", "onError"]) !== -1) {
+            return ["useCheckError"];
+        }
+        if (arrayFindIndex(segments, ["auth", "permissions"]) !== -1) {
+            return ["usePermissions"];
+        }
+        if (arrayFindIndex(segments, ["auth", "updatePassword"]) !== -1) {
+            return ["useUpdatePassword"];
+        }
+    }
+    return segments;
+}
+
+class BaseKeyBuilder {
+    segments: KeySegment[] = [];
+
+    constructor(segments: KeySegment[] = []) {
+        this.segments = segments;
+    }
+
+    key() {
+        return this.segments;
+    }
+
+    legacy() {
+        return convertToLegacy(this.segments);
+    }
+
+    get(legacy?: boolean) {
+        return legacy ? this.legacy() : this.segments;
+    }
+}
+
+class ParamsKeyBuilder extends BaseKeyBuilder {
+    constructor(segments: KeySegment[]) {
+        super(segments);
+    }
+
+    params(paramsValue?: ParamsType) {
+        return new BaseKeyBuilder([...this.segments, paramsValue]);
+    }
+}
+
+class DataIdRequiringKeyBuilder extends BaseKeyBuilder {
+    constructor(segments: KeySegment[]) {
+        super(segments);
+    }
+
+    id(idValue?: IdType) {
+        return new ParamsKeyBuilder([
+            ...this.segments,
+            idValue ? String(idValue) : undefined,
+        ]);
+    }
+}
+
+class DataIdsRequiringKeyBuilder extends BaseKeyBuilder {
+    constructor(segments: KeySegment[]) {
+        super(segments);
+    }
+
+    ids(...idsValue: IdsType) {
+        return new ParamsKeyBuilder([
+            ...this.segments,
+            ...(idsValue.length ? [idsValue.map((el) => String(el))] : []),
+        ]);
+    }
+}
+
+class DataResourceKeyBuilder extends BaseKeyBuilder {
+    constructor(segments: KeySegment[]) {
+        super(segments);
+    }
+
+    action(actionType: ParametrizedDataActions): ParamsKeyBuilder;
+    action(actionType: IdRequiredDataActions): DataIdRequiringKeyBuilder;
+    action(actionType: IdsRequiredDataActions): DataIdsRequiringKeyBuilder;
+    action(
+        actionType:
+            | ParametrizedDataActions
+            | IdRequiredDataActions
+            | IdsRequiredDataActions,
+    ):
+        | ParamsKeyBuilder
+        | DataIdRequiringKeyBuilder
+        | DataIdsRequiringKeyBuilder {
+        if (actionType === "one") {
+            return new DataIdRequiringKeyBuilder([
+                ...this.segments,
+                actionType,
+            ]);
+        } else if (actionType === "many") {
+            return new DataIdsRequiringKeyBuilder([
+                ...this.segments,
+                actionType,
+            ]);
+        } else if (["list", "infinite"].includes(actionType)) {
+            return new ParamsKeyBuilder([...this.segments, actionType]);
+        } else {
+            throw new Error("Invalid action type");
+        }
+    }
+}
+
+class DataKeyBuilder extends BaseKeyBuilder {
+    constructor(segments: KeySegment[]) {
+        super(segments);
+    }
+
+    resource(resourceName?: string) {
+        return new DataResourceKeyBuilder([...this.segments, resourceName]);
+    }
+
+    mutation(mutationName: DataMutationActions) {
+        return new ParamsKeyBuilder([
+            ...(mutationName === "custom" ? this.segments : [this.segments[0]]),
+            mutationName,
+        ]);
+    }
+}
+
+class AuthKeyBuilder extends BaseKeyBuilder {
+    constructor(segments: KeySegment[]) {
+        super(segments);
+    }
+
+    action(actionType: AuthActionType) {
+        return new ParamsKeyBuilder([...this.segments, actionType]);
+    }
+}
+
+class AccessResourceKeyBuilder extends BaseKeyBuilder {
+    constructor(segments: KeySegment[]) {
+        super(segments);
+    }
+
+    action(resourceName: string) {
+        return new ParamsKeyBuilder([...this.segments, resourceName]);
+    }
+}
+
+class AccessKeyBuilder extends BaseKeyBuilder {
+    constructor(segments: KeySegment[]) {
+        super(segments);
+    }
+
+    resource(resourceName?: string) {
+        return new AccessResourceKeyBuilder([...this.segments, resourceName]);
+    }
+}
+
+class AuditActionKeyBuilder extends BaseKeyBuilder {
+    constructor(segments: KeySegment[]) {
+        super(segments);
+    }
+
+    action(actionType: Extract<AuditActionType, "list">) {
+        return new ParamsKeyBuilder([...this.segments, actionType]);
+    }
+}
+
+class AuditKeyBuilder extends BaseKeyBuilder {
+    constructor(segments: KeySegment[]) {
+        super(segments);
+    }
+
+    resource(resourceName?: string) {
+        return new AuditActionKeyBuilder([...this.segments, resourceName]);
+    }
+
+    action(actionType: Extract<AuditActionType, "rename" | "log">) {
+        return new ParamsKeyBuilder([...this.segments, actionType]);
+    }
+}
+
+export class KeyBuilder extends BaseKeyBuilder {
+    constructor(segments: KeySegment[]) {
+        super(segments);
+    }
+
+    data(name?: string) {
+        return new DataKeyBuilder(["data", name || "default"]);
+    }
+
+    auth() {
+        return new AuthKeyBuilder(["auth"]);
+    }
+
+    access() {
+        return new AccessKeyBuilder(["access"]);
+    }
+
+    audit() {
+        return new AuditKeyBuilder(["audit"]);
+    }
+}
+
+export const keys = () => new KeyBuilder([]);

package/src/definitions/helpers/queryKeys/index.ts

@@ -3,7 +3,11 @@ import { QueryKey } from "@tanstack/react-query";
 
 import { MetaQuery } from "src/interfaces";
 import { pickNotDeprecated } from "../pickNotDeprecated";
+import { keys as newKeys } from "../keys";
 
+/**
+ * @deprecated `queryKeys` is deprecated. Please use `keys` instead.
+ */
 export const queryKeys = (
     resource?: string,
     dataProviderName?: string,
@@ -45,3 +49,67 @@ export const queryKeys = (
     };
     return keys;
 };
+
+export const queryKeysReplacement = (preferLegacyKeys?: boolean) => {
+    return (
+        resource?: string,
+        dataProviderName?: string,
+        meta?: MetaQuery,
+        /**
+         * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+         */
+        metaData?: MetaQuery | undefined,
+    ): IQueryKeys => {
+        const providerName = dataProviderName || "default";
+
+        const keys: IQueryKeys = {
+            all: newKeys().data(providerName).get(preferLegacyKeys),
+            resourceAll: newKeys()
+                .data(dataProviderName)
+                .resource(resource ?? "")
+                .get(preferLegacyKeys),
+            list: (config) =>
+                newKeys()
+                    .data(dataProviderName)
+                    .resource(resource ?? "")
+                    .action("list")
+                    .params({
+                        ...config,
+                        ...(pickNotDeprecated(meta, metaData) || {}),
+                    })
+                    .get(preferLegacyKeys),
+            many: (ids) =>
+                newKeys()
+                    .data(dataProviderName)
+                    .resource(resource ?? "")
+                    .action("many")
+                    .ids(...(ids ?? []))
+                    .params({
+                        ...(pickNotDeprecated(meta, metaData) || {}),
+                    })
+                    .get(preferLegacyKeys),
+            detail: (id) =>
+                newKeys()
+                    .data(dataProviderName)
+                    .resource(resource ?? "")
+                    .action("one")
+                    .id(id ?? "")
+                    .params({
+                        ...(pickNotDeprecated(meta, metaData) || {}),
+                    })
+                    .get(preferLegacyKeys),
+            logList: (meta) =>
+                [
+                    ...newKeys()
+                        .audit()
+                        .resource(resource)
+                        .action("list")
+                        .params(meta)
+                        .get(preferLegacyKeys),
+                    metaData as QueryKey,
+                ].filter((item) => item !== undefined),
+        };
+
+        return keys;
+    };
+};

package/src/hooks/accessControl/useCan/index.ts

@@ -8,6 +8,7 @@ import { useContext } from "react";
 import { AccessControlContext } from "@contexts/accessControl";
 import { sanitizeResource } from "@definitions/helpers/sanitize-resource";
 import { CanParams, CanReturnType } from "../../../interfaces";
+import { useKeys } from "@hooks/useKeys";
 
 export type UseCanProps = CanParams & {
     /**
@@ -31,6 +32,7 @@ export const useCan = ({
     queryOptions,
 }: UseCanProps): UseQueryResult<CanReturnType> => {
     const { can } = useContext(AccessControlContext);
+    const { keys, preferLegacyKeys } = useKeys();
 
     /**
      * Since `react-query` stringifies the query keys, it will throw an error for a circular dependency if we include `React.ReactNode` elements inside the keys.
@@ -43,15 +45,15 @@ export const useCan = ({
 
     /* eslint-enable @typescript-eslint/no-unused-vars */
     const queryResponse = useQuery<CanReturnType>(
-        [
-            "useCan",
-            {
-                action,
-                resource,
+        keys()
+            .access()
+            .resource(resource)
+            .action(action)
+            .params({
                 params: { ...paramsRest, resource: sanitizedResource },
                 enabled: queryOptions?.enabled,
-            },
-        ],
+            })
+            .get(preferLegacyKeys),
         // Enabled check for `can` is enough to be sure that it's defined in the query function but TS is not smart enough to know that.
         () =>
             can?.({

package/src/hooks/auditLog/useLog/index.ts

@@ -10,13 +10,10 @@ import { AuditLogContext } from "@contexts/auditLog";
 import { ResourceContext } from "@contexts/resource";
 import { useGetIdentity } from "@hooks/auth";
 import { BaseKey, LogParams } from "../../../interfaces";
-import {
-    hasPermission,
-    pickNotDeprecated,
-    queryKeys,
-} from "@definitions/helpers";
+import { hasPermission, pickNotDeprecated } from "@definitions/helpers";
 import { pickResource } from "@definitions/helpers/pick-resource";
 import { useActiveAuthProvider } from "@definitions/helpers";
+import { useKeys } from "@hooks/useKeys";
 
 type LogRenameData =
     | {
@@ -72,6 +69,7 @@ export const useLog = <
 > => {
     const queryClient = useQueryClient();
     const auditLogContext = useContext(AuditLogContext);
+    const { keys, preferLegacyKeys } = useKeys();
 
     const authProvider = useActiveAuthProvider();
 
@@ -112,7 +110,10 @@ export const useLog = <
                 author: identityData ?? authorData?.data,
             });
         },
-        logMutationOptions,
+        {
+            mutationKey: keys().audit().action("log").get(),
+            ...logMutationOptions,
+        },
     );
 
     const rename = useMutation<
@@ -127,10 +128,16 @@ export const useLog = <
         {
             onSuccess: (data) => {
                 if (data?.resource) {
-                    const queryKey = queryKeys(data?.resource);
-                    queryClient.invalidateQueries(queryKey.logList());
+                    queryClient.invalidateQueries(
+                        keys()
+                            .audit()
+                            .resource(data?.resource ?? "")
+                            .action("list")
+                            .get(preferLegacyKeys),
+                    );
                 }
             },
+            mutationKey: keys().audit().action("rename").get(),
             ...renameMutationOptions,
         },
     );

package/src/hooks/auditLog/useLogList/index.ts

@@ -6,8 +6,8 @@ import {
 } from "@tanstack/react-query";
 
 import { AuditLogContext } from "@contexts/auditLog";
-import { queryKeys } from "@definitions/helpers";
 import { HttpError, MetaQuery } from "../../../interfaces";
+import { useKeys } from "@hooks/useKeys";
 
 export type UseLogProps<TQueryFnData, TError, TData> = {
     resource: string;
@@ -41,11 +41,15 @@ export const useLogList = <
     queryOptions,
 }: UseLogProps<TQueryFnData, TError, TData>): UseQueryResult<TData> => {
     const { get } = useContext(AuditLogContext);
-
-    const queryKey = queryKeys(resource, undefined, metaData);
+    const { keys, preferLegacyKeys } = useKeys();
 
     const queryResponse = useQuery<TQueryFnData, TError, TData>(
-        queryKey.logList(meta),
+        keys()
+            .audit()
+            .resource(resource)
+            .action("list")
+            .params(meta)
+            .get(preferLegacyKeys),
         () =>
             get?.({
                 resource,

package/src/hooks/auth/useForgotPassword/index.ts

@@ -13,6 +13,7 @@ import {
     OpenNotificationParams,
     TForgotPasswordData,
 } from "../../../interfaces";
+import { useKeys } from "@hooks/useKeys";
 
 export type UseForgotPasswordLegacyProps<TVariables> = {
     v3LegacyAuthProviderCompatible: true;
@@ -112,35 +113,40 @@ export function useForgotPassword<TVariables = {}>({
     const { forgotPassword: forgotPasswordFromContext } =
         useAuthBindingsContext();
     const { close, open } = useNotification();
+    const { keys, preferLegacyKeys } = useKeys();
 
     const mutation = useMutation<
         AuthActionResponse,
         Error | RefineError,
         TVariables,
         unknown
-    >(["useForgotPassword"], forgotPasswordFromContext, {
-        onSuccess: ({ success, redirectTo, error }) => {
-            if (success) {
-                close?.("forgot-password-error");
-            }
+    >(
+        keys().auth().action("forgotPassword").get(preferLegacyKeys),
+        forgotPasswordFromContext,
+        {
+            onSuccess: ({ success, redirectTo, error }) => {
+                if (success) {
+                    close?.("forgot-password-error");
+                }
 
-            if (error || !success) {
-                open?.(buildNotification(error));
-            }
+                if (error || !success) {
+                    open?.(buildNotification(error));
+                }
 
-            if (redirectTo) {
-                if (routerType === "legacy") {
-                    replace(redirectTo);
-                } else {
-                    go({ to: redirectTo, type: "replace" });
+                if (redirectTo) {
+                    if (routerType === "legacy") {
+                        replace(redirectTo);
+                    } else {
+                        go({ to: redirectTo, type: "replace" });
+                    }
                 }
-            }
-        },
-        onError: (error: any) => {
-            open?.(buildNotification(error));
+            },
+            onError: (error: any) => {
+                open?.(buildNotification(error));
+            },
+            ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
         },
-        ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
-    });
+    );
 
     const v3LegacyAuthProviderCompatibleMutation = useMutation<
         TForgotPasswordData,
@@ -148,7 +154,10 @@ export function useForgotPassword<TVariables = {}>({
         TVariables,
         unknown
     >(
-        ["useForgotPassword", "v3LegacyAuthProviderCompatible"],
+        [
+            ...keys().auth().action("forgotPassword").get(preferLegacyKeys),
+            "v3LegacyAuthProviderCompatible",
+        ],
         v3LegacyAuthProviderCompatibleForgotPasswordFromContext,
         {
             onSuccess: (redirectPathFromAuth) => {