@refinedev/core 4.47.2 → 4.49.0

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

@@ -1,92 +1,97 @@
+import { getXRay } from "@refinedev/devtools-internal";
 import {
-    useMutation,
-    UseMutationOptions,
-    UseMutationResult,
+  UseMutationOptions,
+  UseMutationResult,
+  useMutation,
 } from "@tanstack/react-query";
-import { getXRay } from "@refinedev/devtools-internal";
 
-import { useGo, useNavigation, useNotification, useRouterType } from "@hooks";
 import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
-import { SuccessNotificationResponse } from "src/interfaces/bindings/auth";
+import {
+  useGo,
+  useKeys,
+  useNavigation,
+  useNotification,
+  useRouterType,
+} from "@hooks";
 
 import {
-    AuthActionResponse,
-    RefineError,
-    OpenNotificationParams,
-    TForgotPasswordData,
-} from "../../../interfaces";
-import { useKeys } from "@hooks/useKeys";
+  AuthActionResponse,
+  SuccessNotificationResponse,
+  TForgotPasswordData,
+} from "../../../contexts/auth/types";
+import { RefineError } from "../../../contexts/data/types";
+import { OpenNotificationParams } from "../../../contexts/notification/types";
 
 export type UseForgotPasswordLegacyProps<TVariables> = {
-    v3LegacyAuthProviderCompatible: true;
-    mutationOptions?: Omit<
-        UseMutationOptions<
-            TForgotPasswordData,
-            Error | RefineError,
-            TVariables,
-            unknown
-        >,
-        "mutationFn" | "onError" | "onSuccess"
-    >;
+  v3LegacyAuthProviderCompatible: true;
+  mutationOptions?: Omit<
+    UseMutationOptions<
+      TForgotPasswordData,
+      Error | RefineError,
+      TVariables,
+      unknown
+    >,
+    "mutationFn" | "onError" | "onSuccess"
+  >;
 };
 
 export type UseForgotPasswordProps<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 UseForgotPasswordCombinedProps<TVariables> = {
-    v3LegacyAuthProviderCompatible: boolean;
-    mutationOptions?: Omit<
-        UseMutationOptions<
-            AuthActionResponse | TForgotPasswordData,
-            Error | RefineError,
-            TVariables,
-            unknown
-        >,
-        "mutationFn"
-    >;
+  v3LegacyAuthProviderCompatible: boolean;
+  mutationOptions?: Omit<
+    UseMutationOptions<
+      AuthActionResponse | TForgotPasswordData,
+      Error | RefineError,
+      TVariables,
+      unknown
+    >,
+    "mutationFn"
+  >;
 };
 
 export type UseForgotPasswordLegacyReturnType<TVariables> = UseMutationResult<
-    TForgotPasswordData,
-    Error | RefineError,
-    TVariables,
-    unknown
+  TForgotPasswordData,
+  Error | RefineError,
+  TVariables,
+  unknown
 >;
 
 export type UseForgotPasswordReturnType<TVariables> = UseMutationResult<
-    AuthActionResponse,
-    Error | RefineError,
-    TVariables,
-    unknown
+  AuthActionResponse,
+  Error | RefineError,
+  TVariables,
+  unknown
 >;
 
 export type UseForgotPasswordCombinedReturnType<TVariables> = UseMutationResult<
-    AuthActionResponse | TForgotPasswordData,
-    Error | RefineError,
-    TVariables,
-    unknown
+  AuthActionResponse | TForgotPasswordData,
+  Error | RefineError,
+  TVariables,
+  unknown
 >;
 
 export function useForgotPassword<TVariables = {}>(
-    props: UseForgotPasswordLegacyProps<TVariables>,
+  props: UseForgotPasswordLegacyProps<TVariables>,
 ): UseForgotPasswordLegacyReturnType<TVariables>;
 
 export function useForgotPassword<TVariables = {}>(
-    props?: UseForgotPasswordProps<TVariables>,
+  props?: UseForgotPasswordProps<TVariables>,
 ): UseForgotPasswordReturnType<TVariables>;
 
 export function useForgotPassword<TVariables = {}>(
-    props?: UseForgotPasswordCombinedProps<TVariables>,
+  props?: UseForgotPasswordCombinedProps<TVariables>,
 ): UseForgotPasswordCombinedReturnType<TVariables>;
 
 /**
@@ -99,124 +104,119 @@ export function useForgotPassword<TVariables = {}>(
  *
  */
 export function useForgotPassword<TVariables = {}>({
-    v3LegacyAuthProviderCompatible,
-    mutationOptions,
+  v3LegacyAuthProviderCompatible,
+  mutationOptions,
 }:
-    | UseForgotPasswordProps<TVariables>
-    | UseForgotPasswordLegacyProps<TVariables> = {}):
-    | UseForgotPasswordReturnType<TVariables>
-    | UseForgotPasswordLegacyReturnType<TVariables> {
-    const routerType = useRouterType();
-    const go = useGo();
-    const { replace } = useNavigation();
-    const {
-        forgotPassword: v3LegacyAuthProviderCompatibleForgotPasswordFromContext,
-    } = useLegacyAuthContext();
-    const { forgotPassword: forgotPasswordFromContext } =
-        useAuthBindingsContext();
-    const { close, open } = useNotification();
-    const { keys, preferLegacyKeys } = useKeys();
-
-    const mutation = useMutation<
-        AuthActionResponse,
-        Error | RefineError,
-        TVariables,
-        unknown
-    >({
-        mutationKey: keys()
-            .auth()
-            .action("forgotPassword")
-            .get(preferLegacyKeys),
-        mutationFn: forgotPasswordFromContext,
-        onSuccess: ({ success, redirectTo, error, successNotification }) => {
-            if (success) {
-                close?.("forgot-password-error");
-
-                if (successNotification) {
-                    open?.(buildSuccessNotification(successNotification));
-                }
-            }
-
-            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),
-        meta: {
-            ...(v3LegacyAuthProviderCompatible === true
-                ? {}
-                : mutationOptions?.meta),
-            ...getXRay("useForgotPassword", preferLegacyKeys),
-        },
-    });
-
-    const v3LegacyAuthProviderCompatibleMutation = useMutation<
-        TForgotPasswordData,
-        Error | RefineError,
-        TVariables,
-        unknown
-    >({
-        mutationKey: [
-            ...keys().auth().action("forgotPassword").get(preferLegacyKeys),
-            "v3LegacyAuthProviderCompatible",
-        ],
-        mutationFn: v3LegacyAuthProviderCompatibleForgotPasswordFromContext,
-        onSuccess: (redirectPathFromAuth) => {
-            if (redirectPathFromAuth !== false) {
-                if (redirectPathFromAuth) {
-                    if (routerType === "legacy") {
-                        replace(redirectPathFromAuth);
-                    } else {
-                        go({ to: redirectPathFromAuth, type: "replace" });
-                    }
-                }
-            }
-            close?.("forgot-password-error");
-        },
-        onError: (error: any) => {
-            open?.(buildNotification(error));
-        },
-        ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
-        meta: {
-            ...(v3LegacyAuthProviderCompatible ? mutationOptions?.meta : {}),
-            ...getXRay("useForgotPassword", preferLegacyKeys),
-        },
-    });
-
-    return v3LegacyAuthProviderCompatible
-        ? v3LegacyAuthProviderCompatibleMutation
-        : mutation;
+  | UseForgotPasswordProps<TVariables>
+  | UseForgotPasswordLegacyProps<TVariables> = {}):
+  | UseForgotPasswordReturnType<TVariables>
+  | UseForgotPasswordLegacyReturnType<TVariables> {
+  const routerType = useRouterType();
+  const go = useGo();
+  const { replace } = useNavigation();
+  const {
+    forgotPassword: v3LegacyAuthProviderCompatibleForgotPasswordFromContext,
+  } = useLegacyAuthContext();
+  const { forgotPassword: forgotPasswordFromContext } =
+    useAuthBindingsContext();
+  const { close, open } = useNotification();
+  const { keys, preferLegacyKeys } = useKeys();
+
+  const mutation = useMutation<
+    AuthActionResponse,
+    Error | RefineError,
+    TVariables,
+    unknown
+  >({
+    mutationKey: keys().auth().action("forgotPassword").get(preferLegacyKeys),
+    mutationFn: forgotPasswordFromContext,
+    onSuccess: ({ success, redirectTo, error, successNotification }) => {
+      if (success) {
+        close?.("forgot-password-error");
+
+        if (successNotification) {
+          open?.(buildSuccessNotification(successNotification));
+        }
+      }
+
+      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),
+    meta: {
+      ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions?.meta),
+      ...getXRay("useForgotPassword", preferLegacyKeys),
+    },
+  });
+
+  const v3LegacyAuthProviderCompatibleMutation = useMutation<
+    TForgotPasswordData,
+    Error | RefineError,
+    TVariables,
+    unknown
+  >({
+    mutationKey: [
+      ...keys().auth().action("forgotPassword").get(preferLegacyKeys),
+      "v3LegacyAuthProviderCompatible",
+    ],
+    mutationFn: v3LegacyAuthProviderCompatibleForgotPasswordFromContext,
+    onSuccess: (redirectPathFromAuth) => {
+      if (redirectPathFromAuth !== false) {
+        if (redirectPathFromAuth) {
+          if (routerType === "legacy") {
+            replace(redirectPathFromAuth);
+          } else {
+            go({ to: redirectPathFromAuth, type: "replace" });
+          }
+        }
+      }
+      close?.("forgot-password-error");
+    },
+    onError: (error: any) => {
+      open?.(buildNotification(error));
+    },
+    ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+    meta: {
+      ...(v3LegacyAuthProviderCompatible ? mutationOptions?.meta : {}),
+      ...getXRay("useForgotPassword", preferLegacyKeys),
+    },
+  });
+
+  return v3LegacyAuthProviderCompatible
+    ? v3LegacyAuthProviderCompatibleMutation
+    : mutation;
 }
 
 const buildNotification = (
-    error?: Error | RefineError,
+  error?: Error | RefineError,
 ): OpenNotificationParams => {
-    return {
-        message: error?.name || "Forgot Password Error",
-        description: error?.message || "Error while resetting password",
-        key: "forgot-password-error",
-        type: "error",
-    };
+  return {
+    message: error?.name || "Forgot Password Error",
+    description: error?.message || "Error while resetting password",
+    key: "forgot-password-error",
+    type: "error",
+  };
 };
 
 const buildSuccessNotification = (
-    successNotification: SuccessNotificationResponse,
+  successNotification: SuccessNotificationResponse,
 ): OpenNotificationParams => {
-    return {
-        message: successNotification.message,
-        description: successNotification.description,
-        key: "forgot-password-success",
-        type: "success",
-    };
+  return {
+    message: successNotification.message,
+    description: successNotification.description,
+    key: "forgot-password-success",
+    type: "success",
+  };
 };

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

@@ -1,53 +1,54 @@
+import { getXRay } from "@refinedev/devtools-internal";
 import {
-    useQuery,
-    UseQueryResult,
-    UseQueryOptions,
+  UseQueryOptions,
+  UseQueryResult,
+  useQuery,
 } from "@tanstack/react-query";
-import { getXRay } from "@refinedev/devtools-internal";
 
 import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
-import { IdentityResponse } from "../../../interfaces";
 import { useKeys } from "@hooks/useKeys";
 
+import { IdentityResponse } from "../../../contexts/auth/types";
+
 export type UseGetIdentityLegacyProps<TData> = {
-    v3LegacyAuthProviderCompatible: true;
-    queryOptions?: UseQueryOptions<TData>;
+  v3LegacyAuthProviderCompatible: true;
+  queryOptions?: UseQueryOptions<TData>;
 };
 
 export type UseGetIdentityProps<TData = IdentityResponse> = {
-    v3LegacyAuthProviderCompatible?: false;
-    queryOptions?: UseQueryOptions<TData>;
+  v3LegacyAuthProviderCompatible?: false;
+  queryOptions?: UseQueryOptions<TData>;
 };
 
 export type UseGetIdentityCombinedProps<TData = any> = {
-    v3LegacyAuthProviderCompatible: boolean;
-    queryOptions?: UseQueryOptions<TData> | UseQueryOptions<IdentityResponse>;
+  v3LegacyAuthProviderCompatible: boolean;
+  queryOptions?: UseQueryOptions<TData> | UseQueryOptions<IdentityResponse>;
 };
 
 export type UseGetIdentityLegacyReturnType<TData> = UseQueryResult<
-    TData,
-    unknown
+  TData,
+  unknown
 >;
 
 export type UseGetIdentityReturnType<TData = IdentityResponse> = UseQueryResult<
-    TData,
-    unknown
+  TData,
+  unknown
 >;
 
 export type UsePermissionsCombinedReturnType<TData = any> =
-    | UseQueryResult<TData, unknown>
-    | UseQueryResult<IdentityResponse, unknown>;
+  | UseQueryResult<TData, unknown>
+  | UseQueryResult<IdentityResponse, unknown>;
 
 export function useGetIdentity<TData = any>(
-    props: UseGetIdentityLegacyProps<TData>,
+  props: UseGetIdentityLegacyProps<TData>,
 ): UseGetIdentityLegacyReturnType<TData>;
 
 export function useGetIdentity<TData = IdentityResponse>(
-    props?: UseGetIdentityProps<TData>,
+  props?: UseGetIdentityProps<TData>,
 ): UseGetIdentityReturnType<TData>;
 
 export function useGetIdentity<TData = any>(
-    props?: UseGetIdentityCombinedProps<TData>,
+  props?: UseGetIdentityCombinedProps<TData>,
 ): UsePermissionsCombinedReturnType<TData>;
 
 /**
@@ -59,47 +60,45 @@ export function useGetIdentity<TData = any>(
  *
  */
 export function useGetIdentity<TData = any>({
-    v3LegacyAuthProviderCompatible = false,
-    queryOptions,
+  v3LegacyAuthProviderCompatible = false,
+  queryOptions,
 }: UseGetIdentityProps<TData> | UseGetIdentityLegacyProps<TData> = {}):
-    | UseGetIdentityReturnType<TData>
-    | UseGetIdentityLegacyReturnType<TData> {
-    const { getUserIdentity: legacyGetUserIdentity } = useLegacyAuthContext();
-    const { getIdentity } = useAuthBindingsContext();
-    const { keys, preferLegacyKeys } = useKeys();
+  | UseGetIdentityReturnType<TData>
+  | UseGetIdentityLegacyReturnType<TData> {
+  const { getUserIdentity: legacyGetUserIdentity } = useLegacyAuthContext();
+  const { getIdentity } = useAuthBindingsContext();
+  const { keys, preferLegacyKeys } = useKeys();
 
-    const queryResponse = useQuery<TData>({
-        queryKey: keys().auth().action("identity").get(preferLegacyKeys),
-        // 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.
-        queryFn:
-            (getIdentity as (params?: unknown) => Promise<TData>) ??
-            (() => Promise.resolve({})),
-        enabled: !v3LegacyAuthProviderCompatible && !!getIdentity,
-        retry: false,
-        ...(v3LegacyAuthProviderCompatible === true ? {} : queryOptions),
-        meta: {
-            ...(v3LegacyAuthProviderCompatible === true
-                ? {}
-                : queryOptions?.meta),
-            ...getXRay("useGetIdentity", preferLegacyKeys),
-        },
-    });
+  const queryResponse = useQuery<TData>({
+    queryKey: keys().auth().action("identity").get(preferLegacyKeys),
+    // 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.
+    queryFn:
+      (getIdentity as (params?: unknown) => Promise<TData>) ??
+      (() => Promise.resolve({})),
+    enabled: !v3LegacyAuthProviderCompatible && !!getIdentity,
+    retry: false,
+    ...(v3LegacyAuthProviderCompatible === true ? {} : queryOptions),
+    meta: {
+      ...(v3LegacyAuthProviderCompatible === true ? {} : queryOptions?.meta),
+      ...getXRay("useGetIdentity", preferLegacyKeys),
+    },
+  });
 
-    const legacyQueryResponse = useQuery<TData>({
-        queryKey: [
-            ...keys().auth().action("identity").get(preferLegacyKeys),
-            "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.
-        queryFn: legacyGetUserIdentity ?? (() => Promise.resolve({})),
-        enabled: v3LegacyAuthProviderCompatible && !!legacyGetUserIdentity,
-        retry: false,
-        ...(v3LegacyAuthProviderCompatible ? queryOptions : {}),
-        meta: {
-            ...(v3LegacyAuthProviderCompatible ? queryOptions?.meta : {}),
-            ...getXRay("useGetIdentity", preferLegacyKeys),
-        },
-    });
+  const legacyQueryResponse = useQuery<TData>({
+    queryKey: [
+      ...keys().auth().action("identity").get(preferLegacyKeys),
+      "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.
+    queryFn: legacyGetUserIdentity ?? (() => Promise.resolve({})),
+    enabled: v3LegacyAuthProviderCompatible && !!legacyGetUserIdentity,
+    retry: false,
+    ...(v3LegacyAuthProviderCompatible ? queryOptions : {}),
+    meta: {
+      ...(v3LegacyAuthProviderCompatible ? queryOptions?.meta : {}),
+      ...getXRay("useGetIdentity", preferLegacyKeys),
+    },
+  });
 
-    return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
+  return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
 }

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

@@ -2,18 +2,18 @@ import { useKeys } from "@hooks/useKeys";
 import { useQueryClient } from "@tanstack/react-query";
 
 export const useInvalidateAuthStore = () => {
-    const queryClient = useQueryClient();
-    const { keys, preferLegacyKeys } = useKeys();
+  const queryClient = useQueryClient();
+  const { keys, preferLegacyKeys } = useKeys();
 
-    const invalidate = async () => {
-        await Promise.all(
-            (["check", "identity", "permissions"] as const).map((action) =>
-                queryClient.invalidateQueries(
-                    keys().auth().action(action).get(preferLegacyKeys),
-                ),
-            ),
-        );
-    };
+  const invalidate = async () => {
+    await Promise.all(
+      (["check", "identity", "permissions"] as const).map((action) =>
+        queryClient.invalidateQueries(
+          keys().auth().action(action).get(preferLegacyKeys),
+        ),
+      ),
+    );
+  };
 
-    return invalidate;
+  return invalidate;
 };