@refinedev/core 4.58.0 → 5.0.1

package/src/hooks/data/useCreateMany.ts

@@ -5,11 +5,7 @@ import {
   useMutation,
 } from "@tanstack/react-query";
 
-import {
-  handleMultiple,
-  pickDataProvider,
-  pickNotDeprecated,
-} from "@definitions";
+import { handleMultiple, pickDataProvider } from "@definitions";
 import {
   useDataProvider,
   useHandleNotification,
@@ -19,7 +15,7 @@ import {
   useMeta,
   usePublish,
   useRefineContext,
-  useResource,
+  useResourceParams,
   useTranslate,
 } from "@hooks";
 
@@ -42,7 +38,6 @@ export type UseCreateManyParams<TData, TError, TVariables> = {
   resource?: string;
   values?: TVariables[];
   meta?: MetaQuery;
-  metaData?: MetaQuery;
   dataProviderName?: string;
   invalidates?: Array<keyof IQueryKeys>;
 } & SuccessErrorNotification<CreateManyResponse<TData>, TError, TVariables[]>;
@@ -97,7 +92,6 @@ export const useCreateMany = <
   successNotification: successNotificationFromProps,
   errorNotification: errorNotificationFromProps,
   meta: metaFromProps,
-  metaData: metaDataFromProps,
   invalidates: invalidatesFromProps,
   mutationOptions,
   overtimeOptions,
@@ -108,7 +102,7 @@ export const useCreateMany = <
 > &
   UseLoadingOvertimeReturnType => {
   const dataProvider = useDataProvider();
-  const { resources, select } = useResource();
+  const { resources, select } = useResourceParams();
   const translate = useTranslate();
   const publish = usePublish();
   const handleNotification = useHandleNotification();
@@ -118,7 +112,7 @@ export const useCreateMany = <
   const {
     options: { textTransformers },
   } = useRefineContext();
-  const { keys, preferLegacyKeys } = useKeys();
+  const { keys } = useKeys();
 
   const mutationResult = useMutation<
     CreateManyResponse<TData>,
@@ -129,7 +123,6 @@ export const useCreateMany = <
       resource: resourceName = resourceFromProps,
       values = valuesFromProps,
       meta = metaFromProps,
-      metaData = metaDataFromProps,
       dataProviderName = dataProviderNameFromProps,
     }: UseCreateManyParams<TData, TError, TVariables>) => {
       if (!values) throw missingValuesError;
@@ -139,7 +132,7 @@ export const useCreateMany = <
 
       const combinedMeta = getMeta({
         resource,
-        meta: pickNotDeprecated(meta, metaData),
+        meta,
       });
 
       const selectedDataProvider = dataProvider(
@@ -151,7 +144,6 @@ export const useCreateMany = <
           resource: resource.name,
           variables: values,
           meta: combinedMeta,
-          metaData: combinedMeta,
         });
       }
       return handleMultiple(
@@ -160,7 +152,6 @@ export const useCreateMany = <
             resource: resource.name,
             variables: val,
             meta: combinedMeta,
-            metaData: combinedMeta,
           }),
         ),
       );
@@ -173,7 +164,6 @@ export const useCreateMany = <
         invalidates = invalidatesFromProps ?? ["list", "many"],
         values = valuesFromProps,
         meta = metaFromProps,
-        metaData = metaDataFromProps,
       } = variables;
       if (!values) throw missingValuesError;
       if (!resourceName) throw missingResourceError;
@@ -189,7 +179,7 @@ export const useCreateMany = <
 
       const combinedMeta = getMeta({
         resource,
-        meta: pickNotDeprecated(meta, metaData),
+        meta,
       });
 
       const notificationConfig =
@@ -283,18 +273,18 @@ export const useCreateMany = <
 
       mutationOptions?.onError?.(err, variables, context);
     },
-    mutationKey: keys().data().mutation("createMany").get(preferLegacyKeys),
+    mutationKey: keys().data().mutation("createMany").get(),
     ...mutationOptions,
     meta: {
       ...mutationOptions?.meta,
-      ...getXRay("useCreateMany", preferLegacyKeys),
+      ...getXRay("useCreateMany"),
     },
   });
-  const { mutate, mutateAsync, ...mutation } = mutationResult;
+  const { mutate, mutateAsync } = mutationResult;
 
   const { elapsedTime } = useLoadingOvertime({
     ...overtimeOptions,
-    isLoading: mutation.isLoading,
+    isLoading: mutationResult.isPending,
   });
 
   // this function is used to make the `variables` parameter optional
@@ -324,7 +314,7 @@ export const useCreateMany = <
   };
 
   return {
-    ...mutation,
+    mutation: mutationResult,
     mutate: handleMutation,
     mutateAsync: handleMutateAsync,
     overtime: { elapsedTime },

package/src/hooks/data/useCustom.ts

@@ -1,3 +1,4 @@
+import { useEffect } from "react";
 import { getXRay } from "@refinedev/devtools-internal";
 import {
   type QueryObserverResult,
@@ -5,11 +6,7 @@ import {
   useQuery,
 } from "@tanstack/react-query";
 
-import {
-  pickNotDeprecated,
-  useActiveAuthProvider,
-  prepareQueryContext,
-} from "@definitions/helpers";
+import { prepareQueryContext } from "@definitions/helpers";
 import {
   useDataProvider,
   useHandleNotification,
@@ -36,10 +33,6 @@ import {
 } from "../useLoadingOvertime";
 
 interface UseCustomConfig<TQuery, TPayload> {
-  /**
-   * @deprecated `sort` is deprecated, use `sorters` instead.
-   */
-  sort?: CrudSort[];
   sorters?: CrudSort[];
   filters?: CrudFilter[];
   query?: TQuery;
@@ -47,6 +40,24 @@ interface UseCustomConfig<TQuery, TPayload> {
   headers?: {};
 }
 
+// Clean type without custom callback extensions
+export type UseCustomQueryOptions<TQueryFnData, TError, TData> = Omit<
+  UseQueryOptions<CustomResponse<TQueryFnData>, TError, CustomResponse<TData>>,
+  "queryKey" | "queryFn"
+> & {
+  // Make queryKey and queryFn optional for backward compatibility
+  queryKey?: UseQueryOptions<
+    CustomResponse<TQueryFnData>,
+    TError,
+    CustomResponse<TData>
+  >["queryKey"];
+  queryFn?: UseQueryOptions<
+    CustomResponse<TQueryFnData>,
+    TError,
+    CustomResponse<TData>
+  >["queryFn"];
+};
+
 export type UseCustomProps<TQueryFnData, TError, TQuery, TPayload, TData> = {
   /**
    * request's URL
@@ -61,22 +72,15 @@ export type UseCustomProps<TQueryFnData, TError, TQuery, TPayload, TData> = {
    */
   config?: UseCustomConfig<TQuery, TPayload>;
   /**
-   * react-query's [useQuery](https://tanstack.com/query/v4/docs/reference/useQuery) options"
+   * react-query's [useQuery](https://tanstack.com/query/v4/docs/reference/useQuery) options
    */
-  queryOptions?: UseQueryOptions<
-    CustomResponse<TQueryFnData>,
-    TError,
-    CustomResponse<TData>
-  >;
+  queryOptions?: UseCustomQueryOptions<TQueryFnData, TError, TData>;
   /**
    * meta data for `dataProvider`
    */
   meta?: MetaQuery;
   /**
    * meta data for `dataProvider`
-   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
-   */
-  metaData?: MetaQuery;
   /**
    * If there is more than one `dataProvider`, you should use the `dataProviderName` that you will use.
    */
@@ -103,6 +107,13 @@ export type UseCustomProps<TQueryFnData, TError, TQuery, TPayload, TData> = {
  *
  */
 
+export type UseCustomReturnType<TData, TError> = {
+  query: QueryObserverResult<CustomResponse<TData>, TError>;
+  result: {
+    data: CustomResponse<TData>["data"];
+  };
+} & UseLoadingOvertimeReturnType;
+
 export const useCustom = <
   TQueryFnData extends BaseRecord = BaseRecord,
   TError extends HttpError = HttpError,
@@ -117,7 +128,6 @@ export const useCustom = <
   successNotification,
   errorNotification,
   meta,
-  metaData,
   dataProviderName,
   overtimeOptions,
 }: UseCustomProps<
@@ -126,19 +136,15 @@ export const useCustom = <
   TQuery,
   TPayload,
   TData
->): QueryObserverResult<CustomResponse<TData>, TError> &
-  UseLoadingOvertimeReturnType => {
+>): UseCustomReturnType<TData, TError> => {
   const dataProvider = useDataProvider();
-  const authProvider = useActiveAuthProvider();
-  const { mutate: checkError } = useOnError({
-    v3LegacyAuthProviderCompatible: Boolean(authProvider?.isLegacy),
-  });
   const translate = useTranslate();
+  const { mutate: checkError } = useOnError();
   const handleNotification = useHandleNotification();
   const getMeta = useMeta();
-  const { keys, preferLegacyKeys } = useKeys();
+  const { keys } = useKeys();
 
-  const preferredMeta = pickNotDeprecated(meta, metaData);
+  const preferredMeta = meta;
 
   const { custom } = dataProvider(dataProviderName);
 
@@ -159,7 +165,7 @@ export const useCustom = <
           ...config,
           ...(preferredMeta || {}),
         })
-        .get(preferLegacyKeys),
+        .get(),
       queryFn: (context) =>
         custom<TQueryFnData>({
           url,
@@ -167,34 +173,39 @@ export const useCustom = <
           ...config,
           meta: {
             ...combinedMeta,
-            queryContext: prepareQueryContext(context),
-          },
-          metaData: {
-            ...combinedMeta,
-            queryContext: prepareQueryContext(context),
+            ...prepareQueryContext(context as any),
           },
         }),
       ...queryOptions,
-      onSuccess: (data) => {
-        queryOptions?.onSuccess?.(data);
+      meta: {
+        ...queryOptions?.meta,
+        ...getXRay("useCustom"),
+      },
+    });
 
+    // Handle success
+    useEffect(() => {
+      if (queryResponse.isSuccess && queryResponse.data) {
         const notificationConfig =
           typeof successNotification === "function"
-            ? successNotification(data, {
+            ? successNotification(queryResponse.data, {
                 ...config,
                 ...combinedMeta,
               })
             : successNotification;
 
         handleNotification(notificationConfig);
-      },
-      onError: (err: TError) => {
-        checkError(err);
-        queryOptions?.onError?.(err);
+      }
+    }, [queryResponse.isSuccess, queryResponse.data, successNotification]);
+
+    // Handle error
+    useEffect(() => {
+      if (queryResponse.isError && queryResponse.error) {
+        checkError(queryResponse.error);
 
         const notificationConfig =
           typeof errorNotification === "function"
-            ? errorNotification(err, {
+            ? errorNotification(queryResponse.error, {
                 ...config,
                 ...combinedMeta,
               })
@@ -204,24 +215,26 @@ export const useCustom = <
           key: `${method}-notification`,
           message: translate(
             "notifications.error",
-            { statusCode: err.statusCode },
-            `Error (status code: ${err.statusCode})`,
+            { statusCode: queryResponse.error.statusCode },
+            `Error (status code: ${queryResponse.error.statusCode})`,
           ),
-          description: err.message,
+          description: queryResponse.error.message,
           type: "error",
         });
-      },
-      meta: {
-        ...queryOptions?.meta,
-        ...getXRay("useCustom", preferLegacyKeys),
-      },
-    });
+      }
+    }, [queryResponse.isError, queryResponse.error?.message]);
     const { elapsedTime } = useLoadingOvertime({
       ...overtimeOptions,
       isLoading: queryResponse.isFetching,
     });
 
-    return { ...queryResponse, overtime: { elapsedTime } };
+    return {
+      query: queryResponse,
+      result: {
+        data: queryResponse.data?.data || ({} as TData),
+      },
+      overtime: { elapsedTime },
+    };
   }
   throw Error("Not implemented custom on data provider.");
 };

package/src/hooks/data/useCustomMutation.ts

@@ -5,7 +5,6 @@ import {
   useMutation,
 } from "@tanstack/react-query";
 
-import { pickNotDeprecated, useActiveAuthProvider } from "@definitions/helpers";
 import {
   useDataProvider,
   useHandleNotification,
@@ -42,10 +41,8 @@ type useCustomMutationParams<TData, TError, TVariables> = {
    */
   meta?: MetaQuery;
   /**
-   * Meta data for `dataProvider`
-   * @deprecated `metaData` is deprecated with refine@4, refine will pass `meta` instead, however, we still support `metaData` for backward compatibility.
+   * If there is more than one `dataProvider`, you should use the `dataProviderName` that you will use.
    */
-  metaData?: MetaQuery;
   dataProviderName?: string;
   config?: UseCustomMutationConfig;
 } & SuccessErrorNotification<
@@ -58,7 +55,32 @@ export type UseCustomMutationReturnType<
   TData extends BaseRecord = BaseRecord,
   TError extends HttpError = HttpError,
   TVariables = {},
-> = UseMutationResult<
+> = {
+  mutation: UseMutationResult<
+    CreateResponse<TData>,
+    TError,
+    useCustomMutationParams<TData, TError, TVariables>,
+    unknown
+  >;
+  mutate: UseMutationResult<
+    CreateResponse<TData>,
+    TError,
+    useCustomMutationParams<TData, TError, TVariables>,
+    unknown
+  >["mutate"];
+  mutateAsync: UseMutationResult<
+    CreateResponse<TData>,
+    TError,
+    useCustomMutationParams<TData, TError, TVariables>,
+    unknown
+  >["mutateAsync"];
+} & UseLoadingOvertimeReturnType;
+
+export type UseCustomMutationOptions<
+  TData extends BaseRecord = BaseRecord,
+  TError extends HttpError = HttpError,
+  TVariables = {},
+> = UseMutationOptions<
   CreateResponse<TData>,
   TError,
   useCustomMutationParams<TData, TError, TVariables>,
@@ -70,15 +92,7 @@ export type UseCustomMutationProps<
   TError extends HttpError = HttpError,
   TVariables = {},
 > = {
-  mutationOptions?: Omit<
-    UseMutationOptions<
-      CreateResponse<TData>,
-      TError,
-      useCustomMutationParams<TData, TError, TVariables>,
-      unknown
-    >,
-    "mutationFn" | "onError" | "onSuccess"
-  >;
+  mutationOptions?: UseCustomMutationOptions<TData, TError, TVariables>;
 } & UseLoadingOvertimeOptionsProps;
 
 /**
@@ -107,33 +121,30 @@ export const useCustomMutation = <
   TVariables
 > = {}): UseCustomMutationReturnType<TData, TError, TVariables> &
   UseLoadingOvertimeReturnType => {
-  const authProvider = useActiveAuthProvider();
-  const { mutate: checkError } = useOnError({
-    v3LegacyAuthProviderCompatible: Boolean(authProvider?.isLegacy),
-  });
+  const { mutate: checkError } = useOnError();
   const handleNotification = useHandleNotification();
   const dataProvider = useDataProvider();
   const translate = useTranslate();
   const getMeta = useMeta();
-  const { keys, preferLegacyKeys } = useKeys();
+  const { keys } = useKeys();
 
-  const mutation = useMutation<
+  const mutationResult = useMutation<
     CreateResponse<TData>,
     TError,
     useCustomMutationParams<TData, TError, TVariables>,
     unknown
-  >(
-    ({
+  >({
+    mutationKey: keys().data().mutation("customMutation").get(),
+    mutationFn: ({
       url,
       method,
       values,
       meta,
-      metaData,
       dataProviderName,
       config,
     }: useCustomMutationParams<TData, TError, TVariables>) => {
       const combinedMeta = getMeta({
-        meta: pickNotDeprecated(meta, metaData),
+        meta: meta,
       });
 
       const { custom } = dataProvider(dataProviderName);
@@ -144,80 +155,78 @@ export const useCustomMutation = <
           method,
           payload: values,
           meta: combinedMeta,
-          metaData: combinedMeta,
           headers: { ...config?.headers },
         });
       }
 
       throw Error("Not implemented custom on data provider.");
     },
-    {
-      onSuccess: (
-        data,
-        {
-          successNotification: successNotificationFromProp,
-          config,
-          meta,
-          metaData,
-        },
-      ) => {
-        const notificationConfig =
-          typeof successNotificationFromProp === "function"
-            ? successNotificationFromProp(data, {
-                ...config,
-                ...(pickNotDeprecated(meta, metaData) || {}),
-              })
-            : successNotificationFromProp;
-
-        handleNotification(notificationConfig);
-      },
-      onError: (
-        err: TError,
-        {
-          errorNotification: errorNotificationFromProp,
-          method,
-          config,
-          meta,
-          metaData,
-        },
-      ) => {
-        checkError(err);
-
-        const notificationConfig =
-          typeof errorNotificationFromProp === "function"
-            ? errorNotificationFromProp(err, {
-                ...config,
-                ...(pickNotDeprecated(meta, metaData) || {}),
-              })
-            : errorNotificationFromProp;
-
-        handleNotification(notificationConfig, {
-          key: `${method}-notification`,
-          message: translate(
-            "notifications.error",
-            { statusCode: err.statusCode },
-            `Error (status code: ${err.statusCode})`,
-          ),
-          description: err.message,
-          type: "error",
-        });
-      },
-      mutationKey: keys()
-        .data()
-        .mutation("customMutation")
-        .get(preferLegacyKeys),
-      ...mutationOptions,
-      meta: {
-        ...mutationOptions?.meta,
-        ...getXRay("useCustomMutation", preferLegacyKeys),
-      },
+    onSuccess: (data, variables, context) => {
+      const {
+        successNotification: successNotificationFromProp,
+        config,
+        meta,
+      } = variables;
+
+      const notificationConfig =
+        typeof successNotificationFromProp === "function"
+          ? successNotificationFromProp(data, {
+              ...config,
+              ...(meta || {}),
+            })
+          : successNotificationFromProp;
+
+      handleNotification(notificationConfig);
+
+      mutationOptions?.onSuccess?.(data, variables, context);
     },
-  );
+    onError: (err: TError, variables, context) => {
+      const {
+        errorNotification: errorNotificationFromProp,
+        method,
+        config,
+        meta,
+      } = variables;
+
+      checkError(err);
+
+      const notificationConfig =
+        typeof errorNotificationFromProp === "function"
+          ? errorNotificationFromProp(err, {
+              ...config,
+              ...(meta || {}),
+            })
+          : errorNotificationFromProp;
+
+      handleNotification(notificationConfig, {
+        key: `${method}-notification`,
+        message: translate(
+          "notifications.error",
+          { statusCode: err.statusCode },
+          `Error (status code: ${err.statusCode})`,
+        ),
+        description: err.message,
+        type: "error",
+      });
+
+      mutationOptions?.onError?.(err, variables, context);
+    },
+    ...mutationOptions,
+    meta: {
+      ...mutationOptions?.meta,
+      ...getXRay("useCustomMutation"),
+    },
+  });
 
   const { elapsedTime } = useLoadingOvertime({
     ...overtimeOptions,
-    isLoading: mutation.isLoading,
+    isLoading: mutationResult.isPending,
   });
 
-  return { ...mutation, overtime: { elapsedTime } };
+  return {
+    mutation: mutationResult,
+    mutate: mutationResult.mutate,
+    mutateAsync: mutationResult.mutateAsync,
+    overtime: { elapsedTime },
+  };
 };