@refinedev/core 4.34.0 → 4.36.0

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

@@ -6,6 +6,7 @@ import {
 
 import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
 import { IdentityResponse } from "../../../interfaces";
+import { useKeys } from "@hooks/useKeys";
 
 export type UseGetIdentityLegacyProps<TData> = {
     v3LegacyAuthProviderCompatible: true;
@@ -64,9 +65,10 @@ export function useGetIdentity<TData = any>({
     | UseGetIdentityLegacyReturnType<TData> {
     const { getUserIdentity: legacyGetUserIdentity } = useLegacyAuthContext();
     const { getIdentity } = useAuthBindingsContext();
+    const { keys, preferLegacyKeys } = useKeys();
 
     const queryResponse = useQuery<TData>(
-        ["getUserIdentity"],
+        keys().auth().action("identity").get(preferLegacyKeys),
         // Enabled check for `getIdentity` is enough to be sure that it's defined in the query function but TS is not smart enough to know that.
         (getIdentity as (params?: unknown) => Promise<TData>) ??
             (() => Promise.resolve({})),
@@ -78,7 +80,10 @@ export function useGetIdentity<TData = any>({
     );
 
     const legacyQueryResponse = useQuery<TData>(
-        ["getUserIdentity", "v3LegacyAuthProviderCompatible"],
+        [
+            ...keys().auth().action("identity").get(preferLegacyKeys),
+            "v3LegacyAuthProviderCompatible",
+        ],
         // Enabled check for `getUserIdentity` is enough to be sure that it's defined in the query function but TS is not smart enough to know that.
         legacyGetUserIdentity ?? (() => Promise.resolve({})),
         {

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

@@ -1,13 +1,21 @@
+import { useKeys } from "@hooks/useKeys";
 import { useQueryClient } from "@tanstack/react-query";
 
 export const useInvalidateAuthStore = () => {
     const queryClient = useQueryClient();
+    const { keys, preferLegacyKeys } = useKeys();
 
     const invalidate = async () => {
         await Promise.all([
-            queryClient.invalidateQueries(["useAuthenticated"]),
-            queryClient.invalidateQueries(["getUserIdentity"]),
-            queryClient.invalidateQueries(["usePermissions"]),
+            queryClient.invalidateQueries(
+                keys().auth().action("check").get(preferLegacyKeys),
+            ),
+            queryClient.invalidateQueries(
+                keys().auth().action("identity").get(preferLegacyKeys),
+            ),
+            queryClient.invalidateQueries(
+                keys().auth().action("permissions").get(preferLegacyKeys),
+            ),
         ]);
     };
 

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

@@ -2,6 +2,7 @@ import { useQuery, UseQueryResult } from "@tanstack/react-query";
 
 import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
 import { CheckResponse } from "../../../interfaces";
+import { useKeys } from "@hooks/useKeys";
 
 export type UseIsAuthenticatedLegacyProps = {
     v3LegacyAuthProviderCompatible: true;
@@ -52,9 +53,10 @@ export function useIsAuthenticated({
     | UseIsAuthenticatedLegacyReturnType {
     const { checkAuth } = useLegacyAuthContext();
     const { check } = useAuthBindingsContext();
+    const { keys, preferLegacyKeys } = useKeys();
 
     const queryResponse = useQuery(
-        ["useAuthenticated", params],
+        keys().auth().action("check").params(params).get(preferLegacyKeys),
         async () => (await check?.(params)) ?? {},
         {
             retry: false,
@@ -63,7 +65,14 @@ export function useIsAuthenticated({
     );
 
     const legacyQueryResponse = useQuery(
-        ["useAuthenticated", params, "v3LegacyAuthProviderCompatible"],
+        [
+            ...keys()
+                .auth()
+                .action("check")
+                .params(params)
+                .get(preferLegacyKeys),
+            "v3LegacyAuthProviderCompatible",
+        ],
         async () => (await checkAuth?.(params)) ?? {},
         {
             retry: false,

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

@@ -23,6 +23,7 @@ import {
 } from "../../../interfaces";
 import { AuthActionResponse } from "src/interfaces/bindings/auth";
 import { useInvalidateAuthStore } from "../useInvalidateAuthStore";
+import { useKeys } from "@hooks/useKeys";
 
 export type UseLoginLegacyProps<TVariables> = {
     v3LegacyAuthProviderCompatible: true;
@@ -125,6 +126,7 @@ export function useLogin<TVariables = {}>({
     const { close, open } = useNotification();
     const { login: legacyLoginFromContext } = useLegacyAuthContext();
     const { login: loginFromContext } = useAuthBindingsContext();
+    const { keys, preferLegacyKeys } = useKeys();
 
     const to = React.useMemo(() => {
         if (routerType === "legacy") {
@@ -142,7 +144,7 @@ export function useLogin<TVariables = {}>({
         Error | RefineError,
         TVariables,
         unknown
-    >(["useLogin"], loginFromContext, {
+    >(keys().auth().action("login").get(preferLegacyKeys), loginFromContext, {
         onSuccess: async ({ success, redirectTo, error }) => {
             if (success) {
                 close?.("login-error");
@@ -183,37 +185,44 @@ export function useLogin<TVariables = {}>({
         Error | RefineError,
         TVariables,
         unknown
-    >(["useLogin", "v3LegacyAuthProviderCompatible"], legacyLoginFromContext, {
-        onSuccess: async (redirectPathFromAuth) => {
-            await invalidateAuthStore();
-
-            if (to) {
-                replace(to as string);
-            }
+    >(
+        [
+            ...keys().auth().action("login").get(preferLegacyKeys),
+            "v3LegacyAuthProviderCompatible",
+        ],
+        legacyLoginFromContext,
+        {
+            onSuccess: async (redirectPathFromAuth) => {
+                await invalidateAuthStore();
+
+                if (to) {
+                    replace(to as string);
+                }
 
-            if (redirectPathFromAuth !== false && !to) {
-                if (typeof redirectPathFromAuth === "string") {
-                    if (routerType === "legacy") {
-                        replace(redirectPathFromAuth);
-                    } else {
-                        go({ to: redirectPathFromAuth, type: "replace" });
-                    }
-                } else {
-                    if (routerType === "legacy") {
-                        replace("/");
+                if (redirectPathFromAuth !== false && !to) {
+                    if (typeof redirectPathFromAuth === "string") {
+                        if (routerType === "legacy") {
+                            replace(redirectPathFromAuth);
+                        } else {
+                            go({ to: redirectPathFromAuth, type: "replace" });
+                        }
                     } else {
-                        go({ to: "/", type: "replace" });
+                        if (routerType === "legacy") {
+                            replace("/");
+                        } else {
+                            go({ to: "/", type: "replace" });
+                        }
                     }
                 }
-            }
 
-            close?.("login-error");
-        },
-        onError: (error: any) => {
-            open?.(buildNotification(error));
+                close?.("login-error");
+            },
+            onError: (error: any) => {
+                open?.(buildNotification(error));
+            },
+            ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
         },
-        ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
-    });
+    );
 
     return v3LegacyAuthProviderCompatible
         ? v3LegacyAuthProviderCompatibleMutation

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

@@ -13,6 +13,7 @@ import {
 } from "../../../interfaces";
 import { AuthActionResponse } from "src/interfaces/bindings/auth";
 import { useInvalidateAuthStore } from "../useInvalidateAuthStore";
+import { useKeys } from "@hooks/useKeys";
 
 type Variables = {
     redirectPath?: string | false;
@@ -109,13 +110,14 @@ export function useLogout<TVariables = {}>({
     const { open, close } = useNotification();
     const { logout: legacyLogoutFromContext } = useLegacyAuthContext();
     const { logout: logoutFromContext } = useAuthBindingsContext();
+    const { keys, preferLegacyKeys } = useKeys();
 
     const mutation = useMutation<
         AuthActionResponse,
         Error | RefineError,
         (TVariables & Variables) | void,
         unknown
-    >(["useLogout"], logoutFromContext, {
+    >(keys().auth().action("logout").get(preferLegacyKeys), logoutFromContext, {
         onSuccess: async (data, variables) => {
             const { success, error, redirectTo } = data;
             const { redirectPath } = variables ?? {};
@@ -154,7 +156,10 @@ export function useLogout<TVariables = {}>({
         (TVariables & Variables) | void,
         unknown
     >(
-        ["useLogout", "v3LegacyAuthProviderCompatible"],
+        [
+            ...keys().auth().action("logout").get(preferLegacyKeys),
+            "v3LegacyAuthProviderCompatible",
+        ],
         legacyLogoutFromContext,
         {
             onSuccess: async (data, variables) => {

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

@@ -3,6 +3,7 @@ import { useMutation, UseMutationResult } from "@tanstack/react-query";
 import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
 import { OnErrorResponse } from "../../../interfaces";
 import { useGo, useLogout, useNavigation, useRouterType } from "@hooks";
+import { useKeys } from "@hooks/useKeys";
 
 export type UseOnErrorLegacyProps = {
     v3LegacyAuthProviderCompatible: true;
@@ -64,6 +65,8 @@ export function useOnError({
     const { checkError: legacyCheckErrorFromContext } = useLegacyAuthContext();
     const { onError: onErrorFromContext } = useAuthBindingsContext();
 
+    const { keys, preferLegacyKeys } = useKeys();
+
     const { mutate: legacyLogout } = useLogout({
         v3LegacyAuthProviderCompatible: Boolean(v3LegacyAuthProviderCompatible),
     });
@@ -71,26 +74,33 @@ export function useOnError({
         v3LegacyAuthProviderCompatible: Boolean(v3LegacyAuthProviderCompatible),
     });
 
-    const mutation = useMutation(["useCheckError"], onErrorFromContext, {
-        onSuccess: ({ logout: shouldLogout, redirectTo }) => {
-            if (shouldLogout) {
-                logout({ redirectPath: redirectTo });
-                return;
-            }
-
-            if (redirectTo) {
-                if (routerType === "legacy") {
-                    replace(redirectTo);
-                } else {
-                    go({ to: redirectTo, type: "replace" });
+    const mutation = useMutation(
+        keys().auth().action("onError").get(preferLegacyKeys),
+        onErrorFromContext,
+        {
+            onSuccess: ({ logout: shouldLogout, redirectTo }) => {
+                if (shouldLogout) {
+                    logout({ redirectPath: redirectTo });
+                    return;
+                }
+
+                if (redirectTo) {
+                    if (routerType === "legacy") {
+                        replace(redirectTo);
+                    } else {
+                        go({ to: redirectTo, type: "replace" });
+                    }
+                    return;
                 }
-                return;
-            }
+            },
         },
-    });
+    );
 
     const v3LegacyAuthProviderCompatibleMutation = useMutation(
-        ["useCheckError", "v3LegacyAuthProviderCompatible"],
+        [
+            ...keys().auth().action("onError").get(preferLegacyKeys),
+            "v3LegacyAuthProviderCompatible",
+        ],
         legacyCheckErrorFromContext,
         {
             onError: (redirectPath?: string) => {

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

@@ -5,6 +5,7 @@ import {
     UseQueryResult,
     UseQueryOptions,
 } from "@tanstack/react-query";
+import { useKeys } from "@hooks/useKeys";
 
 export type UsePermissionsLegacyProps<TData = any> = {
     v3LegacyAuthProviderCompatible: true;
@@ -61,9 +62,10 @@ export function usePermissions<TData = any>({
     | UsePermissionsLegacyReturnType<TData> {
     const { getPermissions: legacyGetPermission } = useLegacyAuthContext();
     const { getPermissions } = useAuthBindingsContext();
+    const { keys, preferLegacyKeys } = useKeys();
 
     const queryResponse = useQuery<TData>(
-        ["usePermissions"],
+        keys().auth().action("permissions").get(preferLegacyKeys),
         // Enabled check for `getPermissions` is enough to be sure that it's defined in the query function but TS is not smart enough to know that.
         (getPermissions as (params?: unknown) => Promise<TData>) ??
             (() => Promise.resolve(undefined)),
@@ -74,7 +76,10 @@ export function usePermissions<TData = any>({
     );
 
     const legacyQueryResponse = useQuery<TData>(
-        ["usePermissions", "v3LegacyAuthProviderCompatible"],
+        [
+            ...keys().auth().action("permissions").get(preferLegacyKeys),
+            "v3LegacyAuthProviderCompatible",
+        ],
         // Enabled check for `getPermissions` is enough to be sure that it's defined in the query function but TS is not smart enough to know that.
         legacyGetPermission ?? (() => Promise.resolve(undefined)),
         {

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

@@ -15,6 +15,7 @@ import {
     TRegisterData,
 } from "../../../interfaces";
 import { useInvalidateAuthStore } from "../useInvalidateAuthStore";
+import { useKeys } from "@hooks/useKeys";
 
 export type UseRegisterLegacyProps<TVariables> = {
     v3LegacyAuthProviderCompatible: true;
@@ -111,40 +112,46 @@ export function useRegister<TVariables = {}>({
     const { register: registerFromContext } = useAuthBindingsContext();
     const { close, open } = useNotification();
 
+    const { keys, preferLegacyKeys } = useKeys();
+
     const mutation = useMutation<
         AuthActionResponse,
         Error | RefineError,
         TVariables,
         unknown
-    >(["useRegister"], registerFromContext, {
-        onSuccess: async ({ success, redirectTo, error }) => {
-            if (success) {
-                close?.("register-error");
-            }
+    >(
+        keys().auth().action("register").get(preferLegacyKeys),
+        registerFromContext,
+        {
+            onSuccess: async ({ success, redirectTo, error }) => {
+                if (success) {
+                    close?.("register-error");
+                }
 
-            if (error || !success) {
-                open?.(buildNotification(error));
-            }
+                if (error || !success) {
+                    open?.(buildNotification(error));
+                }
 
-            await invalidateAuthStore();
+                await invalidateAuthStore();
 
-            if (redirectTo) {
-                if (routerType === "legacy") {
-                    replace(redirectTo);
+                if (redirectTo) {
+                    if (routerType === "legacy") {
+                        replace(redirectTo);
+                    } else {
+                        go({ to: redirectTo, type: "replace" });
+                    }
                 } else {
-                    go({ to: redirectTo, type: "replace" });
-                }
-            } else {
-                if (routerType === "legacy") {
-                    replace("/");
+                    if (routerType === "legacy") {
+                        replace("/");
+                    }
                 }
-            }
-        },
-        onError: (error: any) => {
-            open?.(buildNotification(error));
+            },
+            onError: (error: any) => {
+                open?.(buildNotification(error));
+            },
+            ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
         },
-        ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
-    });
+    );
 
     const v3LegacyAuthProviderCompatibleMutation = useMutation<
         TRegisterData,
@@ -152,7 +159,10 @@ export function useRegister<TVariables = {}>({
         TVariables,
         unknown
     >(
-        ["useRegister", "v3LegacyAuthProviderCompatible"],
+        [
+            ...keys().auth().action("register").get(preferLegacyKeys),
+            "v3LegacyAuthProviderCompatible",
+        ],
         legacyRegisterFromContext,
         {
             onSuccess: async (redirectPathFromAuth) => {

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

@@ -22,6 +22,7 @@ import {
     TUpdatePasswordData,
     UpdatePasswordFormTypes,
 } from "../../../interfaces";
+import { useKeys } from "@hooks/useKeys";
 
 export type UseUpdatePasswordLegacyProps<
     TVariables extends UpdatePasswordFormTypes,
@@ -135,6 +136,8 @@ export function useUpdatePassword<
         useAuthBindingsContext();
     const { close, open } = useNotification();
 
+    const { keys, preferLegacyKeys } = useKeys();
+
     const parsed = useParsed();
     const { useLocation } = useRouterContext();
     const { search } = useLocation();
@@ -156,7 +159,7 @@ export function useUpdatePassword<
         TVariables,
         unknown
     >(
-        ["useUpdatePassword"],
+        keys().auth().action("updatePassword").get(preferLegacyKeys),
         async (variables) => {
             return updatePasswordFromContext?.({
                 ...params,
@@ -194,7 +197,10 @@ export function useUpdatePassword<
         TVariables,
         unknown
     >(
-        ["useUpdatePassword", "v3LegacyAuthProviderCompatible"],
+        [
+            ...keys().auth().action("updatePassword").get(preferLegacyKeys),
+            "v3LegacyAuthProviderCompatible",
+        ],
         async (variables) => {
             return legacyUpdatePasswordFromContext?.({
                 ...params,

package/src/hooks/data/useCreate.ts

@@ -34,6 +34,7 @@ import {
     UseLoadingOvertimeOptionsProps,
     UseLoadingOvertimeReturnType,
 } from "../useLoadingOvertime";
+import { useKeys } from "@hooks/useKeys";
 
 type useCreateParams<TData, TError, TVariables> = {
     /**
@@ -131,6 +132,7 @@ export const useCreate = <
     const {
         options: { textTransformers },
     } = useRefineContext();
+    const { keys, preferLegacyKeys } = useKeys();
 
     const mutation = useMutation<
         CreateResponse<TData>,
@@ -277,6 +279,7 @@ export const useCreate = <
                     type: "error",
                 });
             },
+            mutationKey: keys().data().mutation("create").get(preferLegacyKeys),
             ...mutationOptions,
         },
     );

package/src/hooks/data/useCreateMany.ts

@@ -33,6 +33,7 @@ import {
     UseLoadingOvertimeOptionsProps,
     UseLoadingOvertimeReturnType,
 } from "../useLoadingOvertime";
+import { useKeys } from "@hooks/useKeys";
 
 type useCreateManyParams<TData, TError, TVariables> = {
     resource: string;
@@ -105,6 +106,7 @@ export const useCreateMany = <
     const {
         options: { textTransformers },
     } = useRefineContext();
+    const { keys, preferLegacyKeys } = useKeys();
 
     const mutation = useMutation<
         CreateManyResponse<TData>,
@@ -261,6 +263,10 @@ export const useCreateMany = <
                     type: "error",
                 });
             },
+            mutationKey: keys()
+                .data()
+                .mutation("createMany")
+                .get(preferLegacyKeys),
             ...mutationOptions,
         },
     );

package/src/hooks/data/useCustom.ts

@@ -27,6 +27,7 @@ import {
     UseLoadingOvertimeOptionsProps,
     UseLoadingOvertimeReturnType,
 } from "../useLoadingOvertime";
+import { useKeys } from "@hooks/useKeys";
 
 interface UseCustomConfig<TQuery, TPayload> {
     /**
@@ -129,6 +130,7 @@ export const useCustom = <
     const translate = useTranslate();
     const handleNotification = useHandleNotification();
     const getMeta = useMeta();
+    const { keys, preferLegacyKeys } = useKeys();
 
     const preferredMeta = pickNotDeprecated(meta, metaData);
 
@@ -142,13 +144,16 @@ export const useCustom = <
             TError,
             CustomResponse<TData>
         >({
-            queryKey: [
-                dataProviderName,
-                "custom",
-                method,
-                url,
-                { ...config, ...(preferredMeta || {}) },
-            ],
+            queryKey: keys()
+                .data(dataProviderName)
+                .mutation("custom")
+                .params({
+                    method,
+                    url,
+                    ...config,
+                    ...(preferredMeta || {}),
+                })
+                .get(preferLegacyKeys),
             queryFn: ({ queryKey, pageParam, signal }) =>
                 custom<TQueryFnData>({
                     url,

package/src/hooks/data/useCustomMutation.ts

@@ -25,6 +25,7 @@ import {
     UseLoadingOvertimeOptionsProps,
     UseLoadingOvertimeReturnType,
 } from "../useLoadingOvertime";
+import { useKeys } from "@hooks/useKeys";
 
 interface UseCustomMutationConfig {
     headers?: {};
@@ -112,6 +113,7 @@ export const useCustomMutation = <
     const dataProvider = useDataProvider();
     const translate = useTranslate();
     const getMeta = useMeta();
+    const { keys, preferLegacyKeys } = useKeys();
 
     const mutation = useMutation<
         CreateResponse<TData>,
@@ -198,6 +200,10 @@ export const useCustomMutation = <
                     type: "error",
                 });
             },
+            mutationKey: keys()
+                .data()
+                .mutation("customMutation")
+                .get(preferLegacyKeys),
             ...mutationOptions,
         },
     );

package/src/hooks/data/useDelete.ts

@@ -34,7 +34,7 @@ import {
     MetaQuery,
 } from "../../interfaces";
 import {
-    queryKeys,
+    queryKeysReplacement,
     pickDataProvider,
     pickNotDeprecated,
     useActiveAuthProvider,
@@ -44,6 +44,7 @@ import {
     UseLoadingOvertimeOptionsProps,
     UseLoadingOvertimeReturnType,
 } from "../useLoadingOvertime";
+import { useKeys } from "@hooks/useKeys";
 
 export type DeleteParams<TData, TError, TVariables> = {
     /**
@@ -165,6 +166,7 @@ export const useDelete = <
     const {
         options: { textTransformers },
     } = useRefineContext();
+    const { keys, preferLegacyKeys } = useKeys();
 
     const mutation = useMutation<
         DeleteOneResponse<TData>,
@@ -265,17 +267,27 @@ export const useDelete = <
 
                 const preferredMeta = pickNotDeprecated(meta, metaData);
 
-                const queryKey = queryKeys(
+                const queryKey = queryKeysReplacement(preferLegacyKeys)(
                     identifier,
                     pickDataProvider(identifier, dataProviderName, resources),
                     preferredMeta,
                 );
 
+                const resourceKeys = keys()
+                    .data(
+                        pickDataProvider(
+                            identifier,
+                            dataProviderName,
+                            resources,
+                        ),
+                    )
+                    .resource(identifier);
+
                 const mutationModePropOrContext =
                     mutationMode ?? mutationModeContext;
 
                 await queryClient.cancelQueries(
-                    queryKey.resourceAll,
+                    resourceKeys.get(preferLegacyKeys),
                     undefined,
                     {
                         silent: true,
@@ -283,12 +295,17 @@ export const useDelete = <
                 );
 
                 const previousQueries: PreviousQuery<TData>[] =
-                    queryClient.getQueriesData(queryKey.resourceAll);
+                    queryClient.getQueriesData(
+                        resourceKeys.get(preferLegacyKeys),
+                    );
 
                 if (mutationModePropOrContext !== "pessimistic") {
                     // Set the previous queries to the new ones:
                     queryClient.setQueriesData(
-                        queryKey.list(),
+                        resourceKeys
+                            .action("list")
+                            .params(preferredMeta ?? {})
+                            .get(preferLegacyKeys),
                         (previous?: GetListResponse<TData> | null) => {
                             if (!previous) {
                                 return null;
@@ -306,7 +323,7 @@ export const useDelete = <
                     );
 
                     queryClient.setQueriesData(
-                        queryKey.many(),
+                        resourceKeys.action("many").get(preferLegacyKeys),
                         (previous?: GetListResponse<TData> | null) => {
                             if (!previous) {
                                 return null;
@@ -474,6 +491,7 @@ export const useDelete = <
                     });
                 }
             },
+            mutationKey: keys().data().mutation("delete").get(preferLegacyKeys),
             ...mutationOptions,
         },
     );