@refinedev/core 4.0.0

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

@@ -0,0 +1,92 @@
+import {
+    useQuery,
+    UseQueryResult,
+    UseQueryOptions,
+} from "@tanstack/react-query";
+
+import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
+import { IdentityResponse } from "../../../interfaces";
+
+export type UseGetIdentityLegacyProps<TData> = {
+    v3LegacyAuthProviderCompatible: true;
+    queryOptions?: UseQueryOptions<TData>;
+};
+
+export type UseGetIdentityProps<TData = IdentityResponse> = {
+    v3LegacyAuthProviderCompatible?: false;
+    queryOptions?: UseQueryOptions<TData>;
+};
+
+export type UseGetIdentityCombinedProps<TData = any> = {
+    v3LegacyAuthProviderCompatible: boolean;
+    queryOptions?: UseQueryOptions<TData> | UseQueryOptions<IdentityResponse>;
+};
+
+export type UseGetIdentityLegacyReturnType<TData> = UseQueryResult<
+    TData,
+    unknown
+>;
+
+export type UseGetIdentityReturnType<TData = IdentityResponse> = UseQueryResult<
+    TData,
+    unknown
+>;
+
+export type UsePermissionsCombinedReturnType<TData = any> =
+    | UseQueryResult<TData, unknown>
+    | UseQueryResult<IdentityResponse, unknown>;
+
+export function useGetIdentity<TData = any>(
+    props: UseGetIdentityLegacyProps<TData>,
+): UseGetIdentityLegacyReturnType<TData>;
+
+export function useGetIdentity<TData = IdentityResponse>(
+    props?: UseGetIdentityProps<TData>,
+): UseGetIdentityReturnType<TData>;
+
+export function useGetIdentity<TData = any>(
+    props?: UseGetIdentityCombinedProps<TData>,
+): UsePermissionsCombinedReturnType<TData>;
+
+/**
+ * `useGetIdentity` calls the `getUserIdentity` method from the {@link https://refine.dev/docs/core/providers/auth-provider `authProvider`} under the hood.
+ *
+ * @see {@link https://refine.dev/docs/core/hooks/auth/useGetIdentity} for more details.
+ *
+ * @typeParam TData - Result data of the query
+ *
+ */
+export function useGetIdentity<TData = any>({
+    v3LegacyAuthProviderCompatible = false,
+    queryOptions,
+}: UseGetIdentityProps<TData> | UseGetIdentityLegacyProps<TData> = {}):
+    | UseGetIdentityReturnType<TData>
+    | UseGetIdentityLegacyReturnType<TData> {
+    const { getUserIdentity: legacyGetUserIdentity } = useLegacyAuthContext();
+    const { getIdentity } = useAuthBindingsContext();
+
+    const queryResponse = useQuery<TData>(
+        ["getUserIdentity"],
+        // Enabled check for `getIdentity` is enough to be sure that it's defined in the query function but TS is not smart enough to know that.
+        (getIdentity as (params?: unknown) => Promise<TData>) ??
+            (() => Promise.resolve({})),
+        {
+            enabled: !v3LegacyAuthProviderCompatible && !!getIdentity,
+            retry: false,
+            ...(v3LegacyAuthProviderCompatible === true ? {} : queryOptions),
+        },
+    );
+
+    const legacyQueryResponse = useQuery<TData>(
+        ["getUserIdentity", "v3LegacyAuthProviderCompatible"],
+        // Enabled check for `getUserIdentity` is enough to be sure that it's defined in the query function but TS is not smart enough to know that.
+        legacyGetUserIdentity ?? (() => Promise.resolve({})),
+        {
+            enabled: v3LegacyAuthProviderCompatible && !!legacyGetUserIdentity,
+            retry: false,
+            ...(v3LegacyAuthProviderCompatible ? queryOptions : {}),
+        },
+    );
+
+    return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
+}

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

@@ -0,0 +1,13 @@
+import { useQueryClient } from "@tanstack/react-query";
+
+export const useInvalidateAuthStore = () => {
+    const queryClient = useQueryClient();
+
+    const invalidate = () => {
+        queryClient.invalidateQueries(["useAuthenticated"]);
+        queryClient.invalidateQueries(["getUserIdentity"]);
+        queryClient.invalidateQueries(["usePermissions"]);
+    };
+
+    return invalidate;
+};

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

@@ -0,0 +1,80 @@
+import { useQuery, UseQueryResult } from "@tanstack/react-query";
+
+import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
+import { CheckResponse } from "../../../interfaces";
+
+export type UseIsAuthenticatedLegacyProps = {
+    v3LegacyAuthProviderCompatible: true;
+    params?: any;
+};
+
+export type UseIsAuthenticatedProps = {
+    v3LegacyAuthProviderCompatible?: false;
+    params?: any;
+};
+
+export type UseIsAuthenticatedCombinedProps = {
+    v3LegacyAuthProviderCompatible: boolean;
+    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.
+ *
+ * @see {@link https://refine.dev/docs/core/hooks/auth/useAuthenticated} for more details.
+ */
+export function useIsAuthenticated({
+    v3LegacyAuthProviderCompatible = false,
+    params,
+}: UseIsAuthenticatedProps | UseIsAuthenticatedLegacyProps = {}):
+    | UseIsAuthenticatedReturnType
+    | UseIsAuthenticatedLegacyReturnType {
+    const { checkAuth } = useLegacyAuthContext();
+    const { check } = useAuthBindingsContext();
+
+    const queryResponse = useQuery(
+        ["useAuthenticated", params],
+        async () => (await check?.(params)) ?? {},
+        {
+            retry: false,
+            enabled: !v3LegacyAuthProviderCompatible,
+        },
+    );
+
+    const legacyQueryResponse = useQuery(
+        ["useAuthenticated", "v3LegacyAuthProviderCompatible", params],
+        async () => (await checkAuth?.(params)) ?? {},
+        {
+            retry: false,
+            enabled: v3LegacyAuthProviderCompatible,
+        },
+    );
+
+    return v3LegacyAuthProviderCompatible ? legacyQueryResponse : 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

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

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

@@ -0,0 +1,220 @@
+import {
+    useMutation,
+    UseMutationOptions,
+    UseMutationResult,
+} from "@tanstack/react-query";
+import qs from "qs";
+
+import {
+    useNavigation,
+    useRouterContext,
+    useNotification,
+    useRouterType,
+    useParsed,
+    useGo,
+} from "@hooks";
+import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
+
+import { OpenNotificationParams, TLoginData } from "../../../interfaces";
+import { AuthActionResponse } from "src/interfaces/bindings/auth";
+import React from "react";
+import { useInvalidateAuthStore } from "../useInvaliteAuthStore";
+
+export type UseLoginLegacyProps<TVariables> = {
+    v3LegacyAuthProviderCompatible: true;
+    mutationOptions?: Omit<
+        UseMutationOptions<TLoginData, Error, TVariables, unknown>,
+        "mutationFn" | "onError" | "onSuccess"
+    >;
+};
+
+export type UseLoginProps<TVariables> = {
+    v3LegacyAuthProviderCompatible?: false;
+    mutationOptions?: Omit<
+        UseMutationOptions<AuthActionResponse, Error, TVariables, unknown>,
+        "mutationFn"
+    >;
+};
+
+export type UseLoginCombinedProps<TVariables> = {
+    v3LegacyAuthProviderCompatible: boolean;
+    mutationOptions?: Omit<
+        UseMutationOptions<
+            AuthActionResponse | TLoginData,
+            Error,
+            TVariables,
+            unknown
+        >,
+        "mutationFn"
+    >;
+};
+
+export type UseLoginLegacyReturnType<TVariables> = UseMutationResult<
+    TLoginData,
+    Error,
+    TVariables,
+    unknown
+>;
+
+export type UseLoginReturnType<TVariables> = UseMutationResult<
+    AuthActionResponse,
+    Error,
+    TVariables,
+    unknown
+>;
+
+export type UseLoginCombinedReturnType<TVariables> = UseMutationResult<
+    AuthActionResponse | TLoginData,
+    Error,
+    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-references/providers/auth-provider `authProvider`} under the hood.
+ *
+ * @see {@link https://refine.dev/docs/core/hooks/auth/useLogin} for more details.
+ *
+ * @typeParam TData - Result data of the query
+ * @typeParam TVariables - Values for mutation function. default `{}`
+ *
+ */
+export function useLogin<TVariables = {}>({
+    v3LegacyAuthProviderCompatible,
+    mutationOptions,
+}: UseLoginProps<TVariables> | UseLoginLegacyProps<TVariables> = {}):
+    | UseLoginLegacyReturnType<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 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 mutation = useMutation<
+        AuthActionResponse,
+        Error,
+        TVariables,
+        unknown
+    >(["useLogin"], loginFromContext, {
+        onSuccess: ({ success, redirectTo, error }) => {
+            if (success) {
+                close?.("login-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("/");
+                }
+            }
+
+            setTimeout(() => {
+                invalidateAuthStore();
+            });
+        },
+        onError: (error: any) => {
+            open?.(buildNotification(error));
+        },
+        ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
+    });
+
+    const v3LegacyAuthProviderCompatibleMutation = useMutation<
+        TLoginData,
+        Error,
+        TVariables,
+        unknown
+    >(["useLogin", "v3LegacyAuthProviderCompatible"], legacyLoginFromContext, {
+        onSuccess: (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" });
+                    }
+                }
+            }
+
+            close?.("login-error");
+
+            setTimeout(() => {
+                invalidateAuthStore();
+            });
+        },
+        onError: (error: any) => {
+            open?.(buildNotification(error));
+        },
+        ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+    });
+
+    return v3LegacyAuthProviderCompatible
+        ? v3LegacyAuthProviderCompatibleMutation
+        : mutation;
+}
+
+const buildNotification = (error?: Error): OpenNotificationParams => {
+    return {
+        message: error?.name || "Login Error",
+        description: error?.message || "Invalid credentials",
+        key: "login-error",
+        type: "error",
+    };
+};

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

@@ -0,0 +1,199 @@
+import {
+    useMutation,
+    UseMutationOptions,
+    UseMutationResult,
+} from "@tanstack/react-query";
+
+import { useGo, useNavigation, useNotification, useRouterType } from "@hooks";
+import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
+import { OpenNotificationParams, TLogoutData } from "../../../interfaces";
+import { AuthActionResponse } from "src/interfaces/bindings/auth";
+import { useInvalidateAuthStore } from "../useInvaliteAuthStore";
+
+type Variables = {
+    redirectPath?: string | false;
+};
+
+export type UseLogoutLegacyProps<TVariables> = {
+    v3LegacyAuthProviderCompatible: true;
+    mutationOptions?: Omit<
+        UseMutationOptions<
+            TLogoutData,
+            Error,
+            (TVariables & Variables) | void,
+            unknown
+        >,
+        "mutationFn" | "onError" | "onSuccess"
+    >;
+};
+
+export type UseLogoutProps<TVariables> = {
+    v3LegacyAuthProviderCompatible?: false;
+    mutationOptions?: Omit<
+        UseMutationOptions<
+            AuthActionResponse,
+            Error,
+            (TVariables & Variables) | void,
+            unknown
+        >,
+        "mutationFn"
+    >;
+};
+
+export type UseLogoutCombinedProps<TVariables> = {
+    v3LegacyAuthProviderCompatible: boolean;
+    mutationOptions?: Omit<
+        UseMutationOptions<
+            AuthActionResponse | TLogoutData,
+            Error,
+            (TVariables & Variables) | void,
+            unknown
+        >,
+        "mutationFn"
+    >;
+};
+
+export type UseLogoutLegacyReturnType<TVariables> = UseMutationResult<
+    TLogoutData,
+    Error,
+    (TVariables & Variables) | void,
+    unknown
+>;
+
+export type UseLogoutReturnType<TVariables> = UseMutationResult<
+    AuthActionResponse,
+    Error,
+    (TVariables & Variables) | void,
+    unknown
+>;
+
+export type UseLogoutCombinedReturnType<TVariables> = UseMutationResult<
+    AuthActionResponse | TLogoutData,
+    Error,
+    (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-references/providers/auth-provider `authProvider`} under the hood.
+ *
+ * @see {@link https://refine.dev/docs/core/hooks/auth/useLogout} for more details.
+ *
+ */
+export function useLogout<TVariables = {}>({
+    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 mutation = useMutation<
+        AuthActionResponse,
+        Error,
+        (TVariables & Variables) | void,
+        unknown
+    >(["useLogout"], logoutFromContext, {
+        onSuccess: (data, variables) => {
+            const { success, error, redirectTo } = data;
+            const { redirectPath } = variables ?? {};
+
+            const redirect = redirectPath ?? redirectTo;
+
+            if (success) {
+                close?.("useLogout-error");
+            }
+
+            if (error || !success) {
+                open?.(buildNotification(error));
+            }
+
+            if (redirect !== false) {
+                if (routerType === "legacy") {
+                    push(redirect ?? "/login");
+                } else {
+                    if (redirect) {
+                        go({ to: redirect });
+                    }
+                }
+            }
+
+            invalidateAuthStore();
+        },
+        onError: (error: any) => {
+            open?.(buildNotification(error));
+        },
+        ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
+    });
+
+    const v3LegacyAuthProviderCompatibleMutation = useMutation<
+        TLogoutData,
+        Error,
+        (TVariables & Variables) | void,
+        unknown
+    >(
+        ["useLogout", "v3LegacyAuthProviderCompatible"],
+        legacyLogoutFromContext,
+        {
+            onSuccess: (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" });
+                }
+
+                invalidateAuthStore();
+            },
+            onError: (error: any) => {
+                open?.(buildNotification(error));
+            },
+            ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+        },
+    );
+
+    return v3LegacyAuthProviderCompatible
+        ? v3LegacyAuthProviderCompatibleMutation
+        : mutation;
+}
+
+const buildNotification = (error?: Error): OpenNotificationParams => {
+    return {
+        key: "useLogout-error",
+        type: "error",
+        message: error?.name || "Logout Error",
+        description: error?.message || "Something went wrong during logout",
+    };
+};