@refinedev/core 4.52.0 → 4.54.0

package/src/hooks/data/useUpdate.ts

@@ -1,7 +1,7 @@
 import { getXRay } from "@refinedev/devtools-internal";
 import {
   type UseMutationOptions,
-  type UseMutationResult,
+  type MutateOptions,
   useMutation,
   useQueryClient,
 } from "@tanstack/react-query";
@@ -42,6 +42,7 @@ import type {
   PreviousQuery,
   UpdateResponse,
 } from "../../contexts/data/types";
+import type { UseMutationResult } from "../../definitions/types";
 import type { SuccessErrorNotification } from "../../contexts/notification/types";
 import { ActionTypes } from "../../contexts/undoableQueue/types";
 import {
@@ -78,11 +79,11 @@ export type UpdateParams<TData, TError, TVariables> = {
   /**
    * Resource name for API data interactions
    */
-  resource: string;
+  resource?: string;
   /**
    * id for mutation function
    */
-  id: BaseKey;
+  id?: BaseKey;
   /**
    * [Determines when mutations are executed](/advanced-tutorials/mutation-mode.md)
    */
@@ -98,7 +99,7 @@ export type UpdateParams<TData, TError, TVariables> = {
   /**
    * Values for mutation function
    */
-  values: TVariables;
+  values?: TVariables;
   /**
    * Metadata query for dataProvider
    */
@@ -156,9 +157,10 @@ export type UseUpdateProps<
       UpdateParams<TData, TError, TVariables>,
       UpdateContext<TData>
     >,
-    "mutationFn" | "onError" | "onSuccess" | "onSettled" | "onMutate"
+    "mutationFn" | "onMutate"
   >;
-} & UseLoadingOvertimeOptionsProps;
+} & UseLoadingOvertimeOptionsProps &
+  UpdateParams<TData, TError, TVariables>;
 
 /**
  * `useUpdate` is a modified version of `react-query`'s {@link https://react-query.tanstack.com/reference/useMutation `useMutation`} for update mutations.
@@ -177,6 +179,19 @@ export const useUpdate = <
   TError extends HttpError = HttpError,
   TVariables = {},
 >({
+  id: idFromProps,
+  resource: resourceFromProps,
+  values: valuesFromProps,
+  dataProviderName: dataProviderNameFromProps,
+  successNotification: successNotificationFromProps,
+  errorNotification: errorNotificationFromProps,
+  meta: metaFromProps,
+  metaData: metaDataFromProps,
+  mutationMode: mutationModeFromProps,
+  undoableTimeout: undoableTimeoutFromProps,
+  onCancel: onCancelFromProps,
+  optimisticUpdateMap: optimisticUpdateMapFromProps,
+  invalidates: invalidatesFromProps,
   mutationOptions,
   overtimeOptions,
 }: UseUpdateProps<TData, TError, TVariables> = {}): UseUpdateReturnType<
@@ -208,23 +223,27 @@ export const useUpdate = <
   } = useRefineContext();
   const { keys, preferLegacyKeys } = useKeys();
 
-  const mutation = useMutation<
+  const mutationResult = useMutation<
     UpdateResponse<TData>,
     TError,
     UpdateParams<TData, TError, TVariables>,
     UpdateContext<TData>
   >({
     mutationFn: ({
-      id,
-      values,
-      resource: resourceName,
-      mutationMode,
-      undoableTimeout,
-      onCancel,
-      meta,
-      metaData,
-      dataProviderName,
+      id = idFromProps,
+      values = valuesFromProps,
+      resource: resourceName = resourceFromProps,
+      mutationMode = mutationModeFromProps,
+      undoableTimeout = undoableTimeoutFromProps,
+      onCancel = onCancelFromProps,
+      meta = metaFromProps,
+      metaData = metaDataFromProps,
+      dataProviderName = dataProviderNameFromProps,
     }) => {
+      if (!id) throw missingIdError;
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { resource, identifier } = select(resourceName);
 
       const combinedMeta = getMeta({
@@ -289,15 +308,23 @@ export const useUpdate = <
       return updatePromise;
     },
     onMutate: async ({
-      resource: resourceName,
-      id,
-      mutationMode,
-      values,
-      dataProviderName,
-      meta,
-      metaData,
-      optimisticUpdateMap = { list: true, many: true, detail: true },
+      resource: resourceName = resourceFromProps,
+      id = idFromProps,
+      mutationMode = mutationModeFromProps,
+      values = valuesFromProps,
+      dataProviderName = dataProviderNameFromProps,
+      meta = metaFromProps,
+      metaData = metaDataFromProps,
+      optimisticUpdateMap = optimisticUpdateMapFromProps ?? {
+        list: true,
+        many: true,
+        detail: true,
+      },
     }) => {
+      if (!id) throw missingIdError;
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { identifier } = select(resourceName);
 
       const {
@@ -428,16 +455,16 @@ export const useUpdate = <
         queryKey,
       };
     },
-    onSettled: (
-      _data,
-      _error,
-      {
-        id,
-        resource: resourceName,
-        dataProviderName,
-        invalidates = ["list", "many", "detail"],
-      },
-    ) => {
+    onSettled: (data, error, variables, context) => {
+      const {
+        id = idFromProps,
+        resource: resourceName = resourceFromProps,
+        dataProviderName = dataProviderNameFromProps,
+        invalidates = invalidatesFromProps ?? ["list", "many", "detail"],
+      } = variables;
+      if (!id) throw missingIdError;
+      if (!resourceName) throw missingResourceError;
+
       const { identifier } = select(resourceName);
 
       invalidateStore({
@@ -455,20 +482,23 @@ export const useUpdate = <
         type: ActionTypes.REMOVE,
         payload: { id, resource: identifier },
       });
+
+      mutationOptions?.onSettled?.(data, error, variables, context);
     },
-    onSuccess: (
-      data,
-      {
-        id,
-        resource: resourceName,
-        successNotification,
-        dataProviderName: dataProviderNameFromProp,
-        values,
-        meta,
-        metaData,
-      },
-      context,
-    ) => {
+    onSuccess: (data, variables, context) => {
+      const {
+        id = idFromProps,
+        resource: resourceName = resourceFromProps,
+        successNotification = successNotificationFromProps,
+        dataProviderName: dataProviderNameFromProp = dataProviderNameFromProps,
+        values = valuesFromProps,
+        meta = metaFromProps,
+        metaData = metaDataFromProps,
+      } = variables;
+      if (!id) throw missingIdError;
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { resource, identifier } = select(resourceName);
       const resourceSingular = textTransformers.singular(identifier);
 
@@ -546,12 +576,20 @@ export const useUpdate = <
           ...rest,
         },
       });
+
+      mutationOptions?.onSuccess?.(data, variables, context);
     },
-    onError: (
-      err: TError,
-      { id, resource: resourceName, errorNotification, values },
-      context,
-    ) => {
+    onError: (err: TError, variables, context) => {
+      const {
+        id = idFromProps,
+        resource: resourceName = resourceFromProps,
+        errorNotification = errorNotificationFromProps,
+        values = valuesFromProps,
+      } = variables;
+      if (!id) throw missingIdError;
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { identifier } = select(resourceName);
 
       // set back the queries to the context:
@@ -588,6 +626,8 @@ export const useUpdate = <
           type: "error",
         });
       }
+
+      mutationOptions?.onError?.(err, variables, context);
     },
     mutationKey: keys().data().mutation("update").get(preferLegacyKeys),
     ...mutationOptions,
@@ -596,6 +636,7 @@ export const useUpdate = <
       ...getXRay("useUpdate", preferLegacyKeys),
     },
   });
+  const { mutate, mutateAsync, ...mutation } = mutationResult;
 
   const { elapsedTime } = useLoadingOvertime({
     isLoading: mutation.isLoading,
@@ -603,5 +644,48 @@ export const useUpdate = <
     onInterval: overtimeOptions?.onInterval,
   });
 
-  return { ...mutation, overtime: { elapsedTime } };
+  // this function is used to make the `variables` parameter optional
+  const handleMutation = (
+    variables?: UpdateParams<TData, TError, TVariables>,
+    options?: MutateOptions<
+      UpdateResponse<TData>,
+      TError,
+      UpdateParams<TData, TError, TVariables>,
+      UpdateContext<TData>
+    >,
+  ) => {
+    return mutate(variables || {}, options);
+  };
+
+  // this function is used to make the `variables` parameter optional
+  const handleMutateAsync = (
+    variables?: UpdateParams<TData, TError, TVariables>,
+    options?: MutateOptions<
+      UpdateResponse<TData>,
+      TError,
+      UpdateParams<TData, TError, TVariables>,
+      UpdateContext<TData>
+    >,
+  ) => {
+    return mutateAsync(variables || {}, options);
+  };
+
+  return {
+    ...mutation,
+    mutate: handleMutation,
+    mutateAsync: handleMutateAsync,
+    overtime: { elapsedTime },
+  };
 };
+
+const missingResourceError = new Error(
+  "[useUpdate]: `resource` is not defined or not matched but is required",
+);
+
+const missingIdError = new Error(
+  "[useUpdate]: `id` is not defined but is required in edit and clone actions",
+);
+
+const missingValuesError = new Error(
+  "[useUpdate]: `values` is not provided but is required",
+);

package/src/hooks/data/useUpdateMany.ts

@@ -1,7 +1,7 @@
 import { getXRay } from "@refinedev/devtools-internal";
 import {
   type UseMutationOptions,
-  type UseMutationResult,
+  type MutateOptions,
   useMutation,
   useQueryClient,
 } from "@tanstack/react-query";
@@ -43,6 +43,7 @@ import type {
   QueryResponse,
   UpdateManyResponse,
 } from "../../contexts/data/types";
+import type { UseMutationResult } from "../../definitions/types";
 import {
   type UseLoadingOvertimeOptionsProps,
   type UseLoadingOvertimeReturnType,
@@ -76,15 +77,15 @@ export type OptimisticUpdateManyMapType<TData, TVariables> = {
     | boolean;
 };
 
-type UpdateManyParams<TData, TError, TVariables> = {
+export type UpdateManyParams<TData, TError, TVariables> = {
   /**
    * ids for mutation function
    */
-  ids: BaseKey[];
+  ids?: BaseKey[];
   /**
    * Resource name for API data interactions
    */
-  resource: string;
+  resource?: string;
   /**
    * [Determines when mutations are executed](/advanced-tutorials/mutation-mode.md)
    */
@@ -100,7 +101,7 @@ type UpdateManyParams<TData, TError, TVariables> = {
   /**
    * Values for mutation function
    */
-  values: TVariables;
+  values?: TVariables;
   /**
    * meta data for `dataProvider`
    */
@@ -158,9 +159,10 @@ export type UseUpdateManyProps<
       UpdateManyParams<TData, TError, TVariables>,
       UpdateContext<TData>
     >,
-    "mutationFn" | "onError" | "onSuccess" | "onSettled" | "onMutate"
+    "mutationFn" | "onMutate"
   >;
-} & UseLoadingOvertimeOptionsProps;
+} & UseLoadingOvertimeOptionsProps &
+  UpdateManyParams<TData, TError, TVariables>;
 
 /**
  * `useUpdateMany` is a modified version of `react-query`'s {@link https://react-query.tanstack.com/reference/useMutation `useMutation`} for multiple update mutations.
@@ -179,6 +181,19 @@ export const useUpdateMany = <
   TError extends HttpError = HttpError,
   TVariables = {},
 >({
+  ids: idsFromProps,
+  resource: resourceFromProps,
+  values: valuesFromProps,
+  dataProviderName: dataProviderNameFromProps,
+  successNotification: successNotificationFromProps,
+  errorNotification: errorNotificationFromProps,
+  meta: metaFromProps,
+  metaData: metaDataFromProps,
+  mutationMode: mutationModeFromProps,
+  undoableTimeout: undoableTimeoutFromProps,
+  onCancel: onCancelFromProps,
+  optimisticUpdateMap: optimisticUpdateMapFromProps,
+  invalidates: invalidatesFromProps,
   mutationOptions,
   overtimeOptions,
 }: UseUpdateManyProps<TData, TError, TVariables> = {}): UseUpdateManyReturnType<
@@ -209,23 +224,27 @@ export const useUpdateMany = <
   } = useRefineContext();
   const { keys, preferLegacyKeys } = useKeys();
 
-  const mutation = useMutation<
+  const mutationResult = useMutation<
     UpdateManyResponse<TData>,
     TError,
     UpdateManyParams<TData, TError, TVariables>,
     UpdateContext<TData>
   >({
     mutationFn: ({
-      ids,
-      values,
-      resource: resourceName,
-      onCancel,
-      mutationMode,
-      undoableTimeout,
-      meta,
-      metaData,
-      dataProviderName,
+      ids = idsFromProps,
+      values = valuesFromProps,
+      resource: resourceName = resourceFromProps,
+      onCancel = onCancelFromProps,
+      mutationMode = mutationModeFromProps,
+      undoableTimeout = undoableTimeoutFromProps,
+      meta = metaFromProps,
+      metaData = metaDataFromProps,
+      dataProviderName = dataProviderNameFromProps,
     }: UpdateManyParams<TData, TError, TVariables>) => {
+      if (!ids) throw missingIdError;
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { resource, identifier } = select(resourceName);
 
       const combinedMeta = getMeta({
@@ -301,15 +320,23 @@ export const useUpdateMany = <
       return updatePromise;
     },
     onMutate: async ({
-      resource: resourceName,
-      ids,
-      values,
-      mutationMode,
-      dataProviderName,
-      meta,
-      metaData,
-      optimisticUpdateMap = { list: true, many: true, detail: true },
+      resource: resourceName = resourceFromProps,
+      ids = idsFromProps,
+      values = valuesFromProps,
+      mutationMode = mutationModeFromProps,
+      dataProviderName = dataProviderNameFromProps,
+      meta = metaFromProps,
+      metaData = metaDataFromProps,
+      optimisticUpdateMap = optimisticUpdateMapFromProps ?? {
+        list: true,
+        many: true,
+        detail: true,
+      },
     }) => {
+      if (!ids) throw missingIdError;
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { identifier } = select(resourceName);
       const {
         gqlMutation: _,
@@ -454,17 +481,22 @@ export const useUpdateMany = <
         queryKey,
       };
     },
-    onSettled: (
-      _data,
-      _error,
-      { ids, resource: resourceName, dataProviderName },
-    ) => {
+    onSettled: (data, error, variables, context) => {
+      const {
+        ids = idsFromProps,
+        resource: resourceName = resourceFromProps,
+        dataProviderName = dataProviderNameFromProps,
+        invalidates = invalidatesFromProps,
+      } = variables;
+      if (!ids) throw missingIdError;
+      if (!resourceName) throw missingResourceError;
+
       const { identifier } = select(resourceName);
 
       // invalidate the cache for the list and many queries:
       invalidateStore({
         resource: identifier,
-        invalidates: ["list", "many"],
+        invalidates: invalidates ?? ["list", "many"],
         dataProviderName: pickDataProvider(
           identifier,
           dataProviderName,
@@ -475,7 +507,7 @@ export const useUpdateMany = <
       ids.forEach((id) =>
         invalidateStore({
           resource: identifier,
-          invalidates: ["detail"],
+          invalidates: invalidates ?? ["detail"],
           dataProviderName: pickDataProvider(
             identifier,
             dataProviderName,
@@ -489,20 +521,23 @@ export const useUpdateMany = <
         type: ActionTypes.REMOVE,
         payload: { id: ids, resource: identifier },
       });
+
+      mutationOptions?.onSettled?.(data, error, variables, context);
     },
-    onSuccess: (
-      data,
-      {
-        ids,
-        resource: resourceName,
-        meta,
-        metaData,
-        dataProviderName: dataProviderNameFromProp,
-        successNotification,
-        values,
-      },
-      context,
-    ) => {
+    onSuccess: (data, variables, context) => {
+      const {
+        ids = idsFromProps,
+        resource: resourceName = resourceFromProps,
+        values = valuesFromProps,
+        meta = metaFromProps,
+        metaData = metaDataFromProps,
+        dataProviderName: dataProviderNameFromProp = dataProviderNameFromProps,
+        successNotification = successNotificationFromProps,
+      } = variables;
+      if (!ids) throw missingIdError;
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { resource, identifier } = select(resourceName);
       const resourceSingular = textTransformers.singular(identifier);
 
@@ -581,12 +616,20 @@ export const useUpdateMany = <
           ...rest,
         },
       });
+
+      mutationOptions?.onSuccess?.(data, variables, context);
     },
-    onError: (
-      err: TError,
-      { ids, resource: resourceName, errorNotification, values },
-      context,
-    ) => {
+    onError: (err: TError, variables, context) => {
+      const {
+        ids = idsFromProps,
+        resource: resourceName = resourceFromProps,
+        errorNotification = errorNotificationFromProps,
+        values = valuesFromProps,
+      } = variables;
+      if (!ids) throw missingIdError;
+      if (!values) throw missingValuesError;
+      if (!resourceName) throw missingResourceError;
+
       const { identifier } = select(resourceName);
 
       // set back the queries to the context:
@@ -620,6 +663,8 @@ export const useUpdateMany = <
           type: "error",
         });
       }
+
+      mutationOptions?.onError?.(err, variables, context);
     },
     mutationKey: keys().data().mutation("updateMany").get(preferLegacyKeys),
     ...mutationOptions,
@@ -628,6 +673,7 @@ export const useUpdateMany = <
       ...getXRay("useUpdateMany", preferLegacyKeys),
     },
   });
+  const { mutate, mutateAsync, ...mutation } = mutationResult;
 
   const { elapsedTime } = useLoadingOvertime({
     isLoading: mutation.isLoading,
@@ -635,5 +681,48 @@ export const useUpdateMany = <
     onInterval: overtimeOptions?.onInterval,
   });
 
-  return { ...mutation, overtime: { elapsedTime } };
+  // this function is used to make the `variables` parameter optional
+  const handleMutation = (
+    variables?: UpdateManyParams<TData, TError, TVariables>,
+    options?: MutateOptions<
+      UpdateManyResponse<TData>,
+      TError,
+      UpdateManyParams<TData, TError, TVariables>,
+      UpdateContext<TData>
+    >,
+  ) => {
+    return mutate(variables || {}, options);
+  };
+
+  // this function is used to make the `variables` parameter optional
+  const handleMutateAsync = (
+    variables?: UpdateManyParams<TData, TError, TVariables>,
+    options?: MutateOptions<
+      UpdateManyResponse<TData>,
+      TError,
+      UpdateManyParams<TData, TError, TVariables>,
+      UpdateContext<TData>
+    >,
+  ) => {
+    return mutateAsync(variables || {}, options);
+  };
+
+  return {
+    ...mutation,
+    mutate: handleMutation,
+    mutateAsync: handleMutateAsync,
+    overtime: { elapsedTime },
+  };
 };
+
+const missingResourceError = new Error(
+  "[useUpdateMany]: `resource` is not defined or not matched but is required",
+);
+
+const missingIdError = new Error(
+  "[useUpdateMany]: `id` is not defined but is required in edit and clone actions",
+);
+
+const missingValuesError = new Error(
+  "[useUpdateMany]: `values` is not provided but is required",
+);

package/src/hooks/form/index.ts

@@ -322,7 +322,9 @@ export const useForm = <
     onFinishAutoSave,
     formLoading,
     mutationResult,
+    mutation: mutationResult,
     queryResult,
+    query: queryResult,
     autoSaveProps,
     id,
     setId,

package/src/hooks/form/types.ts

@@ -226,7 +226,17 @@ export type UseFormReturnType<
 > = {
   id?: BaseKey;
   setId: Dispatch<SetStateAction<BaseKey | undefined>>;
+  query?: QueryObserverResult<GetOneResponse<TData>, TError>;
+  /**
+   * @deprecated use `query` instead
+   */
   queryResult?: QueryObserverResult<GetOneResponse<TData>, TError>;
+  mutation:
+    | UseUpdateReturnType<TResponse, TResponseError, TVariables>
+    | UseCreateReturnType<TResponse, TResponseError, TVariables>;
+  /**
+   * @deprecated use `mutation` instead
+   */
   mutationResult:
     | UseUpdateReturnType<TResponse, TResponseError, TVariables>
     | UseCreateReturnType<TResponse, TResponseError, TVariables>;

package/src/hooks/show/index.ts

@@ -82,6 +82,7 @@ export const useShow = <
 
   return {
     queryResult,
+    query: queryResult,
     showId,
     setShowId,
     overtime: { elapsedTime },

package/src/hooks/show/types.ts

@@ -24,6 +24,10 @@ export type UseShowReturnType<
   TData extends BaseRecord = BaseRecord,
   TError extends HttpError = HttpError,
 > = {
+  query: QueryObserverResult<GetOneResponse<TData>, TError>;
+  /**
+   * @deprecated Use `query` instead.
+   */
   queryResult: QueryObserverResult<GetOneResponse<TData>, TError>;
   showId?: BaseKey;
   setShowId: React.Dispatch<React.SetStateAction<BaseKey | undefined>>;