@refinedev/core 4.46.1 → 4.46.2

package/src/hooks/data/useUpdate.ts

@@ -189,8 +189,8 @@ export const useUpdate = <
         TError,
         UpdateParams<TData, TError, TVariables>,
         UpdateContext<TData>
-    >(
-        ({
+    >({
+        mutationFn: ({
             id,
             values,
             resource: resourceName,
@@ -269,363 +269,336 @@ export const useUpdate = <
             );
             return updatePromise;
         },
-        {
-            onMutate: async ({
-                resource: resourceName,
-                id,
-                mutationMode,
-                values,
-                dataProviderName,
-                meta,
-                metaData,
-                optimisticUpdateMap = { list: true, many: true, detail: true },
-            }) => {
-                const { identifier } = select(resourceName);
+        onMutate: async ({
+            resource: resourceName,
+            id,
+            mutationMode,
+            values,
+            dataProviderName,
+            meta,
+            metaData,
+            optimisticUpdateMap = { list: true, many: true, detail: true },
+        }) => {
+            const { identifier } = select(resourceName);
+
+            const {
+                gqlMutation: _,
+                gqlQuery: __,
+                ...preferredMeta
+            } = pickNotDeprecated(meta, metaData) ?? {};
+
+            const queryKey = queryKeysReplacement(preferLegacyKeys)(
+                identifier,
+                pickDataProvider(identifier, dataProviderName, resources),
+                preferredMeta,
+            );
 
-                const {
-                    gqlMutation: _,
-                    gqlQuery: __,
-                    ...preferredMeta
-                } = pickNotDeprecated(meta, metaData) ?? {};
+            const resourceKeys = keys()
+                .data(pickDataProvider(identifier, dataProviderName, resources))
+                .resource(identifier);
 
-                const queryKey = queryKeysReplacement(preferLegacyKeys)(
-                    identifier,
-                    pickDataProvider(identifier, dataProviderName, resources),
-                    preferredMeta,
-                );
+            const previousQueries: PreviousQuery<TData>[] =
+                queryClient.getQueriesData(resourceKeys.get(preferLegacyKeys));
 
-                const resourceKeys = keys()
-                    .data(
-                        pickDataProvider(
-                            identifier,
-                            dataProviderName,
-                            resources,
-                        ),
-                    )
-                    .resource(identifier);
+            const mutationModePropOrContext =
+                mutationMode ?? mutationModeContext;
 
-                const previousQueries: PreviousQuery<TData>[] =
-                    queryClient.getQueriesData(
-                        resourceKeys.get(preferLegacyKeys),
-                    );
+            await queryClient.cancelQueries(
+                resourceKeys.get(preferLegacyKeys),
+                undefined,
+                {
+                    silent: true,
+                },
+            );
 
-                const mutationModePropOrContext =
-                    mutationMode ?? mutationModeContext;
+            if (mutationModePropOrContext !== "pessimistic") {
+                if (optimisticUpdateMap.list) {
+                    // Set the previous queries to the new ones:
+                    queryClient.setQueriesData(
+                        resourceKeys
+                            .action("list")
+                            .params(preferredMeta ?? {})
+                            .get(preferLegacyKeys),
+                        (previous?: GetListResponse<TData> | null) => {
+                            if (
+                                typeof optimisticUpdateMap.list === "function"
+                            ) {
+                                return optimisticUpdateMap.list(
+                                    previous,
+                                    values,
+                                    id,
+                                );
+                            }
 
-                await queryClient.cancelQueries(
-                    resourceKeys.get(preferLegacyKeys),
-                    undefined,
-                    {
-                        silent: true,
-                    },
-                );
+                            if (!previous) {
+                                return null;
+                            }
 
-                if (mutationModePropOrContext !== "pessimistic") {
-                    if (optimisticUpdateMap.list) {
-                        // Set the previous queries to the new ones:
-                        queryClient.setQueriesData(
-                            resourceKeys
-                                .action("list")
-                                .params(preferredMeta ?? {})
-                                .get(preferLegacyKeys),
-                            (previous?: GetListResponse<TData> | null) => {
-                                if (
-                                    typeof optimisticUpdateMap.list ===
-                                    "function"
-                                ) {
-                                    return optimisticUpdateMap.list(
-                                        previous,
-                                        values,
+                            const data = previous.data.map((record: TData) => {
+                                if (record.id?.toString() === id?.toString()) {
+                                    return {
                                         id,
-                                    );
+                                        ...record,
+                                        ...values,
+                                    } as unknown as TData;
                                 }
+                                return record;
+                            });
 
-                                if (!previous) {
-                                    return null;
-                                }
+                            return {
+                                ...previous,
+                                data,
+                            };
+                        },
+                    );
+                }
 
-                                const data = previous.data.map(
-                                    (record: TData) => {
-                                        if (
-                                            record.id?.toString() ===
-                                            id?.toString()
-                                        ) {
-                                            return {
-                                                id,
-                                                ...record,
-                                                ...values,
-                                            } as unknown as TData;
-                                        }
-                                        return record;
-                                    },
+                if (optimisticUpdateMap.many) {
+                    queryClient.setQueriesData(
+                        resourceKeys.action("many").get(preferLegacyKeys),
+                        (previous?: GetManyResponse<TData> | null) => {
+                            if (
+                                typeof optimisticUpdateMap.many === "function"
+                            ) {
+                                return optimisticUpdateMap.many(
+                                    previous,
+                                    values,
+                                    id,
                                 );
+                            }
 
-                                return {
-                                    ...previous,
-                                    data,
-                                };
-                            },
-                        );
-                    }
+                            if (!previous) {
+                                return null;
+                            }
 
-                    if (optimisticUpdateMap.many) {
-                        queryClient.setQueriesData(
-                            resourceKeys.action("many").get(preferLegacyKeys),
-                            (previous?: GetManyResponse<TData> | null) => {
-                                if (
-                                    typeof optimisticUpdateMap.many ===
-                                    "function"
-                                ) {
-                                    return optimisticUpdateMap.many(
-                                        previous,
-                                        values,
+                            const data = previous.data.map((record: TData) => {
+                                if (record.id?.toString() === id?.toString()) {
+                                    record = {
                                         id,
-                                    );
-                                }
-
-                                if (!previous) {
-                                    return null;
+                                        ...record,
+                                        ...values,
+                                    } as unknown as TData;
                                 }
+                                return record;
+                            });
+                            return {
+                                ...previous,
+                                data,
+                            };
+                        },
+                    );
+                }
 
-                                const data = previous.data.map(
-                                    (record: TData) => {
-                                        if (
-                                            record.id?.toString() ===
-                                            id?.toString()
-                                        ) {
-                                            record = {
-                                                id,
-                                                ...record,
-                                                ...values,
-                                            } as unknown as TData;
-                                        }
-                                        return record;
-                                    },
+                if (optimisticUpdateMap.detail) {
+                    queryClient.setQueriesData(
+                        resourceKeys
+                            .action("one")
+                            .id(id)
+                            .params(preferredMeta ?? {})
+                            .get(preferLegacyKeys),
+                        (previous?: GetOneResponse<TData> | null) => {
+                            if (
+                                typeof optimisticUpdateMap.detail === "function"
+                            ) {
+                                return optimisticUpdateMap.detail(
+                                    previous,
+                                    values,
+                                    id,
                                 );
-                                return {
-                                    ...previous,
-                                    data,
-                                };
-                            },
-                        );
-                    }
-
-                    if (optimisticUpdateMap.detail) {
-                        queryClient.setQueriesData(
-                            resourceKeys
-                                .action("one")
-                                .id(id)
-                                .params(preferredMeta ?? {})
-                                .get(preferLegacyKeys),
-                            (previous?: GetOneResponse<TData> | null) => {
-                                if (
-                                    typeof optimisticUpdateMap.detail ===
-                                    "function"
-                                ) {
-                                    return optimisticUpdateMap.detail(
-                                        previous,
-                                        values,
-                                        id,
-                                    );
-                                }
+                            }
+
+                            if (!previous) {
+                                return null;
+                            }
+
+                            return {
+                                ...previous,
+                                data: {
+                                    ...previous.data,
+                                    ...values,
+                                },
+                            };
+                        },
+                    );
+                }
+            }
 
-                                if (!previous) {
-                                    return null;
-                                }
+            return {
+                previousQueries,
+                queryKey,
+            };
+        },
+        onSettled: (
+            _data,
+            _error,
+            {
+                id,
+                resource: resourceName,
+                dataProviderName,
+                invalidates = ["list", "many", "detail"],
+            },
+        ) => {
+            const { identifier } = select(resourceName);
 
-                                return {
-                                    ...previous,
-                                    data: {
-                                        ...previous.data,
-                                        ...values,
-                                    },
-                                };
-                            },
-                        );
-                    }
-                }
+            invalidateStore({
+                resource: identifier,
+                dataProviderName: pickDataProvider(
+                    identifier,
+                    dataProviderName,
+                    resources,
+                ),
+                invalidates,
+                id,
+            });
 
-                return {
-                    previousQueries,
-                    queryKey,
-                };
+            notificationDispatch({
+                type: ActionTypes.REMOVE,
+                payload: { id, resource: identifier },
+            });
+        },
+        onSuccess: (
+            data,
+            {
+                id,
+                resource: resourceName,
+                successNotification,
+                dataProviderName: dataProviderNameFromProp,
+                values,
+                meta,
+                metaData,
             },
-            onSettled: (
-                _data,
-                _error,
-                {
-                    id,
-                    resource: resourceName,
+            context,
+        ) => {
+            const { resource, identifier } = select(resourceName);
+            const resourceSingular = textTransformers.singular(identifier);
+
+            const dataProviderName = pickDataProvider(
+                identifier,
+                dataProviderNameFromProp,
+                resources,
+            );
+
+            const combinedMeta = getMeta({
+                resource,
+                meta: pickNotDeprecated(meta, metaData),
+            });
+
+            const notificationConfig =
+                typeof successNotification === "function"
+                    ? successNotification(data, { id, values }, identifier)
+                    : successNotification;
+
+            handleNotification(notificationConfig, {
+                key: `${id}-${identifier}-notification`,
+                description: translate("notifications.success", "Successful"),
+                message: translate(
+                    "notifications.editSuccess",
+                    {
+                        resource: translate(
+                            `${identifier}.${identifier}`,
+                            resourceSingular,
+                        ),
+                    },
+                    `Successfully updated ${resourceSingular}`,
+                ),
+                type: "success",
+            });
+
+            publish?.({
+                channel: `resources/${resource.name}`,
+                type: "updated",
+                payload: {
+                    ids: data.data?.id ? [data.data.id] : undefined,
+                },
+                date: new Date(),
+                meta: {
+                    ...combinedMeta,
                     dataProviderName,
-                    invalidates = ["list", "many", "detail"],
                 },
-            ) => {
-                const { identifier } = select(resourceName);
-
-                invalidateStore({
-                    resource: identifier,
-                    dataProviderName: pickDataProvider(
-                        identifier,
-                        dataProviderName,
-                        resources,
-                    ),
-                    invalidates,
-                    id,
-                });
+            });
 
-                notificationDispatch({
-                    type: ActionTypes.REMOVE,
-                    payload: { id, resource: identifier },
-                });
-            },
-            onSuccess: (
-                data,
-                {
+            let previousData: any;
+            if (context) {
+                const queryData = queryClient.getQueryData<
+                    UpdateResponse<TData>
+                >(context.queryKey.detail(id));
+
+                previousData = Object.keys(values || {}).reduce<any>(
+                    (acc, item) => {
+                        acc[item] = queryData?.data?.[item];
+                        return acc;
+                    },
+                    {},
+                );
+            }
+
+            const {
+                fields: _fields,
+                operation: _operation,
+                variables: _variables,
+                ...rest
+            } = combinedMeta || {};
+            log?.mutate({
+                action: "update",
+                resource: resource.name,
+                data: values,
+                previousData,
+                meta: {
                     id,
-                    resource: resourceName,
-                    successNotification,
-                    dataProviderName: dataProviderNameFromProp,
-                    values,
-                    meta,
-                    metaData,
+                    dataProviderName,
+                    ...rest,
                 },
-                context,
-            ) => {
-                const { resource, identifier } = select(resourceName);
-                const resourceSingular = textTransformers.singular(identifier);
+            });
+        },
+        onError: (
+            err: TError,
+            { id, resource: resourceName, errorNotification, values },
+            context,
+        ) => {
+            const { identifier } = select(resourceName);
+
+            // set back the queries to the context:
+            if (context) {
+                for (const query of context.previousQueries) {
+                    queryClient.setQueryData(query[0], query[1]);
+                }
+            }
 
-                const dataProviderName = pickDataProvider(
-                    identifier,
-                    dataProviderNameFromProp,
-                    resources,
-                );
+            if (err.message !== "mutationCancelled") {
+                checkError?.(err);
 
-                const combinedMeta = getMeta({
-                    resource,
-                    meta: pickNotDeprecated(meta, metaData),
-                });
+                const resourceSingular = textTransformers.singular(identifier);
 
                 const notificationConfig =
-                    typeof successNotification === "function"
-                        ? successNotification(data, { id, values }, identifier)
-                        : successNotification;
+                    typeof errorNotification === "function"
+                        ? errorNotification(err, { id, values }, identifier)
+                        : errorNotification;
 
                 handleNotification(notificationConfig, {
                     key: `${id}-${identifier}-notification`,
-                    description: translate(
-                        "notifications.success",
-                        "Successful",
-                    ),
                     message: translate(
-                        "notifications.editSuccess",
+                        "notifications.editError",
                         {
                             resource: translate(
                                 `${identifier}.${identifier}`,
                                 resourceSingular,
                             ),
+                            statusCode: err.statusCode,
                         },
-                        `Successfully updated ${resourceSingular}`,
+                        `Error when updating ${resourceSingular} (status code: ${err.statusCode})`,
                     ),
-                    type: "success",
-                });
-
-                publish?.({
-                    channel: `resources/${resource.name}`,
-                    type: "updated",
-                    payload: {
-                        ids: data.data?.id ? [data.data.id] : undefined,
-                    },
-                    date: new Date(),
-                    meta: {
-                        ...combinedMeta,
-                        dataProviderName,
-                    },
-                });
-
-                let previousData: any;
-                if (context) {
-                    const queryData = queryClient.getQueryData<
-                        UpdateResponse<TData>
-                    >(context.queryKey.detail(id));
-
-                    previousData = Object.keys(values || {}).reduce<any>(
-                        (acc, item) => {
-                            acc[item] = queryData?.data?.[item];
-                            return acc;
-                        },
-                        {},
-                    );
-                }
-
-                const {
-                    fields: _fields,
-                    operation: _operation,
-                    variables: _variables,
-                    ...rest
-                } = combinedMeta || {};
-                log?.mutate({
-                    action: "update",
-                    resource: resource.name,
-                    data: values,
-                    previousData,
-                    meta: {
-                        id,
-                        dataProviderName,
-                        ...rest,
-                    },
+                    description: err.message,
+                    type: "error",
                 });
-            },
-            onError: (
-                err: TError,
-                { id, resource: resourceName, errorNotification, values },
-                context,
-            ) => {
-                const { identifier } = select(resourceName);
-
-                // set back the queries to the context:
-                if (context) {
-                    for (const query of context.previousQueries) {
-                        queryClient.setQueryData(query[0], query[1]);
-                    }
-                }
-
-                if (err.message !== "mutationCancelled") {
-                    checkError?.(err);
-
-                    const resourceSingular =
-                        textTransformers.singular(identifier);
-
-                    const notificationConfig =
-                        typeof errorNotification === "function"
-                            ? errorNotification(err, { id, values }, identifier)
-                            : errorNotification;
-
-                    handleNotification(notificationConfig, {
-                        key: `${id}-${identifier}-notification`,
-                        message: translate(
-                            "notifications.editError",
-                            {
-                                resource: translate(
-                                    `${identifier}.${identifier}`,
-                                    resourceSingular,
-                                ),
-                                statusCode: err.statusCode,
-                            },
-                            `Error when updating ${resourceSingular} (status code: ${err.statusCode})`,
-                        ),
-                        description: err.message,
-                        type: "error",
-                    });
-                }
-            },
-            mutationKey: keys().data().mutation("update").get(preferLegacyKeys),
-            ...mutationOptions,
-            meta: {
-                ...mutationOptions?.meta,
-                ...getXRay("useUpdate", preferLegacyKeys),
-            },
+            }
         },
-    );
+        mutationKey: keys().data().mutation("update").get(preferLegacyKeys),
+        ...mutationOptions,
+        meta: {
+            ...mutationOptions?.meta,
+            ...getXRay("useUpdate", preferLegacyKeys),
+        },
+    });
 
     const { elapsedTime } = useLoadingOvertime({
         isLoading: mutation.isLoading,