@refinedev/core 4.58.0 → 5.0.1

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

@@ -1,53 +1,18 @@
 import { getXRay } from "@refinedev/devtools-internal";
 import { type UseMutationResult, useMutation } from "@tanstack/react-query";
 
-import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
-import { useGo, useLogout, useNavigation, useRouterType } from "@hooks";
+import { useAuthProviderContext } from "@contexts/auth";
+import { useGo, useLogout } from "@hooks";
 import { useKeys } from "@hooks/useKeys";
 
 import type { OnErrorResponse } from "../../../contexts/auth/types";
 
-export type UseOnErrorLegacyProps = {
-  v3LegacyAuthProviderCompatible: true;
-};
-
-export type UseOnErrorProps = {
-  v3LegacyAuthProviderCompatible?: false;
-};
-
-export type UseOnErrorCombinedProps = {
-  v3LegacyAuthProviderCompatible: boolean;
-};
-
-export type UseOnErrorLegacyReturnType = UseMutationResult<
-  void,
-  string | undefined,
-  any,
-  unknown
->;
-
 export type UseOnErrorReturnType = UseMutationResult<
   OnErrorResponse,
   unknown,
   unknown,
   unknown
 >;
-export type UseOnErrorCombinedReturnType = UseMutationResult<
-  OnErrorResponse | void,
-  unknown,
-  unknown,
-  unknown
->;
-
-export function useOnError(
-  props: UseOnErrorLegacyProps,
-): UseOnErrorLegacyReturnType;
-
-export function useOnError(props?: UseOnErrorProps): UseOnErrorReturnType;
-
-export function useOnError(
-  props?: UseOnErrorCombinedProps,
-): UseOnErrorCombinedReturnType;
 
 /**
  * `useOnError` calls the `checkError` method from the {@link https://refine.dev/docs/core/providers/auth-provider `authProvider`} under the hood.
@@ -55,29 +20,17 @@ export function useOnError(
  * @see {@link https://refine.dev/docs/api-reference/core/hooks/auth/useCheckError} for more details.
  *
  */
-export function useOnError({
-  v3LegacyAuthProviderCompatible = false,
-}: UseOnErrorProps | UseOnErrorLegacyProps = {}):
-  | UseOnErrorReturnType
-  | UseOnErrorLegacyReturnType {
-  const routerType = useRouterType();
+export function useOnError(): UseOnErrorReturnType {
   const go = useGo();
-  const { replace } = useNavigation();
 
-  const { checkError: legacyCheckErrorFromContext } = useLegacyAuthContext();
-  const { onError: onErrorFromContext } = useAuthBindingsContext();
+  const { onError: onErrorFromContext } = useAuthProviderContext();
 
-  const { keys, preferLegacyKeys } = useKeys();
+  const { keys } = useKeys();
 
-  const { mutate: legacyLogout } = useLogout({
-    v3LegacyAuthProviderCompatible: Boolean(v3LegacyAuthProviderCompatible),
-  });
-  const { mutate: logout } = useLogout({
-    v3LegacyAuthProviderCompatible: Boolean(v3LegacyAuthProviderCompatible),
-  });
+  const { mutate: logout } = useLogout();
 
   const mutation = useMutation<OnErrorResponse, unknown, unknown, unknown>({
-    mutationKey: keys().auth().action("onError").get(preferLegacyKeys),
+    mutationKey: keys().auth().action("onError").get(),
     ...(onErrorFromContext
       ? {
           mutationFn: onErrorFromContext,
@@ -88,11 +41,7 @@ export function useOnError({
             }
 
             if (redirectTo) {
-              if (routerType === "legacy") {
-                replace(redirectTo);
-              } else {
-                go({ to: redirectTo, type: "replace" });
-              }
+              go({ to: redirectTo, type: "replace" });
               return;
             }
           },
@@ -101,30 +50,11 @@ export function useOnError({
           mutationFn: () => ({}) as Promise<OnErrorResponse>,
         }),
     meta: {
-      ...getXRay("useOnError", preferLegacyKeys),
+      ...getXRay("useOnError"),
     },
   });
 
-  const v3LegacyAuthProviderCompatibleMutation = useMutation({
-    mutationKey: [
-      ...keys().auth().action("onError").get(preferLegacyKeys),
-      "v3LegacyAuthProviderCompatible",
-    ],
-    mutationFn: legacyCheckErrorFromContext,
-    onError: (redirectPath?: string) => {
-      legacyLogout({ redirectPath });
-    },
-    meta: {
-      ...getXRay("useOnError", preferLegacyKeys),
-    },
-  });
-
-  return v3LegacyAuthProviderCompatible
-    ? v3LegacyAuthProviderCompatibleMutation
-    : mutation;
+  return {
+    ...mutation,
+  };
 }
-
-/**
- * @deprecated `useCheckError` is deprecated with refine@4, use `useOnError` instead, however, we still support `useCheckError` for backward compatibility.
- */
-export const useCheckError = useOnError;

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

@@ -5,129 +5,52 @@ import {
   useQuery,
 } from "@tanstack/react-query";
 
-import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
+import { useAuthProviderContext } from "@contexts/auth";
 import { useKeys } from "@hooks/useKeys";
-
 import type { PermissionResponse } from "../../../contexts/auth/types";
 
-export type UsePermissionsLegacyProps<
-  TData = any,
-  TParams extends Record<string, any> = Record<string, any>,
-> = {
-  v3LegacyAuthProviderCompatible: true;
-  options?: UseQueryOptions<TData>;
-  params?: TParams;
-};
-
 export type UsePermissionsProps<
   TData = PermissionResponse,
   TParams extends Record<string, any> = Record<string, any>,
 > = {
-  v3LegacyAuthProviderCompatible?: false;
   options?: UseQueryOptions<TData>;
   params?: TParams;
 };
-
-export type UsePermissionsCombinedProps<
-  TData = any,
-  TParams extends Record<string, any> = Record<string, any>,
-> = {
-  v3LegacyAuthProviderCompatible: boolean;
-  options?: UseQueryOptions<TData> | UseQueryOptions<PermissionResponse>;
-  params?: TParams;
-};
-
-export type UsePermissionsLegacyReturnType<TData = any> = UseQueryResult<
-  TData,
-  unknown
->;
-
 export type UsePermissionsReturnType<TData = PermissionResponse> =
   UseQueryResult<TData, unknown>;
 
-export type UsePermissionsCombinedReturnType<TData = any> =
-  | UseQueryResult<TData, unknown>
-  | UseQueryResult<PermissionResponse, unknown>;
-
-export function usePermissions<
-  TData = any,
-  TParams extends Record<string, any> = Record<string, any>,
->(
-  props: UsePermissionsLegacyProps<TData, TParams>,
-): UsePermissionsLegacyReturnType<TData>;
-
-export function usePermissions<
-  TData = PermissionResponse,
-  TParams extends Record<string, any> = Record<string, any>,
->(props?: UsePermissionsProps<TData, TParams>): UsePermissionsReturnType<TData>;
-
-export function usePermissions<
-  TData = any,
-  TParams extends Record<string, any> = Record<string, any>,
->(
-  props?: UsePermissionsCombinedProps<TData, TParams>,
-): UsePermissionsCombinedReturnType<TData>;
-
 /**
- * `usePermissions` calls the `getPermissions` method from the {@link https://refine.dev/docs/core/providers/auth-provider `authProvider`} under the hood.
+ * `usePermissions` calls `getPermissions` method from {@link https://refine.dev/docs/api-reference/core/providers/auth-provider `authProvider`} under the hood.
  *
  * @see {@link https://refine.dev/docs/api-reference/core/hooks/auth/usePermissions} for more details.
  *
  * @typeParam TData - Result data of the query
  *
- * @typeParam TParams - Params will be passed to the `getPermissions` method of {@link https://refine.dev/docs/core/providers/auth-provider `authProvider`}.
- *
  */
 export function usePermissions<
   TData = any,
   TParams extends Record<string, any> = Record<string, any>,
 >({
-  v3LegacyAuthProviderCompatible = false,
   options,
   params,
-}:
-  | UsePermissionsProps<TData, TParams>
-  | UsePermissionsLegacyProps<TData, TParams> = {}):
-  | UsePermissionsReturnType
-  | UsePermissionsLegacyReturnType<TData> {
-  const { getPermissions: legacyGetPermission } = useLegacyAuthContext();
-  const { getPermissions } = useAuthBindingsContext();
-  const { keys, preferLegacyKeys } = useKeys();
+}: UsePermissionsProps<TData, TParams>): UsePermissionsReturnType<TData> {
+  const { getPermissions } = useAuthProviderContext();
+  const { keys } = useKeys();
 
   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.
+    queryKey: keys().auth().action("permissions").get(),
     queryFn: (getPermissions
       ? () => getPermissions(params)
       : () => Promise.resolve(undefined)) as (
       params?: unknown,
     ) => Promise<TData>,
-    enabled: !v3LegacyAuthProviderCompatible && !!getPermissions,
-    ...(v3LegacyAuthProviderCompatible ? {} : options),
-    meta: {
-      ...(v3LegacyAuthProviderCompatible ? {} : options?.meta),
-      ...getXRay("usePermissions", preferLegacyKeys),
-    },
-  });
-
-  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.
-    queryFn: (legacyGetPermission
-      ? () => legacyGetPermission(params)
-      : () => Promise.resolve(undefined)) as (
-      params?: unknown,
-    ) => Promise<TData>,
-    enabled: v3LegacyAuthProviderCompatible && !!legacyGetPermission,
-    ...(v3LegacyAuthProviderCompatible ? options : {}),
+    enabled: !!getPermissions,
+    ...options,
     meta: {
-      ...(v3LegacyAuthProviderCompatible ? options?.meta : {}),
-      ...getXRay("usePermissions", preferLegacyKeys),
+      ...options?.meta,
+      ...getXRay("usePermissions"),
     },
   });
 
-  return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
+  return queryResponse;
 }

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

@@ -5,35 +5,18 @@ 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, useNavigation, useNotification } from "@hooks";
 
 import type {
   AuthActionResponse,
   SuccessNotificationResponse,
-  TLoginData,
-  TRegisterData,
 } from "../../../contexts/auth/types";
 import type { RefineError } from "../../../contexts/data/types";
 import type { OpenNotificationParams } from "../../../contexts/notification/types";
 import { useInvalidateAuthStore } from "../useInvalidateAuthStore";
 
-export type UseRegisterLegacyProps<TVariables> = {
-  v3LegacyAuthProviderCompatible: true;
-  mutationOptions?: Omit<
-    UseMutationOptions<TRegisterData, Error | RefineError, TVariables, unknown>,
-    "mutationFn" | "onError" | "onSuccess"
-  >;
-};
-
 export type UseRegisterProps<TVariables> = {
-  v3LegacyAuthProviderCompatible?: false;
   mutationOptions?: Omit<
     UseMutationOptions<
       AuthActionResponse,
@@ -45,26 +28,6 @@ export type UseRegisterProps<TVariables> = {
   >;
 };
 
-export type UseRegisterCombinedProps<TVariables> = {
-  v3LegacyAuthProviderCompatible: boolean;
-  mutationOptions?: Omit<
-    UseMutationOptions<
-      AuthActionResponse | TRegisterData,
-      Error | RefineError,
-      TVariables,
-      unknown
-    >,
-    "mutationFn"
-  >;
-};
-
-export type UseRegisterLegacyReturnType<TVariables> = UseMutationResult<
-  TRegisterData,
-  Error | RefineError,
-  TVariables,
-  unknown
->;
-
 export type UseRegisterReturnType<TVariables> = UseMutationResult<
   AuthActionResponse,
   Error | RefineError,
@@ -72,49 +35,22 @@ export type UseRegisterReturnType<TVariables> = UseMutationResult<
   unknown
 >;
 
-export type UseRegisterCombinedReturnType<TVariables> = UseMutationResult<
-  AuthActionResponse | TLoginData,
-  Error | RefineError,
-  TVariables,
-  unknown
->;
-
-export function useRegister<TVariables = {}>(
-  props: UseRegisterLegacyProps<TVariables>,
-): UseRegisterLegacyReturnType<TVariables>;
-
-export function useRegister<TVariables = {}>(
-  props?: UseRegisterProps<TVariables>,
-): UseRegisterReturnType<TVariables>;
-
-export function useRegister<TVariables = {}>(
-  props?: UseRegisterCombinedProps<TVariables>,
-): UseRegisterCombinedReturnType<TVariables>;
-
 /**
  * `useRegister` calls `register` method from {@link https://refine.dev/docs/api-reference/core/providers/auth-provider `authProvider`} under the hood.
  *
  * @see {@link https://refine.dev/docs/api-reference/core/hooks/auth/useRegister} for more details.
  *
- * @typeParam TData - Result data of the query
  * @typeParam TVariables - Values for mutation function. default `{}`
  *
  */
 export function useRegister<TVariables = {}>({
-  v3LegacyAuthProviderCompatible,
   mutationOptions,
-}: UseRegisterProps<TVariables> | UseRegisterLegacyProps<TVariables> = {}):
-  | UseRegisterReturnType<TVariables>
-  | UseRegisterLegacyReturnType<TVariables> {
+}: UseRegisterProps<TVariables> = {}): UseRegisterReturnType<TVariables> {
   const invalidateAuthStore = useInvalidateAuthStore();
-  const routerType = useRouterType();
   const go = useGo();
-  const { replace } = useNavigation();
-  const { register: legacyRegisterFromContext } = useLegacyAuthContext();
-  const { register: registerFromContext } = useAuthBindingsContext();
   const { close, open } = useNotification();
-
-  const { keys, preferLegacyKeys } = useKeys();
+  const { register: registerFromContext } = useAuthProviderContext();
+  const { keys } = useKeys();
 
   const mutation = useMutation<
     AuthActionResponse,
@@ -122,8 +58,9 @@ export function useRegister<TVariables = {}>({
     TVariables,
     unknown
   >({
-    mutationKey: keys().auth().action("register").get(preferLegacyKeys),
+    mutationKey: keys().auth().action("register").get(),
     mutationFn: registerFromContext,
+
     onSuccess: async ({ success, redirectTo, error, successNotification }) => {
       if (success) {
         close?.("register-error");
@@ -131,8 +68,6 @@ export function useRegister<TVariables = {}>({
         if (successNotification) {
           open?.(buildSuccessNotification(successNotification));
         }
-
-        await invalidateAuthStore();
       }
 
       if (error || !success) {
@@ -140,72 +75,28 @@ export function useRegister<TVariables = {}>({
       }
 
       if (redirectTo) {
-        if (routerType === "legacy") {
-          replace(redirectTo);
-        } else {
-          go({ to: redirectTo, type: "replace" });
-        }
-      } else {
-        if (routerType === "legacy") {
-          replace("/");
-        }
+        go({ to: redirectTo, type: "replace" });
       }
-    },
-    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",
-    ],
-    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 {
-            go({ to: "/", type: "replace" });
-          }
-        }
-
-        await invalidateAuthStore();
 
-        close?.("register-error");
+      if (success) {
+        setTimeout(() => {
+          invalidateAuthStore();
+        }, 32);
       }
     },
     onError: (error: any) => {
       open?.(buildNotification(error));
     },
-    ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+    ...mutationOptions,
     meta: {
-      ...(v3LegacyAuthProviderCompatible ? mutationOptions?.meta : {}),
-      ...getXRay("useRegister", preferLegacyKeys),
+      ...mutationOptions?.meta,
+      ...getXRay("useRegister"),
     },
   });
 
-  return v3LegacyAuthProviderCompatible
-    ? v3LegacyAuthProviderCompatibleMutation
-    : mutation;
+  return {
+    ...mutation,
+  };
 }
 
 const buildNotification = (