@refinedev/core 4.58.0 → 5.0.1

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

@@ -1,93 +1,46 @@
 import { getXRay } from "@refinedev/devtools-internal";
-import { type UseQueryResult, useQuery } from "@tanstack/react-query";
+import {
+  type UseQueryOptions,
+  type UseQueryResult,
+  useQuery,
+} from "@tanstack/react-query";
 
-import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
-import { useKeys } from "@hooks/useKeys";
+import { useAuthProviderContext } from "@contexts/auth";
+import { useKeys } from "@hooks";
 
 import type { CheckResponse } from "../../../contexts/auth/types";
 
-export type UseIsAuthenticatedLegacyProps = {
-  v3LegacyAuthProviderCompatible: true;
-  params?: any;
-};
-
 export type UseIsAuthenticatedProps = {
-  v3LegacyAuthProviderCompatible?: false;
-  params?: any;
-};
-
-export type UseIsAuthenticatedCombinedProps = {
-  v3LegacyAuthProviderCompatible: boolean;
+  // Make queryKey and queryFn optional
+  queryOptions?: Omit<UseQueryOptions<CheckResponse>, "queryKey" | "queryFn">;
   params?: any;
 };
 
-export type UseIsAuthenticatedLegacyReturnType = UseQueryResult<any, any>;
-
 export type UseIsAuthenticatedReturnType = UseQueryResult<CheckResponse, any>;
 
-export type UseIsAuthenticatedCombinedReturnType = UseQueryResult<
-  CheckResponse | any,
-  any
->;
-
-export function useIsAuthenticated(
-  props: UseIsAuthenticatedLegacyProps,
-): UseIsAuthenticatedLegacyReturnType;
-
-export function useIsAuthenticated(
-  props?: UseIsAuthenticatedProps,
-): UseIsAuthenticatedReturnType;
-
-export function useIsAuthenticated(
-  props?: UseIsAuthenticatedCombinedProps,
-): UseIsAuthenticatedCombinedReturnType;
-
 /**
- *  `useIsAuthenticated` calls the `checkAuth` method from the {@link https://refine.dev/docs/core/providers/auth-provider `authProvider`} under the hood.
+ * `useIsAuthenticated` calls `check` method from {@link https://refine.dev/docs/authentication/auth-provider/#check   `authProvider`} under the hood.
+ *
+ * @see {@link https://refine.dev/docs/api-reference/core/hooks/auth/useIsAuthenticated} for more details.
  *
- * @see {@link https://refine.dev/docs/api-reference/core/hooks/auth/useAuthenticated} for more details.
  */
 export function useIsAuthenticated({
-  v3LegacyAuthProviderCompatible = false,
+  queryOptions,
   params,
-}: UseIsAuthenticatedProps | UseIsAuthenticatedLegacyProps = {}):
-  | UseIsAuthenticatedReturnType
-  | UseIsAuthenticatedLegacyReturnType {
-  const { checkAuth } = useLegacyAuthContext();
-  const { check } = useAuthBindingsContext();
-  const { keys, preferLegacyKeys } = useKeys();
-
-  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),
-    },
-  });
+}: UseIsAuthenticatedProps = {}): UseIsAuthenticatedReturnType {
+  const { check } = useAuthProviderContext();
+  const { keys } = useKeys();
 
-  const legacyQueryResponse = useQuery({
-    queryKey: [
-      ...keys().auth().action("check").params(params).get(preferLegacyKeys),
-      "v3LegacyAuthProviderCompatible",
-    ],
-    queryFn: async () => (await checkAuth?.(params)) ?? {},
+  const queryResponse = useQuery<CheckResponse>({
+    queryKey: keys().auth().action("check").get(),
+    queryFn: async () => (await check?.(params)) ?? { authenticated: true },
     retry: false,
-    enabled: v3LegacyAuthProviderCompatible,
+    ...queryOptions,
     meta: {
-      ...getXRay("useIsAuthenticated", preferLegacyKeys),
+      ...queryOptions?.meta,
+      ...getXRay("useIsAuthenticated"),
     },
   });
 
-  return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
+  return queryResponse;
 }
-
-/**
- * @deprecated `useAuthenticated` is deprecated with refine@4, use `useIsAuthenticated` instead, however, we still support `useAuthenticated` for backward compatibility.
- */
-export const useAuthenticated = useIsAuthenticated;

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

@@ -1,12 +1,11 @@
-import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
+import { useAuthProviderContext } from "@contexts/auth";
 
 /**
  * A hook that the UI uses
  * @internal
  */
 export const useIsExistAuthentication = (): boolean => {
-  const { isProvided: legacyIsProvided } = useLegacyAuthContext();
-  const { isProvided } = useAuthBindingsContext();
+  const { isProvided } = useAuthProviderContext();
 
-  return Boolean(isProvided || legacyIsProvided);
+  return Boolean(isProvided);
 };

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

@@ -6,38 +6,19 @@ import {
   type UseMutationResult,
   useMutation,
 } from "@tanstack/react-query";
-import qs from "qs";
 
-import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
-import {
-  useGo,
-  useKeys,
-  useNavigation,
-  useNotification,
-  useParsed,
-  useRouterContext,
-  useRouterType,
-} from "@hooks";
+import { useAuthProviderContext } from "@contexts/auth";
+import { useGo, useKeys, useNotification, useParsed } from "@hooks";
 
 import type {
   AuthActionResponse,
   SuccessNotificationResponse,
-  TLoginData,
 } from "../../../contexts/auth/types";
 import type { RefineError } from "../../../contexts/data/types";
 import type { OpenNotificationParams } from "../../../contexts/notification/types";
 import { useInvalidateAuthStore } from "../useInvalidateAuthStore";
 
-export type UseLoginLegacyProps<TVariables> = {
-  v3LegacyAuthProviderCompatible: true;
-  mutationOptions?: Omit<
-    UseMutationOptions<TLoginData, Error | RefineError, TVariables, unknown>,
-    "mutationFn" | "onError" | "onSuccess"
-  >;
-};
-
 export type UseLoginProps<TVariables> = {
-  v3LegacyAuthProviderCompatible?: false;
   mutationOptions?: Omit<
     UseMutationOptions<
       AuthActionResponse,
@@ -49,26 +30,6 @@ export type UseLoginProps<TVariables> = {
   >;
 };
 
-export type UseLoginCombinedProps<TVariables> = {
-  v3LegacyAuthProviderCompatible: boolean;
-  mutationOptions?: Omit<
-    UseMutationOptions<
-      AuthActionResponse | TLoginData,
-      Error | RefineError,
-      TVariables,
-      unknown
-    >,
-    "mutationFn"
-  >;
-};
-
-export type UseLoginLegacyReturnType<TVariables> = UseMutationResult<
-  TLoginData,
-  Error | RefineError,
-  TVariables,
-  unknown
->;
-
 export type UseLoginReturnType<TVariables> = UseMutationResult<
   AuthActionResponse,
   Error | RefineError,
@@ -76,25 +37,6 @@ export type UseLoginReturnType<TVariables> = UseMutationResult<
   unknown
 >;
 
-export type UseLoginCombinedReturnType<TVariables> = UseMutationResult<
-  AuthActionResponse | TLoginData,
-  Error | RefineError,
-  TVariables,
-  unknown
->;
-
-export function useLogin<TVariables = {}>(
-  props: UseLoginLegacyProps<TVariables>,
-): UseLoginLegacyReturnType<TVariables>;
-
-export function useLogin<TVariables = {}>(
-  props?: UseLoginProps<TVariables>,
-): UseLoginReturnType<TVariables>;
-
-export function useLogin<TVariables = {}>(
-  props?: UseLoginCombinedProps<TVariables>,
-): UseLoginCombinedReturnType<TVariables>;
-
 /**
  * `useLogin` calls `login` method from {@link https://refine.dev/docs/api-reference/core/providers/auth-provider `authProvider`} under the hood.
  *
@@ -105,36 +47,17 @@ export function useLogin<TVariables = {}>(
  *
  */
 export function useLogin<TVariables = {}>({
-  v3LegacyAuthProviderCompatible,
   mutationOptions,
-}: UseLoginProps<TVariables> | UseLoginLegacyProps<TVariables> = {}):
-  | UseLoginLegacyReturnType<TVariables>
-  | UseLoginReturnType<TVariables> {
+}: UseLoginProps<TVariables> = {}): UseLoginReturnType<TVariables> {
   const invalidateAuthStore = useInvalidateAuthStore();
-  const routerType = useRouterType();
-
   const go = useGo();
-  const { replace } = useNavigation();
-
   const parsed = useParsed();
 
-  const { useLocation } = useRouterContext();
-  const { search } = useLocation();
-
   const { close, open } = useNotification();
-  const { login: legacyLoginFromContext } = useLegacyAuthContext();
-  const { login: loginFromContext } = useAuthBindingsContext();
-  const { keys, preferLegacyKeys } = useKeys();
+  const { login: loginFromContext } = useAuthProviderContext();
+  const { keys } = useKeys();
 
-  const to = React.useMemo(() => {
-    if (routerType === "legacy") {
-      const legacySearch = qs.parse(search, {
-        ignoreQueryPrefix: true,
-      });
-      return legacySearch.to;
-    }
-    return parsed.params?.to;
-  }, [routerType, parsed.params, search]);
+  const to = parsed.params?.to;
 
   const mutation = useMutation<
     AuthActionResponse,
@@ -142,7 +65,7 @@ export function useLogin<TVariables = {}>({
     TVariables,
     unknown
   >({
-    mutationKey: keys().auth().action("login").get(preferLegacyKeys),
+    mutationKey: keys().auth().action("login").get(),
     mutationFn: loginFromContext,
     onSuccess: async ({ success, redirectTo, error, successNotification }) => {
       if (success) {
@@ -157,89 +80,31 @@ export function useLogin<TVariables = {}>({
         open?.(buildNotification(error));
       }
 
-      if (to && success) {
-        if (routerType === "legacy") {
-          replace(to as string);
-        } else {
-          go({ to: to as string, type: "replace" });
-        }
-      } else if (redirectTo) {
-        if (routerType === "legacy") {
-          replace(redirectTo);
-        } else {
+      if (success) {
+        if (to) {
+          go({ to: to, type: "replace" });
+        } else if (redirectTo) {
           go({ to: redirectTo, type: "replace" });
         }
-      } else {
-        if (routerType === "legacy") {
-          replace("/");
-        }
-      }
-
-      setTimeout(() => {
-        invalidateAuthStore();
-      }, 32);
-    },
-    onError: (error: any) => {
-      open?.(buildNotification(error));
-    },
-    ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
-    meta: {
-      ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions?.meta),
-      ...getXRay("useLogin", preferLegacyKeys),
-    },
-  });
-
-  const v3LegacyAuthProviderCompatibleMutation = useMutation<
-    TLoginData,
-    Error | RefineError,
-    TVariables,
-    unknown
-  >({
-    mutationKey: [
-      ...keys().auth().action("login").get(preferLegacyKeys),
-      "v3LegacyAuthProviderCompatible",
-    ],
-    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" });
-          }
-        } else {
-          if (routerType === "legacy") {
-            replace("/");
-          } else {
-            go({ to: "/", type: "replace" });
-          }
-        }
       }
 
       setTimeout(() => {
         invalidateAuthStore();
       }, 32);
-
-      close?.("login-error");
     },
     onError: (error: any) => {
       open?.(buildNotification(error));
     },
-    ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+    ...mutationOptions,
     meta: {
-      ...(v3LegacyAuthProviderCompatible ? mutationOptions?.meta : {}),
-      ...getXRay("useLogin", preferLegacyKeys),
+      ...mutationOptions?.meta,
+      ...getXRay("useLogin"),
     },
   });
 
-  return v3LegacyAuthProviderCompatible
-    ? v3LegacyAuthProviderCompatibleMutation
-    : mutation;
+  return {
+    ...mutation,
+  };
 }
 
 const buildNotification = (

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

@@ -5,19 +5,12 @@ import {
   useMutation,
 } from "@tanstack/react-query";
 
-import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
-import {
-  useGo,
-  useKeys,
-  useNavigation,
-  useNotification,
-  useRouterType,
-} from "@hooks";
+import { useAuthProviderContext } from "@contexts/auth";
+import { useGo, useKeys, useNotification } from "@hooks";
 
 import type {
   AuthActionResponse,
   SuccessNotificationResponse,
-  TLogoutData,
 } from "../../../contexts/auth/types";
 import type { RefineError } from "../../../contexts/data/types";
 import type { OpenNotificationParams } from "../../../contexts/notification/types";
@@ -27,21 +20,7 @@ type Variables = {
   redirectPath?: string | false;
 };
 
-export type UseLogoutLegacyProps<TVariables> = {
-  v3LegacyAuthProviderCompatible: true;
-  mutationOptions?: Omit<
-    UseMutationOptions<
-      TLogoutData,
-      Error | RefineError,
-      (TVariables & Variables) | void,
-      unknown
-    >,
-    "mutationFn" | "onError" | "onSuccess"
-  >;
-};
-
 export type UseLogoutProps<TVariables> = {
-  v3LegacyAuthProviderCompatible?: false;
   mutationOptions?: Omit<
     UseMutationOptions<
       AuthActionResponse,
@@ -53,26 +32,6 @@ export type UseLogoutProps<TVariables> = {
   >;
 };
 
-export type UseLogoutCombinedProps<TVariables> = {
-  v3LegacyAuthProviderCompatible: boolean;
-  mutationOptions?: Omit<
-    UseMutationOptions<
-      AuthActionResponse | TLogoutData,
-      Error | RefineError,
-      (TVariables & Variables) | void,
-      unknown
-    >,
-    "mutationFn"
-  >;
-};
-
-export type UseLogoutLegacyReturnType<TVariables> = UseMutationResult<
-  TLogoutData,
-  Error | RefineError,
-  (TVariables & Variables) | void,
-  unknown
->;
-
 export type UseLogoutReturnType<TVariables> = UseMutationResult<
   AuthActionResponse,
   Error | RefineError,
@@ -80,25 +39,6 @@ export type UseLogoutReturnType<TVariables> = UseMutationResult<
   unknown
 >;
 
-export type UseLogoutCombinedReturnType<TVariables> = UseMutationResult<
-  AuthActionResponse | TLogoutData,
-  Error | RefineError,
-  (TVariables & Variables) | void,
-  unknown
->;
-
-export function useLogout<TVariables = {}>(
-  props: UseLogoutLegacyProps<TVariables>,
-): UseLogoutLegacyReturnType<TVariables>;
-
-export function useLogout<TVariables = {}>(
-  props?: UseLogoutProps<TVariables>,
-): UseLogoutReturnType<TVariables>;
-
-export function useLogout<TVariables = {}>(
-  props?: UseLogoutCombinedProps<TVariables>,
-): UseLogoutCombinedReturnType<TVariables>;
-
 /**
  * `useLogout` calls the `logout` method from the {@link https://refine.dev/docs/api-reference/core/providers/auth-provider `authProvider`} under the hood.
  *
@@ -106,19 +46,13 @@ export function useLogout<TVariables = {}>(
  *
  */
 export function useLogout<TVariables = {}>({
-  v3LegacyAuthProviderCompatible,
   mutationOptions,
-}: UseLogoutProps<TVariables> | UseLogoutLegacyProps<TVariables> = {}):
-  | UseLogoutLegacyReturnType<TVariables>
-  | UseLogoutReturnType<TVariables> {
+}: UseLogoutProps<TVariables> = {}): UseLogoutReturnType<TVariables> {
   const invalidateAuthStore = useInvalidateAuthStore();
-  const routerType = useRouterType();
   const go = useGo();
-  const { push } = useNavigation();
   const { open, close } = useNotification();
-  const { logout: legacyLogoutFromContext } = useLegacyAuthContext();
-  const { logout: logoutFromContext } = useAuthBindingsContext();
-  const { keys, preferLegacyKeys } = useKeys();
+  const { logout: logoutFromContext } = useAuthProviderContext();
+  const { keys } = useKeys();
 
   const mutation = useMutation<
     AuthActionResponse,
@@ -126,9 +60,10 @@ export function useLogout<TVariables = {}>({
     (TVariables & Variables) | void,
     unknown
   >({
-    mutationKey: keys().auth().action("logout").get(preferLegacyKeys),
+    mutationKey: keys().auth().action("logout").get(),
     mutationFn: logoutFromContext,
-    onSuccess: async (data, variables) => {
+    ...mutationOptions,
+    onSuccess: (data, variables) => {
       const { success, error, redirectTo, successNotification } = data;
       const { redirectPath } = variables ?? {};
 
@@ -147,75 +82,25 @@ export function useLogout<TVariables = {}>({
       }
 
       if (redirect !== false) {
-        if (routerType === "legacy") {
-          push(redirect ?? "/login");
-        } else {
-          if (redirect) {
-            go({ to: redirect });
-          }
-        }
-      }
-
-      await invalidateAuthStore();
-    },
-    onError: (error: any) => {
-      open?.(buildNotification(error));
-    },
-    ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
-    meta: {
-      ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions?.meta),
-      ...getXRay("useLogout", preferLegacyKeys),
-    },
-  });
-
-  const v3LegacyAuthProviderCompatibleMutation = useMutation<
-    TLogoutData,
-    Error | RefineError,
-    (TVariables & Variables) | void,
-    unknown
-  >({
-    mutationKey: [
-      ...keys().auth().action("logout").get(preferLegacyKeys),
-      "v3LegacyAuthProviderCompatible",
-    ],
-    mutationFn: legacyLogoutFromContext,
-    onSuccess: async (data, variables) => {
-      const redirectPath = variables?.redirectPath ?? data;
-
-      if (redirectPath === false) {
-        return;
-      }
-
-      if (redirectPath) {
-        if (routerType === "legacy") {
-          push(redirectPath);
-        } else {
-          go({ to: redirectPath });
+        if (redirect) {
+          go({ to: redirect });
         }
-        return;
-      }
-
-      if (routerType === "legacy") {
-        push("/login");
-      } else {
-        go({ to: "/login" });
       }
 
-      await invalidateAuthStore();
+      invalidateAuthStore();
     },
-    onError: (error: any) => {
+    onError: (error) => {
       open?.(buildNotification(error));
     },
-    ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
     meta: {
-      ...(v3LegacyAuthProviderCompatible ? mutationOptions?.meta : {}),
-      ...getXRay("useLogout", preferLegacyKeys),
+      ...mutationOptions?.meta,
+      ...getXRay("useLogout"),
     },
   });
 
-  return v3LegacyAuthProviderCompatible
-    ? v3LegacyAuthProviderCompatibleMutation
-    : mutation;
+  return {
+    ...mutation,
+  };
 }
 
 const buildNotification = (