@refinedev/core 4.47.2 → 4.48.0

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

@@ -1,16 +1,16 @@
 import {
-    useMutation,
-    UseMutationOptions,
-    UseMutationResult,
+  useMutation,
+  UseMutationOptions,
+  UseMutationResult,
 } from "@tanstack/react-query";
 import { getXRay } from "@refinedev/devtools-internal";
 
 import { useGo, useNavigation, useNotification, useRouterType } from "@hooks";
 import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
 import {
-    RefineError,
-    OpenNotificationParams,
-    TLogoutData,
+  RefineError,
+  OpenNotificationParams,
+  TLogoutData,
 } from "../../../interfaces";
 import { AuthActionResponse } from "src/interfaces/bindings/auth";
 import { SuccessNotificationResponse } from "src/interfaces/bindings/auth";
@@ -18,79 +18,79 @@ import { useInvalidateAuthStore } from "../useInvalidateAuthStore";
 import { useKeys } from "@hooks/useKeys";
 
 type Variables = {
-    redirectPath?: string | false;
+  redirectPath?: string | false;
 };
 
 export type UseLogoutLegacyProps<TVariables> = {
-    v3LegacyAuthProviderCompatible: true;
-    mutationOptions?: Omit<
-        UseMutationOptions<
-            TLogoutData,
-            Error | RefineError,
-            (TVariables & Variables) | void,
-            unknown
-        >,
-        "mutationFn" | "onError" | "onSuccess"
-    >;
+  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,
-            Error | RefineError,
-            (TVariables & Variables) | void,
-            unknown
-        >,
-        "mutationFn"
-    >;
+  v3LegacyAuthProviderCompatible?: false;
+  mutationOptions?: Omit<
+    UseMutationOptions<
+      AuthActionResponse,
+      Error | RefineError,
+      (TVariables & Variables) | void,
+      unknown
+    >,
+    "mutationFn"
+  >;
 };
 
 export type UseLogoutCombinedProps<TVariables> = {
-    v3LegacyAuthProviderCompatible: boolean;
-    mutationOptions?: Omit<
-        UseMutationOptions<
-            AuthActionResponse | TLogoutData,
-            Error | RefineError,
-            (TVariables & Variables) | void,
-            unknown
-        >,
-        "mutationFn"
-    >;
+  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
+  TLogoutData,
+  Error | RefineError,
+  (TVariables & Variables) | void,
+  unknown
 >;
 
 export type UseLogoutReturnType<TVariables> = UseMutationResult<
-    AuthActionResponse,
-    Error | RefineError,
-    (TVariables & Variables) | void,
-    unknown
+  AuthActionResponse,
+  Error | RefineError,
+  (TVariables & Variables) | void,
+  unknown
 >;
 
 export type UseLogoutCombinedReturnType<TVariables> = UseMutationResult<
-    AuthActionResponse | TLogoutData,
-    Error | RefineError,
-    (TVariables & Variables) | void,
-    unknown
+  AuthActionResponse | TLogoutData,
+  Error | RefineError,
+  (TVariables & Variables) | void,
+  unknown
 >;
 
 export function useLogout<TVariables = {}>(
-    props: UseLogoutLegacyProps<TVariables>,
+  props: UseLogoutLegacyProps<TVariables>,
 ): UseLogoutLegacyReturnType<TVariables>;
 
 export function useLogout<TVariables = {}>(
-    props?: UseLogoutProps<TVariables>,
+  props?: UseLogoutProps<TVariables>,
 ): UseLogoutReturnType<TVariables>;
 
 export function useLogout<TVariables = {}>(
-    props?: UseLogoutCombinedProps<TVariables>,
+  props?: UseLogoutCombinedProps<TVariables>,
 ): UseLogoutCombinedReturnType<TVariables>;
 
 /**
@@ -100,138 +100,136 @@ export function useLogout<TVariables = {}>(
  *
  */
 export function useLogout<TVariables = {}>({
-    v3LegacyAuthProviderCompatible,
-    mutationOptions,
+  v3LegacyAuthProviderCompatible,
+  mutationOptions,
 }: UseLogoutProps<TVariables> | UseLogoutLegacyProps<TVariables> = {}):
-    | UseLogoutLegacyReturnType<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 mutation = useMutation<
-        AuthActionResponse,
-        Error | RefineError,
-        (TVariables & Variables) | void,
-        unknown
-    >({
-        mutationKey: keys().auth().action("logout").get(preferLegacyKeys),
-        mutationFn: logoutFromContext,
-        onSuccess: async (data, variables) => {
-            const { success, error, redirectTo, successNotification } = data;
-            const { redirectPath } = variables ?? {};
-
-            const redirect = redirectPath ?? redirectTo;
-
-            if (success) {
-                close?.("useLogout-error");
-
-                if (successNotification) {
-                    open?.(buildSuccessNotification(successNotification));
-                }
-            }
-
-            if (error || !success) {
-                open?.(buildNotification(error));
-            }
-
-            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 });
-                }
-                return;
-            }
-
-            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
-        : mutation;
+  | UseLogoutLegacyReturnType<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 mutation = useMutation<
+    AuthActionResponse,
+    Error | RefineError,
+    (TVariables & Variables) | void,
+    unknown
+  >({
+    mutationKey: keys().auth().action("logout").get(preferLegacyKeys),
+    mutationFn: logoutFromContext,
+    onSuccess: async (data, variables) => {
+      const { success, error, redirectTo, successNotification } = data;
+      const { redirectPath } = variables ?? {};
+
+      const redirect = redirectPath ?? redirectTo;
+
+      if (success) {
+        close?.("useLogout-error");
+
+        if (successNotification) {
+          open?.(buildSuccessNotification(successNotification));
+        }
+      }
+
+      if (error || !success) {
+        open?.(buildNotification(error));
+      }
+
+      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 });
+        }
+        return;
+      }
+
+      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
+    : mutation;
 }
 
 const buildNotification = (
-    error?: Error | RefineError,
+  error?: Error | RefineError,
 ): OpenNotificationParams => {
-    return {
-        key: "useLogout-error",
-        type: "error",
-        message: error?.name || "Logout Error",
-        description: error?.message || "Something went wrong during logout",
-    };
+  return {
+    key: "useLogout-error",
+    type: "error",
+    message: error?.name || "Logout Error",
+    description: error?.message || "Something went wrong during logout",
+  };
 };
 
 const buildSuccessNotification = (
-    successNotification: SuccessNotificationResponse,
+  successNotification: SuccessNotificationResponse,
 ): OpenNotificationParams => {
-    return {
-        message: successNotification.message,
-        description: successNotification.description,
-        key: "logout-success",
-        type: "success",
-    };
+  return {
+    message: successNotification.message,
+    description: successNotification.description,
+    key: "logout-success",
+    type: "success",
+  };
 };

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

@@ -7,45 +7,45 @@ import { useGo, useLogout, useNavigation, useRouterType } from "@hooks";
 import { useKeys } from "@hooks/useKeys";
 
 export type UseOnErrorLegacyProps = {
-    v3LegacyAuthProviderCompatible: true;
+  v3LegacyAuthProviderCompatible: true;
 };
 
 export type UseOnErrorProps = {
-    v3LegacyAuthProviderCompatible?: false;
+  v3LegacyAuthProviderCompatible?: false;
 };
 
 export type UseOnErrorCombinedProps = {
-    v3LegacyAuthProviderCompatible: boolean;
+  v3LegacyAuthProviderCompatible: boolean;
 };
 
 export type UseOnErrorLegacyReturnType = UseMutationResult<
-    void,
-    string | undefined,
-    any,
-    unknown
+  void,
+  string | undefined,
+  any,
+  unknown
 >;
 
 export type UseOnErrorReturnType = UseMutationResult<
-    OnErrorResponse,
-    unknown,
-    unknown,
-    unknown
+  OnErrorResponse,
+  unknown,
+  unknown,
+  unknown
 >;
 export type UseOnErrorCombinedReturnType = UseMutationResult<
-    OnErrorResponse | void,
-    unknown,
-    unknown,
-    unknown
+  OnErrorResponse | void,
+  unknown,
+  unknown,
+  unknown
 >;
 
 export function useOnError(
-    props: UseOnErrorLegacyProps,
+  props: UseOnErrorLegacyProps,
 ): UseOnErrorLegacyReturnType;
 
 export function useOnError(props?: UseOnErrorProps): UseOnErrorReturnType;
 
 export function useOnError(
-    props?: UseOnErrorCombinedProps,
+  props?: UseOnErrorCombinedProps,
 ): UseOnErrorCombinedReturnType;
 
 /**
@@ -55,66 +55,66 @@ export function useOnError(
  *
  */
 export function useOnError({
-    v3LegacyAuthProviderCompatible = false,
+  v3LegacyAuthProviderCompatible = false,
 }: UseOnErrorProps | UseOnErrorLegacyProps = {}):
-    | UseOnErrorReturnType
-    | UseOnErrorLegacyReturnType {
-    const routerType = useRouterType();
-    const go = useGo();
-    const { replace } = useNavigation();
-
-    const { checkError: legacyCheckErrorFromContext } = useLegacyAuthContext();
-    const { onError: onErrorFromContext } = useAuthBindingsContext();
-
-    const { keys, preferLegacyKeys } = useKeys();
-
-    const { mutate: legacyLogout } = useLogout({
-        v3LegacyAuthProviderCompatible: Boolean(v3LegacyAuthProviderCompatible),
-    });
-    const { mutate: logout } = useLogout({
-        v3LegacyAuthProviderCompatible: Boolean(v3LegacyAuthProviderCompatible),
-    });
-
-    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" });
-                }
-                return;
-            }
-        },
-        meta: {
-            ...getXRay("useOnError", preferLegacyKeys),
-        },
-    });
-
-    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;
+  | UseOnErrorReturnType
+  | UseOnErrorLegacyReturnType {
+  const routerType = useRouterType();
+  const go = useGo();
+  const { replace } = useNavigation();
+
+  const { checkError: legacyCheckErrorFromContext } = useLegacyAuthContext();
+  const { onError: onErrorFromContext } = useAuthBindingsContext();
+
+  const { keys, preferLegacyKeys } = useKeys();
+
+  const { mutate: legacyLogout } = useLogout({
+    v3LegacyAuthProviderCompatible: Boolean(v3LegacyAuthProviderCompatible),
+  });
+  const { mutate: logout } = useLogout({
+    v3LegacyAuthProviderCompatible: Boolean(v3LegacyAuthProviderCompatible),
+  });
+
+  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" });
+        }
+        return;
+      }
+    },
+    meta: {
+      ...getXRay("useOnError", preferLegacyKeys),
+    },
+  });
+
+  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;
 }
 
 /**