@refinedev/core 4.47.2 → 4.48.0

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

@@ -6,18 +6,18 @@ import { CheckResponse } from "../../../interfaces";
 import { useKeys } from "@hooks/useKeys";
 
 export type UseIsAuthenticatedLegacyProps = {
-    v3LegacyAuthProviderCompatible: true;
-    params?: any;
+  v3LegacyAuthProviderCompatible: true;
+  params?: any;
 };
 
 export type UseIsAuthenticatedProps = {
-    v3LegacyAuthProviderCompatible?: false;
-    params?: any;
+  v3LegacyAuthProviderCompatible?: false;
+  params?: any;
 };
 
 export type UseIsAuthenticatedCombinedProps = {
-    v3LegacyAuthProviderCompatible: boolean;
-    params?: any;
+  v3LegacyAuthProviderCompatible: boolean;
+  params?: any;
 };
 
 export type UseIsAuthenticatedLegacyReturnType = UseQueryResult<any, any>;
@@ -25,20 +25,20 @@ export type UseIsAuthenticatedLegacyReturnType = UseQueryResult<any, any>;
 export type UseIsAuthenticatedReturnType = UseQueryResult<CheckResponse, any>;
 
 export type UseIsAuthenticatedCombinedReturnType = UseQueryResult<
-    CheckResponse | any,
-    any
+  CheckResponse | any,
+  any
 >;
 
 export function useIsAuthenticated(
-    props: UseIsAuthenticatedLegacyProps,
+  props: UseIsAuthenticatedLegacyProps,
 ): UseIsAuthenticatedLegacyReturnType;
 
 export function useIsAuthenticated(
-    props?: UseIsAuthenticatedProps,
+  props?: UseIsAuthenticatedProps,
 ): UseIsAuthenticatedReturnType;
 
 export function useIsAuthenticated(
-    props?: UseIsAuthenticatedCombinedProps,
+  props?: UseIsAuthenticatedCombinedProps,
 ): UseIsAuthenticatedCombinedReturnType;
 
 /**
@@ -47,47 +47,43 @@ export function useIsAuthenticated(
  * @see {@link https://refine.dev/docs/api-reference/core/hooks/auth/useAuthenticated} for more details.
  */
 export function useIsAuthenticated({
-    v3LegacyAuthProviderCompatible = false,
-    params,
+  v3LegacyAuthProviderCompatible = false,
+  params,
 }: UseIsAuthenticatedProps | UseIsAuthenticatedLegacyProps = {}):
-    | UseIsAuthenticatedReturnType
-    | UseIsAuthenticatedLegacyReturnType {
-    const { checkAuth } = useLegacyAuthContext();
-    const { check } = useAuthBindingsContext();
-    const { keys, preferLegacyKeys } = useKeys();
+  | 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),
-        },
-    });
+  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({
-        queryKey: [
-            ...keys()
-                .auth()
-                .action("check")
-                .params(params)
-                .get(preferLegacyKeys),
-            "v3LegacyAuthProviderCompatible",
-        ],
-        queryFn: async () => (await checkAuth?.(params)) ?? {},
-        retry: false,
-        enabled: v3LegacyAuthProviderCompatible,
-        meta: {
-            ...getXRay("useIsAuthenticated", preferLegacyKeys),
-        },
-    });
+  const legacyQueryResponse = useQuery({
+    queryKey: [
+      ...keys().auth().action("check").params(params).get(preferLegacyKeys),
+      "v3LegacyAuthProviderCompatible",
+    ],
+    queryFn: async () => (await checkAuth?.(params)) ?? {},
+    retry: false,
+    enabled: v3LegacyAuthProviderCompatible,
+    meta: {
+      ...getXRay("useIsAuthenticated", preferLegacyKeys),
+    },
+  });
 
-    return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
+  return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
 }
 
 /**

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

@@ -5,8 +5,8 @@ import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
  * @internal
  */
 export const useIsExistAuthentication = (): boolean => {
-    const { isProvided: legacyIsProvided } = useLegacyAuthContext();
-    const { isProvided } = useAuthBindingsContext();
+  const { isProvided: legacyIsProvided } = useLegacyAuthContext();
+  const { isProvided } = useAuthBindingsContext();
 
-    return Boolean(isProvided || legacyIsProvided);
+  return Boolean(isProvided || legacyIsProvided);
 };

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

@@ -1,26 +1,26 @@
 import React from "react";
 import {
-    useMutation,
-    UseMutationOptions,
-    UseMutationResult,
+  useMutation,
+  UseMutationOptions,
+  UseMutationResult,
 } from "@tanstack/react-query";
 import { getXRay } from "@refinedev/devtools-internal";
 import qs from "qs";
 
 import {
-    useNavigation,
-    useRouterContext,
-    useNotification,
-    useRouterType,
-    useParsed,
-    useGo,
+  useNavigation,
+  useRouterContext,
+  useNotification,
+  useRouterType,
+  useParsed,
+  useGo,
 } from "@hooks";
 import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
 
 import {
-    RefineError,
-    OpenNotificationParams,
-    TLoginData,
+  RefineError,
+  OpenNotificationParams,
+  TLoginData,
 } from "../../../interfaces";
 import { AuthActionResponse } from "src/interfaces/bindings/auth";
 import { SuccessNotificationResponse } from "src/interfaces/bindings/auth";
@@ -28,75 +28,70 @@ import { useInvalidateAuthStore } from "../useInvalidateAuthStore";
 import { useKeys } from "@hooks/useKeys";
 
 export type UseLoginLegacyProps<TVariables> = {
-    v3LegacyAuthProviderCompatible: true;
-    mutationOptions?: Omit<
-        UseMutationOptions<
-            TLoginData,
-            Error | RefineError,
-            TVariables,
-            unknown
-        >,
-        "mutationFn" | "onError" | "onSuccess"
-    >;
+  v3LegacyAuthProviderCompatible: true;
+  mutationOptions?: Omit<
+    UseMutationOptions<TLoginData, Error | RefineError, TVariables, unknown>,
+    "mutationFn" | "onError" | "onSuccess"
+  >;
 };
 
 export type UseLoginProps<TVariables> = {
-    v3LegacyAuthProviderCompatible?: false;
-    mutationOptions?: Omit<
-        UseMutationOptions<
-            AuthActionResponse,
-            Error | RefineError,
-            TVariables,
-            unknown
-        >,
-        "mutationFn"
-    >;
+  v3LegacyAuthProviderCompatible?: false;
+  mutationOptions?: Omit<
+    UseMutationOptions<
+      AuthActionResponse,
+      Error | RefineError,
+      TVariables,
+      unknown
+    >,
+    "mutationFn"
+  >;
 };
 
 export type UseLoginCombinedProps<TVariables> = {
-    v3LegacyAuthProviderCompatible: boolean;
-    mutationOptions?: Omit<
-        UseMutationOptions<
-            AuthActionResponse | TLoginData,
-            Error | RefineError,
-            TVariables,
-            unknown
-        >,
-        "mutationFn"
-    >;
+  v3LegacyAuthProviderCompatible: boolean;
+  mutationOptions?: Omit<
+    UseMutationOptions<
+      AuthActionResponse | TLoginData,
+      Error | RefineError,
+      TVariables,
+      unknown
+    >,
+    "mutationFn"
+  >;
 };
 
 export type UseLoginLegacyReturnType<TVariables> = UseMutationResult<
-    TLoginData,
-    Error | RefineError,
-    TVariables,
-    unknown
+  TLoginData,
+  Error | RefineError,
+  TVariables,
+  unknown
 >;
 
 export type UseLoginReturnType<TVariables> = UseMutationResult<
-    AuthActionResponse,
-    Error | RefineError,
-    TVariables,
-    unknown
+  AuthActionResponse,
+  Error | RefineError,
+  TVariables,
+  unknown
 >;
 
 export type UseLoginCombinedReturnType<TVariables> = UseMutationResult<
-    AuthActionResponse | TLoginData,
-    Error | RefineError,
-    TVariables,
-    unknown
+  AuthActionResponse | TLoginData,
+  Error | RefineError,
+  TVariables,
+  unknown
 >;
 
 export function useLogin<TVariables = {}>(
-    props: UseLoginLegacyProps<TVariables>,
+  props: UseLoginLegacyProps<TVariables>,
 ): UseLoginLegacyReturnType<TVariables>;
 
 export function useLogin<TVariables = {}>(
-    props?: UseLoginProps<TVariables>,
+  props?: UseLoginProps<TVariables>,
 ): UseLoginReturnType<TVariables>;
 
 export function useLogin<TVariables = {}>(
-    props?: UseLoginCombinedProps<TVariables>,
+  props?: UseLoginCombinedProps<TVariables>,
 ): UseLoginCombinedReturnType<TVariables>;
 
 /**
@@ -109,165 +104,157 @@ export function useLogin<TVariables = {}>(
  *
  */
 export function useLogin<TVariables = {}>({
-    v3LegacyAuthProviderCompatible,
-    mutationOptions,
+  v3LegacyAuthProviderCompatible,
+  mutationOptions,
 }: UseLoginProps<TVariables> | UseLoginLegacyProps<TVariables> = {}):
-    | UseLoginLegacyReturnType<TVariables>
-    | UseLoginReturnType<TVariables> {
-    const invalidateAuthStore = useInvalidateAuthStore();
-    const routerType = useRouterType();
+  | UseLoginLegacyReturnType<TVariables>
+  | UseLoginReturnType<TVariables> {
+  const invalidateAuthStore = useInvalidateAuthStore();
+  const routerType = useRouterType();
 
-    const go = useGo();
-    const { replace } = useNavigation();
+  const go = useGo();
+  const { replace } = useNavigation();
 
-    const parsed = useParsed();
+  const parsed = useParsed();
 
-    const { useLocation } = useRouterContext();
-    const { search } = useLocation();
+  const { useLocation } = useRouterContext();
+  const { search } = useLocation();
 
-    const { close, open } = useNotification();
-    const { login: legacyLoginFromContext } = useLegacyAuthContext();
-    const { login: loginFromContext } = useAuthBindingsContext();
-    const { keys, preferLegacyKeys } = useKeys();
+  const { close, open } = useNotification();
+  const { login: legacyLoginFromContext } = useLegacyAuthContext();
+  const { login: loginFromContext } = useAuthBindingsContext();
+  const { keys, preferLegacyKeys } = useKeys();
 
-    const to = React.useMemo(() => {
-        if (routerType === "legacy") {
-            const legacySearch = qs.parse(search, {
-                ignoreQueryPrefix: true,
-            });
-            return legacySearch.to;
-        } else {
-            return parsed.params?.to;
-        }
-    }, [routerType, parsed.params, search]);
+  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 mutation = useMutation<
-        AuthActionResponse,
-        Error | RefineError,
-        TVariables,
-        unknown
-    >({
-        mutationKey: keys().auth().action("login").get(preferLegacyKeys),
-        mutationFn: loginFromContext,
-        onSuccess: async ({
-            success,
-            redirectTo,
-            error,
-            successNotification,
-        }) => {
-            if (success) {
-                close?.("login-error");
+  const mutation = useMutation<
+    AuthActionResponse,
+    Error | RefineError,
+    TVariables,
+    unknown
+  >({
+    mutationKey: keys().auth().action("login").get(preferLegacyKeys),
+    mutationFn: loginFromContext,
+    onSuccess: async ({ success, redirectTo, error, successNotification }) => {
+      if (success) {
+        close?.("login-error");
 
-                if (successNotification) {
-                    open?.(buildSuccessNotification(successNotification));
-                }
-            }
+        if (successNotification) {
+          open?.(buildSuccessNotification(successNotification));
+        }
+      }
 
-            if (error || !success) {
-                open?.(buildNotification(error));
-            }
+      if (error || !success) {
+        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 {
-                    go({ to: redirectTo, type: "replace" });
-                }
-            } else {
-                if (routerType === "legacy") {
-                    replace("/");
-                }
-            }
+      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 {
+          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("useLogin", preferLegacyKeys),
-        },
-    });
+      await invalidateAuthStore();
+    },
+    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);
-            }
+  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" });
-                    }
-                }
-            }
+      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" });
+          }
+        }
+      }
 
-            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
-        : mutation;
+  return v3LegacyAuthProviderCompatible
+    ? v3LegacyAuthProviderCompatibleMutation
+    : mutation;
 }
 
 const buildNotification = (
-    error?: Error | RefineError,
+  error?: Error | RefineError,
 ): OpenNotificationParams => {
-    return {
-        message: error?.name || "Login Error",
-        description: error?.message || "Invalid credentials",
-        key: "login-error",
-        type: "error",
-    };
+  return {
+    message: error?.name || "Login Error",
+    description: error?.message || "Invalid credentials",
+    key: "login-error",
+    type: "error",
+  };
 };
 
 const buildSuccessNotification = (
-    successNotification: SuccessNotificationResponse,
+  successNotification: SuccessNotificationResponse,
 ): OpenNotificationParams => {
-    return {
-        message: successNotification.message,
-        description: successNotification.description,
-        key: "login-success",
-        type: "success",
-    };
+  return {
+    message: successNotification.message,
+    description: successNotification.description,
+    key: "login-success",
+    type: "success",
+  };
 };