@refinedev/core 4.0.0

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

@@ -0,0 +1,110 @@
+import { useMutation, UseMutationResult } from "@tanstack/react-query";
+
+import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
+import { OnErrorResponse } from "../../../interfaces";
+import { useGo, useLogout, useNavigation, useRouterType } from "@hooks";
+
+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.
+ *
+ * @see {@link https://refine.dev/docs/core/hooks/auth/useCheckError} for more details.
+ *
+ */
+export function useOnError({
+    v3LegacyAuthProviderCompatible = false,
+}: UseOnErrorProps | UseOnErrorLegacyProps = {}):
+    | UseOnErrorReturnType
+    | UseOnErrorLegacyReturnType {
+    const routerType = useRouterType();
+    const go = useGo();
+    const { replace } = useNavigation();
+
+    const { checkError: legacyCheckErrorFromContext } = useLegacyAuthContext();
+    const { onError: onErrorFromContext } = useAuthBindingsContext();
+
+    const { mutate: legacyLogout } = useLogout({
+        v3LegacyAuthProviderCompatible: Boolean(v3LegacyAuthProviderCompatible),
+    });
+    const { mutate: logout } = useLogout({
+        v3LegacyAuthProviderCompatible: Boolean(v3LegacyAuthProviderCompatible),
+    });
+
+    const mutation = useMutation(["useCheckError"], 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;
+            }
+        },
+    });
+
+    const v3LegacyAuthProviderCompatibleMutation = useMutation(
+        ["useCheckError", "v3LegacyAuthProviderCompatible"],
+        legacyCheckErrorFromContext,
+        {
+            onError: (redirectPath?: string) => {
+                legacyLogout({ redirectPath });
+            },
+        },
+    );
+
+    return v3LegacyAuthProviderCompatible
+        ? v3LegacyAuthProviderCompatibleMutation
+        : 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

@@ -0,0 +1,87 @@
+import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
+import { PermissionResponse } from "../../../interfaces";
+import {
+    useQuery,
+    UseQueryResult,
+    UseQueryOptions,
+} from "@tanstack/react-query";
+
+export type UsePermissionsLegacyProps<TData = any> = {
+    v3LegacyAuthProviderCompatible: true;
+    options?: UseQueryOptions<TData>;
+};
+
+export type UsePermissionsProps<TData = PermissionResponse> = {
+    v3LegacyAuthProviderCompatible?: false;
+    options?: UseQueryOptions<TData>;
+};
+
+export type UsePermissionsCombinedProps<TData = any> = {
+    v3LegacyAuthProviderCompatible: boolean;
+    options?: UseQueryOptions<TData> | UseQueryOptions<PermissionResponse>;
+};
+
+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>(
+    props: UsePermissionsLegacyProps<TData>,
+): UsePermissionsLegacyReturnType<TData>;
+
+export function usePermissions<TData = PermissionResponse>(
+    props?: UsePermissionsProps<TData>,
+): UsePermissionsReturnType<TData>;
+
+export function usePermissions<TData = any>(
+    props?: UsePermissionsCombinedProps<TData>,
+): UsePermissionsCombinedReturnType<TData>;
+
+/**
+ * `usePermissions` calls the `getPermissions` 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/usePermissions} for more details.
+ *
+ * @typeParam TData - Result data of the query
+ *
+ */
+export function usePermissions<TData = any>({
+    v3LegacyAuthProviderCompatible = false,
+    options,
+}: UsePermissionsProps<TData> | UsePermissionsLegacyProps<TData> = {}):
+    | UsePermissionsReturnType
+    | UsePermissionsLegacyReturnType<TData> {
+    const { getPermissions: legacyGetPermission } = useLegacyAuthContext();
+    const { getPermissions } = useAuthBindingsContext();
+
+    const queryResponse = useQuery<TData>(
+        ["usePermissions"],
+        // 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.
+        (getPermissions as (params?: unknown) => Promise<TData>) ??
+            (() => Promise.resolve(undefined)),
+        {
+            enabled: !v3LegacyAuthProviderCompatible && !!getPermissions,
+            ...(v3LegacyAuthProviderCompatible ? {} : options),
+        },
+    );
+
+    const legacyQueryResponse = useQuery<TData>(
+        ["usePermissions", "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.
+        legacyGetPermission ?? (() => Promise.resolve(undefined)),
+        {
+            enabled: v3LegacyAuthProviderCompatible && !!legacyGetPermission,
+            ...(v3LegacyAuthProviderCompatible ? options : {}),
+        },
+    );
+
+    return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
+}

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

@@ -0,0 +1,186 @@
+import {
+    useMutation,
+    UseMutationOptions,
+    UseMutationResult,
+} from "@tanstack/react-query";
+
+import { useNavigation, useRouterType, useGo, useNotification } from "@hooks";
+import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
+
+import {
+    AuthActionResponse,
+    OpenNotificationParams,
+    TLoginData,
+    TRegisterData,
+} from "../../../interfaces";
+import { useInvalidateAuthStore } from "../useInvaliteAuthStore";
+
+export type UseRegisterLegacyProps<TVariables> = {
+    v3LegacyAuthProviderCompatible: true;
+    mutationOptions?: Omit<
+        UseMutationOptions<TRegisterData, Error, TVariables, unknown>,
+        "mutationFn" | "onError" | "onSuccess"
+    >;
+};
+
+export type UseRegisterProps<TVariables> = {
+    v3LegacyAuthProviderCompatible?: false;
+    mutationOptions?: Omit<
+        UseMutationOptions<AuthActionResponse, Error, TVariables, unknown>,
+        "mutationFn"
+    >;
+};
+
+export type UseRegisterCombinedProps<TVariables> = {
+    v3LegacyAuthProviderCompatible: boolean;
+    mutationOptions?: Omit<
+        UseMutationOptions<
+            AuthActionResponse | TRegisterData,
+            Error,
+            TVariables,
+            unknown
+        >,
+        "mutationFn"
+    >;
+};
+
+export type UseRegisterLegacyReturnType<TVariables> = UseMutationResult<
+    TRegisterData,
+    Error,
+    TVariables,
+    unknown
+>;
+
+export type UseRegisterReturnType<TVariables> = UseMutationResult<
+    AuthActionResponse,
+    Error,
+    TVariables,
+    unknown
+>;
+
+export type UseRegisterCombinedReturnType<TVariables> = UseMutationResult<
+    AuthActionResponse | TLoginData,
+    Error,
+    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-references/providers/auth-provider `authProvider`} under the hood.
+ *
+ * @see {@link https://refine.dev/docs/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> {
+    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 mutation = useMutation<
+        AuthActionResponse,
+        Error,
+        TVariables,
+        unknown
+    >(["useRegister"], registerFromContext, {
+        onSuccess: ({ success, redirectTo, error }) => {
+            if (success) {
+                close?.("register-error");
+            }
+
+            if (error || !success) {
+                open?.(buildNotification(error));
+            }
+
+            if (redirectTo) {
+                if (routerType === "legacy") {
+                    replace(redirectTo);
+                } else {
+                    go({ to: redirectTo, type: "replace" });
+                }
+            } else {
+                if (routerType === "legacy") {
+                    replace("/");
+                }
+            }
+
+            invalidateAuthStore();
+        },
+        onError: (error: any) => {
+            open?.(buildNotification(error));
+        },
+        ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
+    });
+
+    const v3LegacyAuthProviderCompatibleMutation = useMutation<
+        TRegisterData,
+        Error,
+        TVariables,
+        unknown
+    >(
+        ["useRegister", "v3LegacyAuthProviderCompatible"],
+        legacyRegisterFromContext,
+        {
+            onSuccess: (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" });
+                        }
+                    }
+                    close?.("register-error");
+                }
+
+                invalidateAuthStore();
+            },
+            onError: (error: any) => {
+                open?.(buildNotification(error));
+            },
+            ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+        },
+    );
+
+    return v3LegacyAuthProviderCompatible
+        ? v3LegacyAuthProviderCompatibleMutation
+        : mutation;
+}
+
+const buildNotification = (error?: Error): OpenNotificationParams => {
+    return {
+        message: error?.name || "Register Error",
+        description: error?.message || "Error while registering",
+        key: "register-error",
+        type: "error",
+    };
+};

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

@@ -0,0 +1,215 @@
+import React from "react";
+import {
+    useMutation,
+    UseMutationOptions,
+    UseMutationResult,
+} from "@tanstack/react-query";
+import qs from "qs";
+
+import {
+    useNavigation,
+    useRouterType,
+    useGo,
+    useParsed,
+    useNotification,
+    useRouterContext,
+} from "@hooks";
+import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
+import {
+    AuthActionResponse,
+    OpenNotificationParams,
+    TUpdatePasswordData,
+    UpdatePasswordFormTypes,
+} from "../../../interfaces";
+
+export type UseUpdatePasswordLegacyProps<
+    TVariables extends UpdatePasswordFormTypes,
+> = {
+    v3LegacyAuthProviderCompatible: true;
+    mutationOptions?: Omit<
+        UseMutationOptions<TUpdatePasswordData, Error, TVariables, unknown>,
+        "mutationFn" | "onError" | "onSuccess"
+    >;
+};
+
+export type UseUpdatePasswordProps<TVariables extends UpdatePasswordFormTypes> =
+    {
+        v3LegacyAuthProviderCompatible?: false;
+        mutationOptions?: Omit<
+            UseMutationOptions<AuthActionResponse, Error, TVariables, unknown>,
+            "mutationFn"
+        >;
+    };
+
+export type UseUpdatePasswordCombinedProps<
+    TVariables extends UpdatePasswordFormTypes,
+> = {
+    v3LegacyAuthProviderCompatible: boolean;
+    mutationOptions?: Omit<
+        UseMutationOptions<
+            AuthActionResponse | TUpdatePasswordData,
+            Error,
+            TVariables,
+            unknown
+        >,
+        "mutationFn"
+    >;
+};
+
+export type UseUpdatePasswordLegacyReturnType<
+    TVariables extends UpdatePasswordFormTypes,
+> = UseMutationResult<TUpdatePasswordData, Error, TVariables, unknown>;
+
+export type UseUpdatePasswordReturnType<
+    TVariables extends UpdatePasswordFormTypes,
+> = UseMutationResult<AuthActionResponse, Error, TVariables, unknown>;
+
+export type UseUpdatePasswordCombinedReturnType<
+    TVariables extends UpdatePasswordFormTypes,
+> = UseMutationResult<
+    AuthActionResponse | TUpdatePasswordData,
+    Error,
+    TVariables,
+    unknown
+>;
+
+export function useUpdatePassword<TVariables extends UpdatePasswordFormTypes>(
+    props: UseUpdatePasswordLegacyProps<TVariables>,
+): UseUpdatePasswordLegacyReturnType<TVariables>;
+
+export function useUpdatePassword<TVariables extends UpdatePasswordFormTypes>(
+    props?: UseUpdatePasswordProps<TVariables>,
+): UseUpdatePasswordReturnType<TVariables>;
+
+export function useUpdatePassword<TVariables extends UpdatePasswordFormTypes>(
+    props?: UseUpdatePasswordCombinedProps<TVariables>,
+): UseUpdatePasswordCombinedReturnType<TVariables>;
+
+/**
+ * `useUpdatePassword` calls `updatePassword` 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/useUpdatePassword} for more details.
+ *
+ * @typeParam TData - Result data of the query
+ * @typeParam TVariables - Values for mutation function. default `{}`
+ *
+ */
+export function useUpdatePassword<
+    TVariables extends UpdatePasswordFormTypes = {},
+>({
+    v3LegacyAuthProviderCompatible,
+    mutationOptions,
+}:
+    | UseUpdatePasswordProps<TVariables>
+    | UseUpdatePasswordLegacyProps<TVariables> = {}):
+    | UseUpdatePasswordReturnType<TVariables>
+    | UseUpdatePasswordLegacyReturnType<TVariables> {
+    const routerType = useRouterType();
+
+    const go = useGo();
+    const { replace } = useNavigation();
+    const { updatePassword: legacyUpdatePasswordFromContext } =
+        useLegacyAuthContext();
+    const { updatePassword: updatePasswordFromContext } =
+        useAuthBindingsContext();
+    const { close, open } = useNotification();
+
+    const parsed = useParsed();
+    const { useLocation } = useRouterContext();
+    const { search } = useLocation();
+
+    const params = React.useMemo(() => {
+        if (routerType === "legacy") {
+            const queryStrings = qs.parse(search, {
+                ignoreQueryPrefix: true,
+            });
+            return queryStrings ?? {};
+        } else {
+            return parsed.params ?? {};
+        }
+    }, [search, parsed, routerType]);
+
+    const mutation = useMutation<
+        AuthActionResponse,
+        Error,
+        TVariables,
+        unknown
+    >(
+        ["useUpdatePassword"],
+        async (variables) => {
+            return updatePasswordFromContext?.({
+                ...params,
+                ...variables,
+            }) as Promise<AuthActionResponse>;
+        },
+        {
+            onSuccess: ({ success, redirectTo, error }) => {
+                if (success) {
+                    close?.("update-password-error");
+                }
+
+                if (error || !success) {
+                    open?.(buildNotification(error));
+                }
+
+                if (redirectTo) {
+                    if (routerType === "legacy") {
+                        replace(redirectTo);
+                    } else {
+                        go({ to: redirectTo, type: "replace" });
+                    }
+                }
+            },
+            onError: (error: any) => {
+                open?.(buildNotification(error));
+            },
+            ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
+        },
+    );
+
+    const v3LegacyAuthProviderCompatibleMutation = useMutation<
+        TUpdatePasswordData,
+        Error,
+        TVariables,
+        unknown
+    >(
+        ["useUpdatePassword", "v3LegacyAuthProviderCompatible"],
+        async (variables) => {
+            return legacyUpdatePasswordFromContext?.({
+                ...params,
+                ...variables,
+            });
+        },
+        {
+            onSuccess: (redirectPathFromAuth) => {
+                if (redirectPathFromAuth !== false) {
+                    if (redirectPathFromAuth) {
+                        if (routerType === "legacy") {
+                            replace(redirectPathFromAuth);
+                        } else {
+                            go({ to: redirectPathFromAuth, type: "replace" });
+                        }
+                    }
+                }
+                close?.("update-password-error");
+            },
+            onError: (error: any) => {
+                open?.(buildNotification(error));
+            },
+            ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+        },
+    );
+
+    return v3LegacyAuthProviderCompatible
+        ? v3LegacyAuthProviderCompatibleMutation
+        : mutation;
+}
+
+const buildNotification = (error?: Error): OpenNotificationParams => {
+    return {
+        message: error?.name || "Update Password Error",
+        description: error?.message || "Error while updating password",
+        key: "update-password-error",
+        type: "error",
+    };
+};