@refinedev/core 4.47.2 → 4.48.0

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

@@ -1,7 +1,7 @@
 import {
-    useQuery,
-    UseQueryResult,
-    UseQueryOptions,
+  useQuery,
+  UseQueryResult,
+  UseQueryOptions,
 } from "@tanstack/react-query";
 import { getXRay } from "@refinedev/devtools-internal";
 
@@ -10,43 +10,62 @@ import { useKeys } from "@hooks/useKeys";
 import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
 import { PermissionResponse } from "../../../interfaces";
 
-export type UsePermissionsLegacyProps<TData = any> = {
-    v3LegacyAuthProviderCompatible: true;
-    options?: UseQueryOptions<TData>;
+export type UsePermissionsLegacyProps<
+  TData = any,
+  TParams extends Record<string, any> = Record<string, any>,
+> = {
+  v3LegacyAuthProviderCompatible: true;
+  options?: UseQueryOptions<TData>;
+  params?: TParams;
 };
 
-export type UsePermissionsProps<TData = PermissionResponse> = {
-    v3LegacyAuthProviderCompatible?: false;
-    options?: UseQueryOptions<TData>;
+export type UsePermissionsProps<
+  TData = PermissionResponse,
+  TParams extends Record<string, any> = Record<string, any>,
+> = {
+  v3LegacyAuthProviderCompatible?: false;
+  options?: UseQueryOptions<TData>;
+  params?: TParams;
 };
 
-export type UsePermissionsCombinedProps<TData = any> = {
-    v3LegacyAuthProviderCompatible: boolean;
-    options?: UseQueryOptions<TData> | UseQueryOptions<PermissionResponse>;
+export type UsePermissionsCombinedProps<
+  TData = any,
+  TParams extends Record<string, any> = Record<string, any>,
+> = {
+  v3LegacyAuthProviderCompatible: boolean;
+  options?: UseQueryOptions<TData> | UseQueryOptions<PermissionResponse>;
+  params?: TParams;
 };
 
 export type UsePermissionsLegacyReturnType<TData = any> = UseQueryResult<
-    TData,
-    unknown
+  TData,
+  unknown
 >;
 
 export type UsePermissionsReturnType<TData = PermissionResponse> =
-    UseQueryResult<TData, unknown>;
+  UseQueryResult<TData, unknown>;
 
 export type UsePermissionsCombinedReturnType<TData = any> =
-    | UseQueryResult<TData, unknown>
-    | UseQueryResult<PermissionResponse, unknown>;
+  | UseQueryResult<TData, unknown>
+  | UseQueryResult<PermissionResponse, unknown>;
 
-export function usePermissions<TData = any>(
-    props: UsePermissionsLegacyProps<TData>,
+export function usePermissions<
+  TData = any,
+  TParams extends Record<string, any> = Record<string, any>,
+>(
+  props: UsePermissionsLegacyProps<TData, TParams>,
 ): UsePermissionsLegacyReturnType<TData>;
 
-export function usePermissions<TData = PermissionResponse>(
-    props?: UsePermissionsProps<TData>,
-): UsePermissionsReturnType<TData>;
+export function usePermissions<
+  TData = PermissionResponse,
+  TParams extends Record<string, any> = Record<string, any>,
+>(props?: UsePermissionsProps<TData, TParams>): UsePermissionsReturnType<TData>;
 
-export function usePermissions<TData = any>(
-    props?: UsePermissionsCombinedProps<TData>,
+export function usePermissions<
+  TData = any,
+  TParams extends Record<string, any> = Record<string, any>,
+>(
+  props?: UsePermissionsCombinedProps<TData, TParams>,
 ): UsePermissionsCombinedReturnType<TData>;
 
 /**
@@ -56,45 +75,59 @@ export function usePermissions<TData = any>(
  *
  * @typeParam TData - Result data of the query
  *
+ * @typeParam TParams - Params will be passed to the `getPermissions` method of {@link https://refine.dev/docs/core/providers/auth-provider `authProvider`}.
+ *
  */
-export function usePermissions<TData = any>({
-    v3LegacyAuthProviderCompatible = false,
-    options,
-}: UsePermissionsProps<TData> | UsePermissionsLegacyProps<TData> = {}):
-    | UsePermissionsReturnType
-    | UsePermissionsLegacyReturnType<TData> {
-    const { getPermissions: legacyGetPermission } = useLegacyAuthContext();
-    const { getPermissions } = useAuthBindingsContext();
-    const { keys, preferLegacyKeys } = useKeys();
+export function usePermissions<
+  TData = any,
+  TParams extends Record<string, any> = Record<string, any>,
+>({
+  v3LegacyAuthProviderCompatible = false,
+  options,
+  params,
+}:
+  | UsePermissionsProps<TData, TParams>
+  | UsePermissionsLegacyProps<TData, TParams> = {}):
+  | UsePermissionsReturnType
+  | UsePermissionsLegacyReturnType<TData> {
+  const { getPermissions: legacyGetPermission } = useLegacyAuthContext();
+  const { getPermissions } = useAuthBindingsContext();
+  const { keys, preferLegacyKeys } = useKeys();
 
-    const queryResponse = useQuery<TData>({
-        queryKey: keys().auth().action("permissions").get(preferLegacyKeys),
-        // 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.
-        queryFn:
-            (getPermissions as (params?: unknown) => Promise<TData>) ??
-            (() => Promise.resolve(undefined)),
-        enabled: !v3LegacyAuthProviderCompatible && !!getPermissions,
-        ...(v3LegacyAuthProviderCompatible ? {} : options),
-        meta: {
-            ...(v3LegacyAuthProviderCompatible ? {} : options?.meta),
-            ...getXRay("usePermissions", preferLegacyKeys),
-        },
-    });
+  const queryResponse = useQuery<TData>({
+    queryKey: keys().auth().action("permissions").get(preferLegacyKeys),
+    // 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.
+    queryFn: (getPermissions
+      ? () => getPermissions(params)
+      : () => Promise.resolve(undefined)) as (
+      params?: unknown,
+    ) => Promise<TData>,
+    enabled: !v3LegacyAuthProviderCompatible && !!getPermissions,
+    ...(v3LegacyAuthProviderCompatible ? {} : options),
+    meta: {
+      ...(v3LegacyAuthProviderCompatible ? {} : options?.meta),
+      ...getXRay("usePermissions", preferLegacyKeys),
+    },
+  });
 
-    const legacyQueryResponse = useQuery<TData>({
-        queryKey: [
-            ...keys().auth().action("permissions").get(preferLegacyKeys),
-            "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.
-        queryFn: legacyGetPermission ?? (() => Promise.resolve(undefined)),
-        enabled: v3LegacyAuthProviderCompatible && !!legacyGetPermission,
-        ...(v3LegacyAuthProviderCompatible ? options : {}),
-        meta: {
-            ...(v3LegacyAuthProviderCompatible ? options?.meta : {}),
-            ...getXRay("usePermissions", preferLegacyKeys),
-        },
-    });
+  const legacyQueryResponse = useQuery<TData>({
+    queryKey: [
+      ...keys().auth().action("permissions").get(preferLegacyKeys),
+      "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.
+    queryFn: (legacyGetPermission
+      ? () => legacyGetPermission(params)
+      : () => Promise.resolve(undefined)) as (
+      params?: unknown,
+    ) => Promise<TData>,
+    enabled: v3LegacyAuthProviderCompatible && !!legacyGetPermission,
+    ...(v3LegacyAuthProviderCompatible ? options : {}),
+    meta: {
+      ...(v3LegacyAuthProviderCompatible ? options?.meta : {}),
+      ...getXRay("usePermissions", preferLegacyKeys),
+    },
+  });
 
-    return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
+  return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
 }

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

@@ -1,7 +1,7 @@
 import {
-    useMutation,
-    UseMutationOptions,
-    UseMutationResult,
+  useMutation,
+  UseMutationOptions,
+  UseMutationResult,
 } from "@tanstack/react-query";
 import { getXRay } from "@refinedev/devtools-internal";
 
@@ -10,85 +10,80 @@ import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
 import { SuccessNotificationResponse } from "src/interfaces/bindings/auth";
 
 import {
-    AuthActionResponse,
-    RefineError,
-    OpenNotificationParams,
-    TLoginData,
-    TRegisterData,
+  AuthActionResponse,
+  RefineError,
+  OpenNotificationParams,
+  TLoginData,
+  TRegisterData,
 } from "../../../interfaces";
 import { useInvalidateAuthStore } from "../useInvalidateAuthStore";
 import { useKeys } from "@hooks/useKeys";
 
 export type UseRegisterLegacyProps<TVariables> = {
-    v3LegacyAuthProviderCompatible: true;
-    mutationOptions?: Omit<
-        UseMutationOptions<
-            TRegisterData,
-            Error | RefineError,
-            TVariables,
-            unknown
-        >,
-        "mutationFn" | "onError" | "onSuccess"
-    >;
+  v3LegacyAuthProviderCompatible: true;
+  mutationOptions?: Omit<
+    UseMutationOptions<TRegisterData, Error | RefineError, TVariables, unknown>,
+    "mutationFn" | "onError" | "onSuccess"
+  >;
 };
 
 export type UseRegisterProps<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 UseRegisterCombinedProps<TVariables> = {
-    v3LegacyAuthProviderCompatible: boolean;
-    mutationOptions?: Omit<
-        UseMutationOptions<
-            AuthActionResponse | TRegisterData,
-            Error | RefineError,
-            TVariables,
-            unknown
-        >,
-        "mutationFn"
-    >;
+  v3LegacyAuthProviderCompatible: boolean;
+  mutationOptions?: Omit<
+    UseMutationOptions<
+      AuthActionResponse | TRegisterData,
+      Error | RefineError,
+      TVariables,
+      unknown
+    >,
+    "mutationFn"
+  >;
 };
 
 export type UseRegisterLegacyReturnType<TVariables> = UseMutationResult<
-    TRegisterData,
-    Error | RefineError,
-    TVariables,
-    unknown
+  TRegisterData,
+  Error | RefineError,
+  TVariables,
+  unknown
 >;
 
 export type UseRegisterReturnType<TVariables> = UseMutationResult<
-    AuthActionResponse,
-    Error | RefineError,
-    TVariables,
-    unknown
+  AuthActionResponse,
+  Error | RefineError,
+  TVariables,
+  unknown
 >;
 
 export type UseRegisterCombinedReturnType<TVariables> = UseMutationResult<
-    AuthActionResponse | TLoginData,
-    Error | RefineError,
-    TVariables,
-    unknown
+  AuthActionResponse | TLoginData,
+  Error | RefineError,
+  TVariables,
+  unknown
 >;
 
 export function useRegister<TVariables = {}>(
-    props: UseRegisterLegacyProps<TVariables>,
+  props: UseRegisterLegacyProps<TVariables>,
 ): UseRegisterLegacyReturnType<TVariables>;
 
 export function useRegister<TVariables = {}>(
-    props?: UseRegisterProps<TVariables>,
+  props?: UseRegisterProps<TVariables>,
 ): UseRegisterReturnType<TVariables>;
 
 export function useRegister<TVariables = {}>(
-    props?: UseRegisterCombinedProps<TVariables>,
+  props?: UseRegisterCombinedProps<TVariables>,
 ): UseRegisterCombinedReturnType<TVariables>;
 
 /**
@@ -101,138 +96,131 @@ export function useRegister<TVariables = {}>(
  *
  */
 export function useRegister<TVariables = {}>({
-    v3LegacyAuthProviderCompatible,
-    mutationOptions,
+  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 { keys, preferLegacyKeys } = useKeys();
-
-    const mutation = useMutation<
-        AuthActionResponse,
-        Error | RefineError,
-        TVariables,
-        unknown
-    >({
-        mutationKey: keys().auth().action("register").get(preferLegacyKeys),
-        mutationFn: registerFromContext,
-        onSuccess: async ({
-            success,
-            redirectTo,
-            error,
-            successNotification,
-        }) => {
-            if (success) {
-                close?.("register-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" });
-                }
-            } else {
-                if (routerType === "legacy") {
-                    replace("/");
-                }
-            }
-
-            await invalidateAuthStore();
-        },
-        onError: (error: any) => {
-            open?.(buildNotification(error));
-        },
-        ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
-        meta: {
-            ...(v3LegacyAuthProviderCompatible === true
-                ? {}
-                : mutationOptions?.meta),
-            ...getXRay("useRegister", preferLegacyKeys),
-        },
-    });
-
-    const v3LegacyAuthProviderCompatibleMutation = useMutation<
-        TRegisterData,
-        Error | RefineError,
-        TVariables,
-        unknown
-    >({
-        mutationKey: [
-            ...keys().auth().action("register").get(preferLegacyKeys),
-            "v3LegacyAuthProviderCompatible",
-        ],
-        mutationFn: legacyRegisterFromContext,
-        onSuccess: async (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" });
-                    }
-                }
-
-                await invalidateAuthStore();
-
-                close?.("register-error");
-            }
-        },
-        onError: (error: any) => {
-            open?.(buildNotification(error));
-        },
-        ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
-        meta: {
-            ...(v3LegacyAuthProviderCompatible ? mutationOptions?.meta : {}),
-            ...getXRay("useRegister", preferLegacyKeys),
-        },
-    });
-
-    return v3LegacyAuthProviderCompatible
-        ? v3LegacyAuthProviderCompatibleMutation
-        : mutation;
+  | 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 { keys, preferLegacyKeys } = useKeys();
+
+  const mutation = useMutation<
+    AuthActionResponse,
+    Error | RefineError,
+    TVariables,
+    unknown
+  >({
+    mutationKey: keys().auth().action("register").get(preferLegacyKeys),
+    mutationFn: registerFromContext,
+    onSuccess: async ({ success, redirectTo, error, successNotification }) => {
+      if (success) {
+        close?.("register-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" });
+        }
+      } else {
+        if (routerType === "legacy") {
+          replace("/");
+        }
+      }
+
+      await invalidateAuthStore();
+    },
+    onError: (error: any) => {
+      open?.(buildNotification(error));
+    },
+    ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions),
+    meta: {
+      ...(v3LegacyAuthProviderCompatible === true ? {} : mutationOptions?.meta),
+      ...getXRay("useRegister", preferLegacyKeys),
+    },
+  });
+
+  const v3LegacyAuthProviderCompatibleMutation = useMutation<
+    TRegisterData,
+    Error | RefineError,
+    TVariables,
+    unknown
+  >({
+    mutationKey: [
+      ...keys().auth().action("register").get(preferLegacyKeys),
+      "v3LegacyAuthProviderCompatible",
+    ],
+    mutationFn: legacyRegisterFromContext,
+    onSuccess: async (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" });
+          }
+        }
+
+        await invalidateAuthStore();
+
+        close?.("register-error");
+      }
+    },
+    onError: (error: any) => {
+      open?.(buildNotification(error));
+    },
+    ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+    meta: {
+      ...(v3LegacyAuthProviderCompatible ? mutationOptions?.meta : {}),
+      ...getXRay("useRegister", preferLegacyKeys),
+    },
+  });
+
+  return v3LegacyAuthProviderCompatible
+    ? v3LegacyAuthProviderCompatibleMutation
+    : mutation;
 }
 
 const buildNotification = (
-    error?: Error | RefineError,
+  error?: Error | RefineError,
 ): OpenNotificationParams => {
-    return {
-        message: error?.name || "Register Error",
-        description: error?.message || "Error while registering",
-        key: "register-error",
-        type: "error",
-    };
+  return {
+    message: error?.name || "Register Error",
+    description: error?.message || "Error while registering",
+    key: "register-error",
+    type: "error",
+  };
 };
 
 const buildSuccessNotification = (
-    successNotification: SuccessNotificationResponse,
+  successNotification: SuccessNotificationResponse,
 ): OpenNotificationParams => {
-    return {
-        message: successNotification.message,
-        description: successNotification.description,
-        key: "register-success",
-        type: "success",
-    };
+  return {
+    message: successNotification.message,
+    description: successNotification.description,
+    key: "register-success",
+    type: "success",
+  };
 };