@refinedev/core 4.58.0 → 5.0.1

package/src/definitions/table/index.ts

@@ -3,8 +3,6 @@ import unionWith from "lodash/unionWith";
 import qs, { type IStringifyOptions } from "qs";
 import warnOnce from "warn-once";
 
-import { pickNotDeprecated } from "@definitions/helpers";
-
 import type {
   CrudFilter,
   CrudOperators,
@@ -13,29 +11,36 @@ import type {
 } from "../../contexts/data/types";
 
 export const parseTableParams = (url: string) => {
-  const { current, pageSize, sorter, sorters, filters } = qs.parse(
+  const { currentPage, pageSize, sorters, sorter, filters } = qs.parse(
     url.substring(1), // remove first ? character
   );
 
   return {
-    parsedCurrent: current && Number(current),
+    parsedCurrent: currentPage && Number(currentPage),
     parsedPageSize: pageSize && Number(pageSize),
-    parsedSorter: (pickNotDeprecated(sorters, sorter) as CrudSort[]) ?? [],
+    parsedSorter: (sorters as CrudSort[]) || (sorter as CrudSort[]) || [],
     parsedFilters: (filters as CrudFilter[]) ?? [],
   };
 };
 
 export const parseTableParamsFromQuery = (params: any) => {
-  const url = qs.stringify(params);
-  return parseTableParams(`/${url}`);
+  const { currentPage, pageSize, sorters, sorter, filters } = params;
+
+  return {
+    parsedCurrent: currentPage && Number(currentPage),
+    parsedPageSize: pageSize && Number(pageSize),
+    parsedSorter: (sorters as CrudSort[]) || (sorter as CrudSort[]) || [],
+    parsedFilters: (filters as CrudFilter[]) ?? [],
+  };
 };
 
 /**
  * @internal This function is used to stringify table params from the useTable hook.
  */
 export const stringifyTableParams = (params: {
-  pagination?: { current?: number; pageSize?: number };
+  pagination?: { currentPage?: number; pageSize?: number };
   sorters: CrudSort[];
+  sorter?: CrudSort[];
   filters: CrudFilter[];
   [key: string]: any;
 }): string => {
@@ -44,13 +49,16 @@ export const stringifyTableParams = (params: {
     arrayFormat: "indices",
     encode: false,
   };
-  const { pagination, sorter, sorters, filters, ...rest } = params;
+  const { pagination, sorters, sorter, filters, ...rest } = params;
+
+  // Prioritize sorters over sorter
+  const finalSorters = sorters && sorters.length > 0 ? sorters : sorter;
 
   const queryString = qs.stringify(
     {
       ...rest,
       ...(pagination ? pagination : {}),
-      sorters: pickNotDeprecated(sorters, sorter),
+      sorters: finalSorters,
       filters,
     },
     options,

package/src/definitions/types/index.ts

@@ -31,10 +31,11 @@ export type UseMutationResult<
   TError = unknown,
   TVariables = unknown,
   TContext = unknown,
-> = Omit<
-  UseMutationResultBase<TData, TError, TVariables, TContext>,
-  "mutate" | "mutateAsync"
-> & {
+> = {
+  mutation: UseMutationResultBase<TData, TError, TVariables, TContext>;
   mutate: MutateFunction<TData, TError, TVariables, TContext>;
   mutateAsync: MutateAsyncFunction<TData, TError, TVariables, TContext>;
 };
+
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> &
+  Partial<Pick<T, K>>;

package/src/hooks/accessControl/useCan/index.ts

@@ -17,9 +17,12 @@ import type {
 
 export type UseCanProps = CanParams & {
   /**
-   * react-query's [useQuery](https://tanstack.com/query/v4/docs/reference/useQuery) options
+   * TansSack Query's [useQuery](https://tanstack.com/query/latest/docs/framework/react/reference/useQuery) options
    */
-  queryOptions?: UseQueryOptions<CanReturnType>;
+  // Make queryKey and queryFn optional
+  queryOptions?: Omit<UseQueryOptions<CanReturnType>, "queryKey"> & {
+    queryKey?: UseQueryOptions<CanReturnType>["queryKey"];
+  };
 };
 
 /**
@@ -37,7 +40,7 @@ export const useCan = ({
   queryOptions: hookQueryOptions,
 }: UseCanProps): UseQueryResult<CanReturnType> => {
   const { can, options: globalOptions } = useContext(AccessControlContext);
-  const { keys, preferLegacyKeys } = useKeys();
+  const { keys } = useKeys();
 
   const { queryOptions: globalQueryOptions } = globalOptions || {};
 
@@ -63,7 +66,7 @@ export const useCan = ({
         params: { ...paramsRest, resource: sanitizedResource },
         enabled: mergedQueryOptions?.enabled,
       })
-      .get(preferLegacyKeys),
+      .get(),
     // Enabled check for `can` is enough to be sure that it's defined in the query function but TS is not smart enough to know that.
     queryFn: () =>
       can?.({
@@ -75,7 +78,7 @@ export const useCan = ({
     ...mergedQueryOptions,
     meta: {
       ...mergedQueryOptions?.meta,
-      ...getXRay("useCan", preferLegacyKeys, resource, [
+      ...getXRay("useCan", resource, [
         "useButtonCanAccess",
         "useNavigationButton",
       ]),

package/src/hooks/auditLog/useLog/index.ts

@@ -10,8 +10,7 @@ import {
 
 import { AuditLogContext } from "@contexts/auditLog";
 import { ResourceContext } from "@contexts/resource";
-import { hasPermission, pickNotDeprecated } from "@definitions/helpers";
-import { useActiveAuthProvider } from "@definitions/helpers";
+import { hasPermission } from "@definitions/helpers";
 import { pickResource } from "@definitions/helpers/pick-resource";
 import { useGetIdentity } from "@hooks/auth";
 import { useKeys } from "@hooks/useKeys";
@@ -73,30 +72,24 @@ export const useLog = <
 > => {
   const queryClient = useQueryClient();
   const auditLogContext = useContext(AuditLogContext);
-  const { keys, preferLegacyKeys } = useKeys();
-
-  const authProvider = useActiveAuthProvider();
+  const { keys } = useKeys();
 
   const { resources } = useContext(ResourceContext);
+
   const {
     data: identityData,
     refetch,
     isLoading,
   } = useGetIdentity({
-    v3LegacyAuthProviderCompatible: Boolean(authProvider?.isLegacy),
     queryOptions: {
       enabled: !!auditLogContext?.create,
     },
   });
 
-  const log = useMutation<TLogData, Error, LogParams, unknown>(
-    async (params) => {
+  const log = useMutation<TLogData, Error, LogParams, unknown>({
+    mutationFn: async (params: LogParams) => {
       const resource = pickResource(params.resource, resources);
-      const logPermissions = pickNotDeprecated(
-        resource?.meta?.audit,
-        resource?.options?.audit,
-        resource?.options?.auditLog?.permissions,
-      );
+      const logPermissions = resource?.meta?.audit;
 
       if (logPermissions) {
         if (!hasPermission(logPermissions, params.action)) {
@@ -114,45 +107,41 @@ export const useLog = <
         author: identityData ?? authorData?.data,
       });
     },
-    {
-      mutationKey: keys().audit().action("log").get(),
-      ...logMutationOptions,
-      meta: {
-        ...logMutationOptions?.meta,
-        ...getXRay("useLog", preferLegacyKeys),
-      },
+    mutationKey: keys().audit().action("log").get(),
+    ...logMutationOptions,
+    meta: {
+      ...logMutationOptions?.meta,
+      ...getXRay("useLog"),
     },
-  );
+  });
 
   const rename = useMutation<
     TLogRenameData,
     Error,
     { id: BaseKey; name: string },
     unknown
-  >(
-    async (params) => {
+  >({
+    mutationFn: async (params: { id: BaseKey; name: string }) => {
       return await auditLogContext.update?.(params);
     },
-    {
-      onSuccess: (data) => {
-        if (data?.resource) {
-          queryClient.invalidateQueries(
-            keys()
-              .audit()
-              .resource(data?.resource ?? "")
-              .action("list")
-              .get(preferLegacyKeys),
-          );
-        }
-      },
-      mutationKey: keys().audit().action("rename").get(),
-      ...renameMutationOptions,
-      meta: {
-        ...renameMutationOptions?.meta,
-        ...getXRay("useLog", preferLegacyKeys),
-      },
+    onSuccess: (data: TLogRenameData) => {
+      if (data?.resource) {
+        queryClient.invalidateQueries({
+          queryKey: keys()
+            .audit()
+            .resource(data?.resource ?? "")
+            .action("list")
+            .get(),
+        });
+      }
     },
-  );
+    mutationKey: keys().audit().action("rename").get(),
+    ...renameMutationOptions,
+    meta: {
+      ...renameMutationOptions?.meta,
+      ...getXRay("useLog"),
+    },
+  });
 
   return { log, rename };
 };

package/src/hooks/auditLog/useLogList/index.ts

@@ -10,15 +10,18 @@ import {
 import { AuditLogContext } from "@contexts/auditLog";
 import { useKeys } from "@hooks/useKeys";
 
-import type { HttpError, MetaQuery } from "../../../contexts/data/types";
+import type { HttpError } from "../../../contexts/data/types";
+import type { MakeOptional } from "../../../definitions/types";
 
 export type UseLogProps<TQueryFnData, TError, TData> = {
   resource: string;
   action?: string;
   meta?: Record<number | string, any>;
   author?: Record<number | string, any>;
-  queryOptions?: UseQueryOptions<TQueryFnData, TError, TData>;
-  metaData?: MetaQuery;
+  queryOptions?: MakeOptional<
+    UseQueryOptions<TQueryFnData, TError, TData>,
+    "queryKey" | "queryFn"
+  >;
 };
 
 /**
@@ -40,11 +43,10 @@ export const useLogList = <
   action,
   meta,
   author,
-  metaData,
   queryOptions,
-}: UseLogProps<TQueryFnData, TError, TData>): UseQueryResult<TData> => {
+}: UseLogProps<TQueryFnData, TError, TData>): UseQueryResult<TData, TError> => {
   const { get } = useContext(AuditLogContext);
-  const { keys, preferLegacyKeys } = useKeys();
+  const { keys } = useKeys();
 
   const queryResponse = useQuery<TQueryFnData, TError, TData>({
     queryKey: keys()
@@ -52,21 +54,20 @@ export const useLogList = <
       .resource(resource)
       .action("list")
       .params(meta)
-      .get(preferLegacyKeys),
+      .get(),
     queryFn: () =>
       get?.({
         resource,
         action,
         author,
         meta,
-        metaData,
       }) ?? Promise.resolve([]),
     enabled: typeof get !== "undefined",
     ...queryOptions,
     retry: false,
     meta: {
       ...queryOptions?.meta,
-      ...getXRay("useLogList", preferLegacyKeys, resource),
+      ...getXRay("useLogList", resource),
     },
   });
 

package/src/hooks/auth/index.ts

@@ -5,7 +5,7 @@ export { useLogin } from "./useLogin";
 export { useRegister } from "./useRegister";
 export { useForgotPassword } from "./useForgotPassword";
 export { useUpdatePassword } from "./useUpdatePassword";
-export { useAuthenticated, useIsAuthenticated } from "./useIsAuthenticated";
-export { useCheckError, useOnError } from "./useOnError";
+export { useIsAuthenticated } from "./useIsAuthenticated";
+export { useOnError } from "./useOnError";
 export { useIsExistAuthentication } from "./useIsExistAuthentication";
 export { useInvalidateAuthStore } from "./useInvalidateAuthStore";

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

@@ -5,14 +5,8 @@ import {
   useMutation,
 } from "@tanstack/react-query";
 
-import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
-import {
-  useGo,
-  useKeys,
-  useNavigation,
-  useNotification,
-  useRouterType,
-} from "@hooks";
+import { useAuthProviderContext } from "@contexts/auth";
+import { useGo, useKeys, useNotification } from "@hooks";
 
 import type {
   AuthActionResponse,
@@ -22,34 +16,7 @@ import type {
 import type { RefineError } from "../../../contexts/data/types";
 import type { OpenNotificationParams } from "../../../contexts/notification/types";
 
-export type UseForgotPasswordLegacyProps<TVariables> = {
-  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"
-  >;
-};
-
-export type UseForgotPasswordCombinedProps<TVariables> = {
-  v3LegacyAuthProviderCompatible: boolean;
   mutationOptions?: Omit<
     UseMutationOptions<
       AuthActionResponse | TForgotPasswordData,
@@ -61,13 +28,6 @@ export type UseForgotPasswordCombinedProps<TVariables> = {
   >;
 };
 
-export type UseForgotPasswordLegacyReturnType<TVariables> = UseMutationResult<
-  TForgotPasswordData,
-  Error | RefineError,
-  TVariables,
-  unknown
->;
-
 export type UseForgotPasswordReturnType<TVariables> = UseMutationResult<
   AuthActionResponse,
   Error | RefineError,
@@ -75,52 +35,22 @@ export type UseForgotPasswordReturnType<TVariables> = UseMutationResult<
   unknown
 >;
 
-export type UseForgotPasswordCombinedReturnType<TVariables> = UseMutationResult<
-  AuthActionResponse | TForgotPasswordData,
-  Error | RefineError,
-  TVariables,
-  unknown
->;
-
-export function useForgotPassword<TVariables = {}>(
-  props: UseForgotPasswordLegacyProps<TVariables>,
-): UseForgotPasswordLegacyReturnType<TVariables>;
-
-export function useForgotPassword<TVariables = {}>(
-  props?: UseForgotPasswordProps<TVariables>,
-): UseForgotPasswordReturnType<TVariables>;
-
-export function useForgotPassword<TVariables = {}>(
-  props?: UseForgotPasswordCombinedProps<TVariables>,
-): UseForgotPasswordCombinedReturnType<TVariables>;
-
 /**
  * `useForgotPassword` calls `forgotPassword` method from {@link https://refine.dev/docs/api-reference/core/providers/auth-provider `authProvider`} under the hood.
  *
  * @see {@link https://refine.dev/docs/api-reference/core/hooks/auth/useForgotPassword} for more details.
  *
- * @typeParam TData - Result data of the query
  * @typeParam TVariables - Values for mutation function. default `{}`
  *
  */
 export function useForgotPassword<TVariables = {}>({
-  v3LegacyAuthProviderCompatible,
   mutationOptions,
-}:
-  | UseForgotPasswordProps<TVariables>
-  | UseForgotPasswordLegacyProps<TVariables> = {}):
-  | UseForgotPasswordReturnType<TVariables>
-  | UseForgotPasswordLegacyReturnType<TVariables> {
-  const routerType = useRouterType();
+}: UseForgotPasswordProps<TVariables> = {}): UseForgotPasswordReturnType<TVariables> {
   const go = useGo();
-  const { replace } = useNavigation();
-  const {
-    forgotPassword: v3LegacyAuthProviderCompatibleForgotPasswordFromContext,
-  } = useLegacyAuthContext();
+  const { open, close } = useNotification();
   const { forgotPassword: forgotPasswordFromContext } =
-    useAuthBindingsContext();
-  const { close, open } = useNotification();
-  const { keys, preferLegacyKeys } = useKeys();
+    useAuthProviderContext();
+  const { keys } = useKeys();
 
   const mutation = useMutation<
     AuthActionResponse,
@@ -128,8 +58,9 @@ export function useForgotPassword<TVariables = {}>({
     TVariables,
     unknown
   >({
-    mutationKey: keys().auth().action("forgotPassword").get(preferLegacyKeys),
+    mutationKey: keys().auth().action("forgotPassword").get(),
     mutationFn: forgotPasswordFromContext,
+
     onSuccess: ({ success, redirectTo, error, successNotification }) => {
       if (success) {
         close?.("forgot-password-error");
@@ -144,59 +75,22 @@ export function useForgotPassword<TVariables = {}>({
       }
 
       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" });
-          }
-        }
+        go({ to: redirectTo, type: "replace" });
       }
-      close?.("forgot-password-error");
     },
     onError: (error: any) => {
       open?.(buildNotification(error));
     },
-    ...(v3LegacyAuthProviderCompatible ? mutationOptions : {}),
+    ...mutationOptions,
     meta: {
-      ...(v3LegacyAuthProviderCompatible ? mutationOptions?.meta : {}),
-      ...getXRay("useForgotPassword", preferLegacyKeys),
+      ...mutationOptions?.meta,
+      ...getXRay("useForgotPassword"),
     },
   });
 
-  return v3LegacyAuthProviderCompatible
-    ? v3LegacyAuthProviderCompatibleMutation
-    : mutation;
+  return {
+    ...mutation,
+  };
 }
 
 const buildNotification = (

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

@@ -1,58 +1,22 @@
 import { getXRay } from "@refinedev/devtools-internal";
 import {
-  type UseQueryOptions,
   type UseQueryResult,
+  type UseQueryOptions,
   useQuery,
 } from "@tanstack/react-query";
 
-import { useAuthBindingsContext, useLegacyAuthContext } from "@contexts/auth";
-import { useKeys } from "@hooks/useKeys";
-
-import type { IdentityResponse } from "../../../contexts/auth/types";
-
-export type UseGetIdentityLegacyProps<TData> = {
-  v3LegacyAuthProviderCompatible: true;
-  queryOptions?: UseQueryOptions<TData>;
-};
+import { useAuthProviderContext } from "@contexts/auth";
+import { useKeys } from "@hooks";
+import type { MakeOptional } from "../../../definitions/types";
 
-export type UseGetIdentityProps<TData = IdentityResponse> = {
-  v3LegacyAuthProviderCompatible?: false;
-  queryOptions?: UseQueryOptions<TData>;
+export type UseGetIdentityProps<TData = any> = {
+  queryOptions?: MakeOptional<UseQueryOptions<TData>, "queryKey" | "queryFn">;
 };
 
-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>;
+export type UseGetIdentityReturnType<TData> = UseQueryResult<TData>;
 
 /**
- * `useGetIdentity` calls the `getUserIdentity` method from the {@link https://refine.dev/docs/core/providers/auth-provider `authProvider`} under the hood.
+ * `useGetIdentity` calls `getIdentity` method from {@link https://refine.dev/docs/api-reference/core/providers/auth-provider `authProvider`} under the hood.
  *
  * @see {@link https://refine.dev/docs/api-reference/core/hooks/auth/useGetIdentity} for more details.
  *
@@ -60,45 +24,24 @@ export function useGetIdentity<TData = any>(
  *
  */
 export function useGetIdentity<TData = any>({
-  v3LegacyAuthProviderCompatible = false,
   queryOptions,
-}: UseGetIdentityProps<TData> | UseGetIdentityLegacyProps<TData> = {}):
-  | UseGetIdentityReturnType<TData>
-  | UseGetIdentityLegacyReturnType<TData> {
-  const { getUserIdentity: legacyGetUserIdentity } = useLegacyAuthContext();
-  const { getIdentity } = useAuthBindingsContext();
-  const { keys, preferLegacyKeys } = useKeys();
+}: UseGetIdentityProps<TData> = {}): UseGetIdentityReturnType<TData> {
+  const { getIdentity } = useAuthProviderContext();
+  const { keys } = 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.
+    queryKey: keys().auth().action("identity").get(),
     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 : {}),
+    enabled: !!getIdentity,
+    ...queryOptions,
     meta: {
-      ...(v3LegacyAuthProviderCompatible ? queryOptions?.meta : {}),
-      ...getXRay("useGetIdentity", preferLegacyKeys),
+      ...queryOptions?.meta,
+      ...getXRay("useGetIdentity"),
     },
   });
 
-  return v3LegacyAuthProviderCompatible ? legacyQueryResponse : queryResponse;
+  return queryResponse;
 }

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

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