@refinedev/core 4.46.1 → 4.46.3-alpha.0

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

@@ -56,20 +56,22 @@ export function useIsAuthenticated({
     const { check } = useAuthBindingsContext();
     const { keys, preferLegacyKeys } = useKeys();
 
-    const queryResponse = useQuery(
-        keys().auth().action("check").params(params).get(preferLegacyKeys),
-        async () => (await check?.(params)) ?? {},
-        {
-            retry: false,
-            enabled: !v3LegacyAuthProviderCompatible,
-            meta: {
-                ...getXRay("useIsAuthenticated", preferLegacyKeys),
-            },
+    const queryResponse = useQuery({
+        queryKey: keys()
+            .auth()
+            .action("check")
+            .params(params)
+            .get(preferLegacyKeys),
+        queryFn: async () => (await check?.(params)) ?? {},
+        retry: false,
+        enabled: !v3LegacyAuthProviderCompatible,
+        meta: {
+            ...getXRay("useIsAuthenticated", preferLegacyKeys),
         },
-    );
+    });
 
-    const legacyQueryResponse = useQuery(
-        [
+    const legacyQueryResponse = useQuery({
+        queryKey: [
             ...keys()
                 .auth()
                 .action("check")
@@ -77,15 +79,13 @@ export function useIsAuthenticated({
                 .get(preferLegacyKeys),
             "v3LegacyAuthProviderCompatible",
         ],
-        async () => (await checkAuth?.(params)) ?? {},
-        {
-            retry: false,
-            enabled: v3LegacyAuthProviderCompatible,
-            meta: {
-                ...getXRay("useIsAuthenticated", preferLegacyKeys),
-            },
+        queryFn: async () => (await checkAuth?.(params)) ?? {},
+        retry: false,
+        enabled: v3LegacyAuthProviderCompatible,
+        meta: {
+            ...getXRay("useIsAuthenticated", preferLegacyKeys),
         },
-    );
+    });
 
     return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
 }

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

@@ -145,7 +145,9 @@ export function useLogin<TVariables = {}>({
         Error | RefineError,
         TVariables,
         unknown
-    >(keys().auth().action("login").get(preferLegacyKeys), loginFromContext, {
+    >({
+        mutationKey: keys().auth().action("login").get(preferLegacyKeys),
+        mutationFn: loginFromContext,
         onSuccess: async ({ success, redirectTo, error }) => {
             if (success) {
                 close?.("login-error");
@@ -192,50 +194,46 @@ export function useLogin<TVariables = {}>({
         Error | RefineError,
         TVariables,
         unknown
-    >(
-        [
+    >({
+        mutationKey: [
             ...keys().auth().action("login").get(preferLegacyKeys),
             "v3LegacyAuthProviderCompatible",
         ],
-        legacyLoginFromContext,
-        {
-            onSuccess: async (redirectPathFromAuth) => {
-                if (to) {
-                    replace(to as string);
-                }
+        mutationFn: legacyLoginFromContext,
+        onSuccess: async (redirectPathFromAuth) => {
+            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" });
-                        }
+            if (redirectPathFromAuth !== false && !to) {
+                if (typeof redirectPathFromAuth === "string") {
+                    if (routerType === "legacy") {
+                        replace(redirectPathFromAuth);
                     } else {
-                        if (routerType === "legacy") {
-                            replace("/");
-                        } else {
-                            go({ to: "/", type: "replace" });
-                        }
+                        go({ to: redirectPathFromAuth, type: "replace" });
+                    }
+                } else {
+                    if (routerType === "legacy") {
+                        replace("/");
+                    } else {
+                        go({ to: "/", type: "replace" });
                     }
                 }
+            }
 
-                await invalidateAuthStore();
+            await invalidateAuthStore();
 
-                close?.("login-error");
-            },
-            onError: (error: any) => {
-                open?.(buildNotification(error));
-            },
-            ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
-            meta: {
-                ...(v3LegacyAuthProviderCompatible
-                    ? mutationOptions?.meta
-                    : {}),
-                ...getXRay("useLogin", preferLegacyKeys),
-            },
+            close?.("login-error");
+        },
+        onError: (error: any) => {
+            open?.(buildNotification(error));
         },
-    );
+        ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+        meta: {
+            ...(v3LegacyAuthProviderCompatible ? mutationOptions?.meta : {}),
+            ...getXRay("useLogin", preferLegacyKeys),
+        },
+    });
 
     return v3LegacyAuthProviderCompatible
         ? v3LegacyAuthProviderCompatibleMutation

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

@@ -118,7 +118,9 @@ export function useLogout<TVariables = {}>({
         Error | RefineError,
         (TVariables & Variables) | void,
         unknown
-    >(keys().auth().action("logout").get(preferLegacyKeys), logoutFromContext, {
+    >({
+        mutationKey: keys().auth().action("logout").get(preferLegacyKeys),
+        mutationFn: logoutFromContext,
         onSuccess: async (data, variables) => {
             const { success, error, redirectTo } = data;
             const { redirectPath } = variables ?? {};
@@ -162,49 +164,45 @@ export function useLogout<TVariables = {}>({
         Error | RefineError,
         (TVariables & Variables) | void,
         unknown
-    >(
-        [
+    >({
+        mutationKey: [
             ...keys().auth().action("logout").get(preferLegacyKeys),
             "v3LegacyAuthProviderCompatible",
         ],
-        legacyLogoutFromContext,
-        {
-            onSuccess: async (data, variables) => {
-                const redirectPath = variables?.redirectPath ?? data;
-
-                if (redirectPath === false) {
-                    return;
-                }
+        mutationFn: legacyLogoutFromContext,
+        onSuccess: async (data, variables) => {
+            const redirectPath = variables?.redirectPath ?? data;
 
-                if (redirectPath) {
-                    if (routerType === "legacy") {
-                        push(redirectPath);
-                    } else {
-                        go({ to: redirectPath });
-                    }
-                    return;
-                }
+            if (redirectPath === false) {
+                return;
+            }
 
+            if (redirectPath) {
                 if (routerType === "legacy") {
-                    push("/login");
+                    push(redirectPath);
                 } else {
-                    go({ to: "/login" });
+                    go({ to: redirectPath });
                 }
+                return;
+            }
 
-                await invalidateAuthStore();
-            },
-            onError: (error: any) => {
-                open?.(buildNotification(error));
-            },
-            ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
-            meta: {
-                ...(v3LegacyAuthProviderCompatible
-                    ? mutationOptions?.meta
-                    : {}),
-                ...getXRay("useLogout", preferLegacyKeys),
-            },
+            if (routerType === "legacy") {
+                push("/login");
+            } else {
+                go({ to: "/login" });
+            }
+
+            await invalidateAuthStore();
+        },
+        onError: (error: any) => {
+            open?.(buildNotification(error));
         },
-    );
+        ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+        meta: {
+            ...(v3LegacyAuthProviderCompatible ? mutationOptions?.meta : {}),
+            ...getXRay("useLogout", preferLegacyKeys),
+        },
+    });
 
     return v3LegacyAuthProviderCompatible
         ? v3LegacyAuthProviderCompatibleMutation

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

@@ -75,46 +75,42 @@ export function useOnError({
         v3LegacyAuthProviderCompatible: Boolean(v3LegacyAuthProviderCompatible),
     });
 
-    const mutation = useMutation(
-        keys().auth().action("onError").get(preferLegacyKeys),
-        onErrorFromContext,
-        {
-            onSuccess: ({ logout: shouldLogout, redirectTo }) => {
-                if (shouldLogout) {
-                    logout({ redirectPath: redirectTo });
-                    return;
+    const mutation = useMutation({
+        mutationKey: keys().auth().action("onError").get(preferLegacyKeys),
+        mutationFn: onErrorFromContext,
+        onSuccess: ({ logout: shouldLogout, redirectTo }) => {
+            if (shouldLogout) {
+                logout({ redirectPath: redirectTo });
+                return;
+            }
+
+            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" });
-                    }
-                    return;
-                }
-            },
-            meta: {
-                ...getXRay("useOnError", preferLegacyKeys),
-            },
+                return;
+            }
+        },
+        meta: {
+            ...getXRay("useOnError", preferLegacyKeys),
         },
-    );
+    });
 
-    const v3LegacyAuthProviderCompatibleMutation = useMutation(
-        [
+    const v3LegacyAuthProviderCompatibleMutation = useMutation({
+        mutationKey: [
             ...keys().auth().action("onError").get(preferLegacyKeys),
             "v3LegacyAuthProviderCompatible",
         ],
-        legacyCheckErrorFromContext,
-        {
-            onError: (redirectPath?: string) => {
-                legacyLogout({ redirectPath });
-            },
-            meta: {
-                ...getXRay("useOnError", preferLegacyKeys),
-            },
+        mutationFn: legacyCheckErrorFromContext,
+        onError: (redirectPath?: string) => {
+            legacyLogout({ redirectPath });
+        },
+        meta: {
+            ...getXRay("useOnError", preferLegacyKeys),
         },
-    );
+    });
 
     return v3LegacyAuthProviderCompatible
         ? v3LegacyAuthProviderCompatibleMutation

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

@@ -67,37 +67,34 @@ export function usePermissions<TData = any>({
     const { getPermissions } = useAuthBindingsContext();
     const { keys, preferLegacyKeys } = useKeys();
 
-    const queryResponse = useQuery<TData>(
-        keys().auth().action("permissions").get(preferLegacyKeys),
+    const queryResponse = useQuery<TData>({
+        queryKey: 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>) ??
+        queryFn:
+            (getPermissions as (params?: unknown) => Promise<TData>) ??
             (() => Promise.resolve(undefined)),
-        {
-            enabled: !v3LegacyAuthProviderCompatible && !!getPermissions,
-            ...(v3LegacyAuthProviderCompatible ? {} : options),
-            meta: {
-                ...(v3LegacyAuthProviderCompatible ? {} : options?.meta),
-                ...getXRay("usePermissions", preferLegacyKeys),
-            },
+        enabled: !v3LegacyAuthProviderCompatible && !!getPermissions,
+        ...(v3LegacyAuthProviderCompatible ? {} : options),
+        meta: {
+            ...(v3LegacyAuthProviderCompatible ? {} : options?.meta),
+            ...getXRay("usePermissions", preferLegacyKeys),
         },
-    );
+    });
 
-    const legacyQueryResponse = useQuery<TData>(
-        [
+    const legacyQueryResponse = useQuery<TData>({
+        queryKey: [
             ...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)),
-        {
-            enabled: v3LegacyAuthProviderCompatible && !!legacyGetPermission,
-            ...(v3LegacyAuthProviderCompatible ? options : {}),
-            meta: {
-                ...(v3LegacyAuthProviderCompatible ? options?.meta : {}),
-                ...getXRay("usePermissions", preferLegacyKeys),
-            },
+        queryFn: legacyGetPermission ?? (() => Promise.resolve(undefined)),
+        enabled: v3LegacyAuthProviderCompatible && !!legacyGetPermission,
+        ...(v3LegacyAuthProviderCompatible ? options : {}),
+        meta: {
+            ...(v3LegacyAuthProviderCompatible ? options?.meta : {}),
+            ...getXRay("usePermissions", preferLegacyKeys),
         },
-    );
+    });
 
     return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
 }

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

@@ -120,91 +120,85 @@ export function useRegister<TVariables = {}>({
         Error | RefineError,
         TVariables,
         unknown
-    >(
-        keys().auth().action("register").get(preferLegacyKeys),
-        registerFromContext,
-        {
-            onSuccess: async ({ success, redirectTo, error }) => {
-                if (success) {
-                    close?.("register-error");
-                }
-
-                if (error || !success) {
-                    open?.(buildNotification(error));
-                }
+    >({
+        mutationKey: keys().auth().action("register").get(preferLegacyKeys),
+        mutationFn: registerFromContext,
+        onSuccess: async ({ success, redirectTo, error }) => {
+            if (success) {
+                close?.("register-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 {
-                    if (routerType === "legacy") {
-                        replace("/");
-                    }
+                    go({ to: redirectTo, type: "replace" });
+                }
+            } else {
+                if (routerType === "legacy") {
+                    replace("/");
                 }
+            }
 
-                await invalidateAuthStore();
-            },
-            onError: (error: any) => {
-                open?.(buildNotification(error));
-            },
-            ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
-            meta: {
-                ...(v3LegacyAuthProviderCompatible === true
-                    ? {}
-                    : mutationOptions?.meta),
-                ...getXRay("useRegister", preferLegacyKeys),
-            },
+            await invalidateAuthStore();
+        },
+        onError: (error: any) => {
+            open?.(buildNotification(error));
         },
-    );
+        ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
+        meta: {
+            ...(v3LegacyAuthProviderCompatible === true
+                ? {}
+                : mutationOptions?.meta),
+            ...getXRay("useRegister", preferLegacyKeys),
+        },
+    });
 
     const v3LegacyAuthProviderCompatibleMutation = useMutation<
         TRegisterData,
         Error | RefineError,
         TVariables,
         unknown
-    >(
-        [
+    >({
+        mutationKey: [
             ...keys().auth().action("register").get(preferLegacyKeys),
             "v3LegacyAuthProviderCompatible",
         ],
-        legacyRegisterFromContext,
-        {
-            onSuccess: async (redirectPathFromAuth) => {
-                if (redirectPathFromAuth !== false) {
-                    if (redirectPathFromAuth) {
-                        if (routerType === "legacy") {
-                            replace(redirectPathFromAuth);
-                        } else {
-                            go({ to: redirectPathFromAuth, type: "replace" });
-                        }
+        mutationFn: legacyRegisterFromContext,
+        onSuccess: async (redirectPathFromAuth) => {
+            if (redirectPathFromAuth !== false) {
+                if (redirectPathFromAuth) {
+                    if (routerType === "legacy") {
+                        replace(redirectPathFromAuth);
+                    } else {
+                        go({ to: redirectPathFromAuth, type: "replace" });
+                    }
+                } else {
+                    if (routerType === "legacy") {
+                        replace("/");
                     } else {
-                        if (routerType === "legacy") {
-                            replace("/");
-                        } else {
-                            go({ to: "/", type: "replace" });
-                        }
+                        go({ to: "/", type: "replace" });
                     }
+                }
 
-                    await invalidateAuthStore();
+                await invalidateAuthStore();
 
-                    close?.("register-error");
-                }
-            },
-            onError: (error: any) => {
-                open?.(buildNotification(error));
-            },
-            ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
-            meta: {
-                ...(v3LegacyAuthProviderCompatible
-                    ? mutationOptions?.meta
-                    : {}),
-                ...getXRay("useRegister", preferLegacyKeys),
-            },
+                close?.("register-error");
+            }
+        },
+        onError: (error: any) => {
+            open?.(buildNotification(error));
+        },
+        ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+        meta: {
+            ...(v3LegacyAuthProviderCompatible ? mutationOptions?.meta : {}),
+            ...getXRay("useRegister", preferLegacyKeys),
         },
-    );
+    });
 
     return v3LegacyAuthProviderCompatible
         ? v3LegacyAuthProviderCompatibleMutation

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

@@ -159,86 +159,83 @@ export function useUpdatePassword<
         Error,
         TVariables,
         unknown
-    >(
-        keys().auth().action("updatePassword").get(preferLegacyKeys),
-        async (variables) => {
+    >({
+        mutationKey: keys()
+            .auth()
+            .action("updatePassword")
+            .get(preferLegacyKeys),
+        mutationFn: async (variables) => {
             return updatePasswordFromContext?.({
                 ...params,
                 ...variables,
             }) as Promise<AuthActionResponse>;
         },
-        {
-            onSuccess: ({ success, redirectTo, error }) => {
-                if (success) {
-                    close?.("update-password-error");
-                }
+        onSuccess: ({ success, redirectTo, error }) => {
+            if (success) {
+                close?.("update-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));
-            },
-            ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
-            meta: {
-                ...(v3LegacyAuthProviderCompatible === true
-                    ? {}
-                    : mutationOptions?.meta),
-                ...getXRay("useUpdatePassword", preferLegacyKeys),
-            },
+            }
         },
-    );
+        onError: (error: any) => {
+            open?.(buildNotification(error));
+        },
+        ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
+        meta: {
+            ...(v3LegacyAuthProviderCompatible === true
+                ? {}
+                : mutationOptions?.meta),
+            ...getXRay("useUpdatePassword", preferLegacyKeys),
+        },
+    });
 
     const v3LegacyAuthProviderCompatibleMutation = useMutation<
         TUpdatePasswordData,
         Error | RefineError,
         TVariables,
         unknown
-    >(
-        [
+    >({
+        mutationKey: [
             ...keys().auth().action("updatePassword").get(preferLegacyKeys),
             "v3LegacyAuthProviderCompatible",
         ],
-        async (variables) => {
+        mutationFn: async (variables) => {
             return legacyUpdatePasswordFromContext?.({
                 ...params,
                 ...variables,
             });
         },
-        {
-            onSuccess: (redirectPathFromAuth) => {
-                if (redirectPathFromAuth !== false) {
-                    if (redirectPathFromAuth) {
-                        if (routerType === "legacy") {
-                            replace(redirectPathFromAuth);
-                        } else {
-                            go({ to: redirectPathFromAuth, type: "replace" });
-                        }
+        onSuccess: (redirectPathFromAuth) => {
+            if (redirectPathFromAuth !== false) {
+                if (redirectPathFromAuth) {
+                    if (routerType === "legacy") {
+                        replace(redirectPathFromAuth);
+                    } else {
+                        go({ to: redirectPathFromAuth, type: "replace" });
                     }
                 }
-                close?.("update-password-error");
-            },
-            onError: (error: any) => {
-                open?.(buildNotification(error));
-            },
-            ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
-            meta: {
-                ...(v3LegacyAuthProviderCompatible
-                    ? mutationOptions?.meta
-                    : {}),
-                ...getXRay("useUpdatePassword", preferLegacyKeys),
-            },
+            }
+            close?.("update-password-error");
+        },
+        onError: (error: any) => {
+            open?.(buildNotification(error));
+        },
+        ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+        meta: {
+            ...(v3LegacyAuthProviderCompatible ? mutationOptions?.meta : {}),
+            ...getXRay("useUpdatePassword", preferLegacyKeys),
         },
-    );
+    });
 
     return v3LegacyAuthProviderCompatible
         ? v3LegacyAuthProviderCompatibleMutation