@strato-admin/core 0.1.1 → 0.3.0

package/dist/ra-core/src/dataProvider/useMutationWithMutationMode.d.ts

@@ -0,0 +1,51 @@
+import { UseMutationOptions, UseMutationResult, MutateOptions, QueryKey } from '@tanstack/react-query';
+import { MutationMode } from '../types';
+export declare const useMutationWithMutationMode: <ErrorType = Error, TData extends {
+    data?: unknown;
+} = {
+    data?: unknown;
+}, TVariables = unknown>(params: TVariables | undefined, options: UseMutationWithMutationModeOptions<ErrorType, TData, TVariables>) => UseMutationWithMutationModeResult<boolean, ErrorType, TData, TVariables>;
+export type Snapshot = [key: QueryKey, value: any][];
+type MutationFunction<TData extends {
+    data?: unknown;
+} = {
+    data?: unknown;
+}, TVariables = unknown> = (variables: TVariables) => Promise<TData>;
+export type UseMutationWithMutationModeOptions<ErrorType = Error, TData extends {
+    data?: unknown;
+} = {
+    data?: unknown;
+}, TVariables = unknown> = Omit<UseMutationOptions<TData['data'], ErrorType, Partial<TVariables>>, 'mutationFn'> & {
+    getMutateWithMiddlewares?: (mutate: MutationFunction<TData, TVariables>) => (params: TVariables) => Promise<TData>;
+    mutationFn?: MutationFunction<TData, TVariables>;
+    mutationMode?: MutationMode;
+    returnPromise?: boolean;
+    updateCache: <OptionsType extends {
+        mutationMode: MutationMode;
+    }>(params: Partial<TVariables>, options: OptionsType, mutationResult: TData['data'] | undefined) => TData['data'];
+    getQueryKeys: <OptionsType extends {
+        mutationMode: MutationMode;
+    }>(params: Partial<TVariables>, options: OptionsType) => Array<QueryKey>;
+    onUndo?: <OptionsType extends {
+        mutationMode: MutationMode;
+    }>(params: Partial<TVariables>, options: OptionsType) => void;
+};
+export type MutationFunctionWithOptions<TReturnPromise extends boolean = boolean, ErrorType = Error, TData extends {
+    data?: unknown;
+} = {
+    data?: unknown;
+}, TVariables = unknown> = (params?: Partial<TVariables>, options?: MutateOptions<TData['data'], ErrorType, Partial<TVariables>, unknown> & {
+    mutationMode?: MutationMode;
+    returnPromise?: TReturnPromise;
+}) => Promise<TReturnPromise extends true ? TData['data'] : void>;
+export type UseMutationWithMutationModeResult<TReturnPromise extends boolean = boolean, ErrorType = Error, TData extends {
+    data?: unknown;
+} = {
+    data?: unknown;
+}, TVariables = unknown> = [
+    MutationFunctionWithOptions<TReturnPromise, ErrorType, TData, TVariables>,
+    UseMutationResult<TData['data'], ErrorType, Partial<TVariables>, unknown> & {
+        isLoading: boolean;
+    }
+];
+export {};

package/dist/ra-core/src/dataProvider/useMutationWithMutationMode.js

@@ -0,0 +1,238 @@
+import { useEffect, useMemo, useRef } from 'react';
+import { useMutation, useQueryClient, } from '@tanstack/react-query';
+import { useAddUndoableMutation } from './undo/useAddUndoableMutation';
+import { useEvent } from '../util';
+export const useMutationWithMutationMode = (params = {}, options) => {
+    const queryClient = useQueryClient();
+    const addUndoableMutation = useAddUndoableMutation();
+    const { mutationKey, mutationMode = 'pessimistic', mutationFn, getMutateWithMiddlewares, updateCache, getQueryKeys, onUndo, ...mutationOptions } = options;
+    if (mutationFn == null) {
+        throw new Error('useMutationWithMutationMode mutation requires a mutationFn');
+    }
+    const mutationFnEvent = useEvent(mutationFn);
+    const updateCacheEvent = useEvent(updateCache);
+    const getQueryKeysEvent = useEvent(getQueryKeys);
+    const getSnapshotEvent = useEvent(
+    /**
+     * Snapshot the previous values via queryClient.getQueriesData()
+     *
+     * The snapshotData ref will contain an array of tuples [query key, associated data]
+     *
+     * @example
+     * [
+     *   [['posts', 'getList'], { data: [{ id: 1, title: 'Hello' }], total: 1 }],
+     *   [['posts', 'getMany'], [{ id: 1, title: 'Hello' }]],
+     * ]
+     *
+     * @see https://tanstack.com/query/v5/docs/react/reference/QueryClient#queryclientgetqueriesdata
+     */
+    (queryKeys) => queryKeys.reduce((prev, queryKey) => prev.concat(queryClient.getQueriesData({ queryKey })), []));
+    const onUndoEvent = useEvent(onUndo ?? noop);
+    const getMutateWithMiddlewaresEvent = useEvent(getMutateWithMiddlewares ??
+        noop);
+    const mode = useRef(mutationMode);
+    useEffect(() => {
+        mode.current = mutationMode;
+    }, [mutationMode]);
+    // This ref won't be updated when params change in an effect, only when the mutate callback is called (See L247)
+    // This ensures that for undoable and optimistic mutations, the params are not changed by side effects (unselectAll for instance)
+    // _after_ the mutate function has been called, while keeping the ability to change declaration time params _until_ the mutation is called.
+    const paramsRef = useRef(params);
+    // Ref that stores the snapshot of the state before the mutation to allow reverting it
+    const snapshot = useRef([]);
+    // Ref that stores the mutation with middlewares to avoid losing them if the calling component is unmounted
+    const mutateWithMiddlewares = useRef(mutationFnEvent);
+    // We need to store the call-time onError and onSettled in refs to be able to call them in the useMutation hook even
+    // when the calling component is unmounted
+    const callTimeOnError = useRef(undefined);
+    const callTimeOnSettled = useRef(undefined);
+    // We don't need to keep a ref on the onSuccess callback as we call it ourselves for optimistic and
+    // undoable mutations. There is a limitation though: if one of the side effects applied by the onSuccess callback
+    // unmounts the component that called the useUpdate hook (redirect for instance), it must be the last one applied,
+    // otherwise the other side effects may not applied.
+    const hasCallTimeOnSuccess = useRef(false);
+    const mutation = useMutation({
+        mutationKey,
+        mutationFn: async (params) => {
+            if (params == null) {
+                throw new Error('useMutationWithMutationMode mutation requires parameters');
+            }
+            return (mutateWithMiddlewares
+                .current(params)
+                // Middlewares expect the data property of the dataProvider response
+                .then(({ data }) => data));
+        },
+        ...mutationOptions,
+        onMutate: async (...args) => {
+            if (mutationOptions.onMutate) {
+                const userContext = (await mutationOptions.onMutate(...args)) || {};
+                return {
+                    snapshot: snapshot.current,
+                    // @ts-ignore
+                    ...userContext,
+                };
+            }
+            else {
+                // Return a context object with the snapshot value
+                return { snapshot: snapshot.current };
+            }
+        },
+        onError: (...args) => {
+            if (mode.current === 'optimistic' ||
+                mode.current === 'undoable') {
+                const [, , onMutateResult] = args;
+                // If the mutation fails, use the context returned from onMutate to rollback
+                onMutateResult.snapshot.forEach(([key, value]) => {
+                    queryClient.setQueryData(key, value);
+                });
+            }
+            if (callTimeOnError.current) {
+                return callTimeOnError.current(...args);
+            }
+            if (mutationOptions.onError) {
+                return mutationOptions.onError(...args);
+            }
+            // call-time error callback is executed by react-query
+        },
+        onSuccess: (...args) => {
+            if (mode.current === 'pessimistic') {
+                const [data, variables] = args;
+                // update the getOne and getList query cache with the new result
+                updateCacheEvent({ ...paramsRef.current, ...variables }, {
+                    mutationMode: mode.current,
+                }, data);
+                if (mutationOptions.onSuccess &&
+                    !hasCallTimeOnSuccess.current) {
+                    mutationOptions.onSuccess(...args);
+                }
+            }
+        },
+        onSettled: (...args) => {
+            if (mode.current === 'optimistic' ||
+                mode.current === 'undoable') {
+                const [, , variables] = args;
+                // Always refetch after error or success:
+                getQueryKeysEvent({ ...paramsRef.current, ...variables }, {
+                    mutationMode: mode.current,
+                }).forEach(queryKey => {
+                    queryClient.invalidateQueries({ queryKey });
+                });
+            }
+            if (callTimeOnSettled.current) {
+                return callTimeOnSettled.current(...args);
+            }
+            if (mutationOptions.onSettled) {
+                return mutationOptions.onSettled(...args);
+            }
+        },
+    });
+    const mutate = async (callTimeParams = {}, callTimeOptions = {}) => {
+        const { mutationMode, returnPromise = mutationOptions.returnPromise, onError, onSettled, onSuccess, ...otherCallTimeOptions } = callTimeOptions;
+        // store the hook time params *at the moment of the call*
+        // because they may change afterwards, which would break the undoable mode
+        // as the previousData would be overwritten by the optimistic update
+        paramsRef.current = params;
+        // Store the mutation with middlewares to avoid losing them if the calling component is unmounted
+        if (getMutateWithMiddlewares) {
+            mutateWithMiddlewares.current = getMutateWithMiddlewaresEvent((params) => {
+                return mutationFnEvent(params);
+            });
+        }
+        else {
+            mutateWithMiddlewares.current = mutationFnEvent;
+        }
+        // We need to keep the onSuccess callback here and not in the useMutation for undoable mutations
+        hasCallTimeOnSuccess.current = !!onSuccess;
+        // We need to store the onError and onSettled callbacks here to be able to call them in the useMutation hook
+        // so that they are called even when the calling component is unmounted
+        callTimeOnError.current = onError;
+        callTimeOnSettled.current = onSettled;
+        if (mutationMode) {
+            mode.current = mutationMode;
+        }
+        if (returnPromise && mode.current !== 'pessimistic') {
+            console.warn('The returnPromise parameter can only be used if the mutationMode is set to pessimistic');
+        }
+        snapshot.current = getSnapshotEvent(getQueryKeysEvent({ ...paramsRef.current, ...callTimeParams }, {
+            mutationMode: mode.current,
+        }));
+        if (mode.current === 'pessimistic') {
+            if (returnPromise) {
+                return mutation.mutateAsync({ ...paramsRef.current, ...callTimeParams }, 
+                // We don't pass onError and onSettled here as we will call them in the useMutation hook side effects
+                { onSuccess, ...otherCallTimeOptions });
+            }
+            return mutation.mutate({ ...paramsRef.current, ...callTimeParams }, 
+            // We don't pass onError and onSettled here as we will call them in the useMutation hook side effects
+            { onSuccess, ...otherCallTimeOptions });
+        }
+        // Cancel any outgoing re-fetches (so they don't overwrite our optimistic update)
+        await Promise.all(snapshot.current.map(([queryKey]) => queryClient.cancelQueries({ queryKey })));
+        // Optimistically update to the new value
+        const optimisticResult = updateCacheEvent({ ...paramsRef.current, ...callTimeParams }, {
+            mutationMode: mode.current,
+        }, undefined);
+        // run the success callbacks during the next tick
+        setTimeout(() => {
+            if (onSuccess) {
+                onSuccess(optimisticResult, { ...paramsRef.current, ...callTimeParams }, {
+                    snapshot: snapshot.current,
+                }, {
+                    client: queryClient,
+                    mutationKey,
+                    meta: mutationOptions.meta,
+                });
+            }
+            else if (mutationOptions.onSuccess &&
+                !hasCallTimeOnSuccess.current) {
+                mutationOptions.onSuccess(optimisticResult, { ...paramsRef.current, ...callTimeParams }, {
+                    snapshot: snapshot.current,
+                }, {
+                    client: queryClient,
+                    mutationKey,
+                    meta: mutationOptions.meta,
+                });
+            }
+        }, 0);
+        if (mode.current === 'optimistic') {
+            // call the mutate method without success side effects
+            return mutation.mutate({
+                ...paramsRef.current,
+                ...callTimeParams,
+            });
+        }
+        else {
+            // Undoable mutation: add the mutation to the undoable queue.
+            // The Notification component will dequeue it when the user confirms or cancels the message.
+            addUndoableMutation(({ isUndo }) => {
+                if (isUndo) {
+                    if (onUndo) {
+                        onUndoEvent({
+                            ...paramsRef.current,
+                            ...callTimeParams,
+                        }, {
+                            mutationMode: mode.current,
+                        });
+                    }
+                    // rollback
+                    snapshot.current.forEach(([key, value]) => {
+                        queryClient.setQueryData(key, value);
+                    });
+                }
+                else {
+                    // call the mutate method without success side effects
+                    mutation.mutate({
+                        ...paramsRef.current,
+                        ...callTimeParams,
+                    });
+                }
+            });
+        }
+    };
+    const mutationResult = useMemo(() => ({
+        isLoading: mutation.isPending,
+        ...mutation,
+    }), [mutation]);
+    return [useEvent(mutate), mutationResult];
+};
+const noop = () => { };

package/dist/ra-core/src/dataProvider/useRefresh.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Hook for triggering a page refresh. Returns a callback function.
+ *
+ * The callback invalidates all queries and refetches the active ones.
+ * Any component depending on react-query data will be re-rendered.
+ *
+ * @example
+ *
+ * const refresh = useRefresh();
+ * const handleClick = () => {
+ *     refresh();
+ * };
+ */
+export declare const useRefresh: () => () => void;

package/dist/ra-core/src/dataProvider/useRefresh.js

@@ -0,0 +1,21 @@
+import { useCallback } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+/**
+ * Hook for triggering a page refresh. Returns a callback function.
+ *
+ * The callback invalidates all queries and refetches the active ones.
+ * Any component depending on react-query data will be re-rendered.
+ *
+ * @example
+ *
+ * const refresh = useRefresh();
+ * const handleClick = () => {
+ *     refresh();
+ * };
+ */
+export const useRefresh = () => {
+    const queryClient = useQueryClient();
+    return useCallback(() => {
+        queryClient.invalidateQueries();
+    }, [queryClient]);
+};

package/dist/ra-core/src/dataProvider/useUpdate.d.ts

@@ -0,0 +1,89 @@
+import { type UseMutationResult, type MutateOptions, UseMutationOptions } from '@tanstack/react-query';
+import type { RaRecord, UpdateParams, MutationMode, DataProvider } from '../types';
+/**
+ * Get a callback to call the dataProvider.update() method, the result and the loading state.
+ *
+ * @param {string} resource
+ * @param {Params} params The update parameters { id, data, previousData, meta }
+ * @param {Object} options Options object to pass to the queryClient.
+ * May include side effects to be executed upon success or failure, e.g. { onSuccess: () => { refresh(); } }
+ * May include a mutation mode (optimistic/pessimistic/undoable), e.g. { mutationMode: 'undoable' }
+ *
+ * @typedef Params
+ * @prop params.id The resource identifier, e.g. 123
+ * @prop params.data The updates to merge into the record, e.g. { views: 10 }
+ * @prop params.previousData The record before the update is applied
+ * @prop params.meta Optional meta data
+ *
+ * @returns The current mutation state. Destructure as [update, { data, error, isPending }].
+ *
+ * The return value updates according to the request state:
+ *
+ * - initial: [update, { isPending: false, isIdle: true }]
+ * - start:   [update, { isPending: true }]
+ * - success: [update, { data: [data from response], isPending: false, isSuccess: true }]
+ * - error:   [update, { error: [error from response], isPending: false, isError: true }]
+ *
+ * The update() function must be called with a resource and a parameter object: update(resource, { id, data, previousData }, options)
+ *
+ * This hook uses react-query useMutation under the hood.
+ * This means the state object contains mutate, isIdle, reset and other react-query methods.
+ *
+ * @see https://react-query-v3.tanstack.com/reference/useMutation
+ *
+ * @example // set params when calling the update callback
+ *
+ * import { useUpdate, useRecordContext } from 'react-admin';
+ *
+ * const IncreaseLikeButton = () => {
+ *     const record = useRecordContext();
+ *     const diff = { likes: record.likes + 1 };
+ *     const [update, { isPending, error }] = useUpdate();
+ *     const handleClick = () => {
+ *         update('likes', { id: record.id, data: diff, previousData: record })
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Like</div>;
+ * };
+ *
+ * @example // set params when calling the hook
+ *
+ * import { useUpdate, useRecordContext } from 'react-admin';
+ *
+ * const IncreaseLikeButton = () => {
+ *     const record = useRecordContext();
+ *     const diff = { likes: record.likes + 1 };
+ *     const [update, { isPending, error }] = useUpdate('likes', { id: record.id, data: diff, previousData: record });
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={() => update()}>Like</button>;
+ * };
+ *
+ * @example // TypeScript
+ * const [update, { data }] = useUpdate<Product>('products', { id, data: diff, previousData: product });
+ *                    \-- data is Product
+ */
+export declare const useUpdate: <RecordType extends RaRecord = any, ErrorType = Error>(resource?: string, params?: Partial<UpdateParams<RecordType>>, options?: UseUpdateOptions<RecordType, ErrorType>) => UseUpdateResult<RecordType, boolean, ErrorType>;
+export interface UseUpdateMutateParams<RecordType extends RaRecord = any> {
+    resource?: string;
+    id?: RecordType['id'];
+    data?: Partial<RecordType>;
+    previousData?: any;
+    meta?: any;
+}
+export type UseUpdateOptions<RecordType extends RaRecord = any, ErrorType = Error> = Omit<UseMutationOptions<RecordType, ErrorType, Partial<UseUpdateMutateParams<RecordType>>>, 'mutationFn'> & {
+    mutationMode?: MutationMode;
+    returnPromise?: boolean;
+    getMutateWithMiddlewares?: <UpdateFunctionType extends DataProvider['update'] = DataProvider['update']>(mutate: UpdateFunctionType) => (...Params: Parameters<UpdateFunctionType>) => ReturnType<UpdateFunctionType>;
+};
+export type UpdateMutationFunction<RecordType extends RaRecord = any, TReturnPromise extends boolean = boolean, ErrorType = Error> = (resource?: string, params?: Partial<UpdateParams<RecordType>>, options?: MutateOptions<RecordType, ErrorType, Partial<UseUpdateMutateParams<RecordType>>, unknown> & {
+    mutationMode?: MutationMode;
+    returnPromise?: TReturnPromise;
+}) => Promise<TReturnPromise extends true ? RecordType : void>;
+export type UseUpdateResult<RecordType extends RaRecord = any, TReturnPromise extends boolean = boolean, ErrorType = Error> = [
+    UpdateMutationFunction<RecordType, TReturnPromise, ErrorType>,
+    UseMutationResult<RecordType, ErrorType, Partial<UpdateParams<RecordType> & {
+        resource?: string;
+    }>, unknown> & {
+        isLoading: boolean;
+    }
+];

package/dist/ra-core/src/dataProvider/useUpdate.js

@@ -0,0 +1,183 @@
+import { useQueryClient, } from '@tanstack/react-query';
+import { useDataProvider } from './useDataProvider';
+import { useMutationWithMutationMode } from './useMutationWithMutationMode';
+import { useEvent } from '../util';
+/**
+ * Get a callback to call the dataProvider.update() method, the result and the loading state.
+ *
+ * @param {string} resource
+ * @param {Params} params The update parameters { id, data, previousData, meta }
+ * @param {Object} options Options object to pass to the queryClient.
+ * May include side effects to be executed upon success or failure, e.g. { onSuccess: () => { refresh(); } }
+ * May include a mutation mode (optimistic/pessimistic/undoable), e.g. { mutationMode: 'undoable' }
+ *
+ * @typedef Params
+ * @prop params.id The resource identifier, e.g. 123
+ * @prop params.data The updates to merge into the record, e.g. { views: 10 }
+ * @prop params.previousData The record before the update is applied
+ * @prop params.meta Optional meta data
+ *
+ * @returns The current mutation state. Destructure as [update, { data, error, isPending }].
+ *
+ * The return value updates according to the request state:
+ *
+ * - initial: [update, { isPending: false, isIdle: true }]
+ * - start:   [update, { isPending: true }]
+ * - success: [update, { data: [data from response], isPending: false, isSuccess: true }]
+ * - error:   [update, { error: [error from response], isPending: false, isError: true }]
+ *
+ * The update() function must be called with a resource and a parameter object: update(resource, { id, data, previousData }, options)
+ *
+ * This hook uses react-query useMutation under the hood.
+ * This means the state object contains mutate, isIdle, reset and other react-query methods.
+ *
+ * @see https://react-query-v3.tanstack.com/reference/useMutation
+ *
+ * @example // set params when calling the update callback
+ *
+ * import { useUpdate, useRecordContext } from 'react-admin';
+ *
+ * const IncreaseLikeButton = () => {
+ *     const record = useRecordContext();
+ *     const diff = { likes: record.likes + 1 };
+ *     const [update, { isPending, error }] = useUpdate();
+ *     const handleClick = () => {
+ *         update('likes', { id: record.id, data: diff, previousData: record })
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Like</div>;
+ * };
+ *
+ * @example // set params when calling the hook
+ *
+ * import { useUpdate, useRecordContext } from 'react-admin';
+ *
+ * const IncreaseLikeButton = () => {
+ *     const record = useRecordContext();
+ *     const diff = { likes: record.likes + 1 };
+ *     const [update, { isPending, error }] = useUpdate('likes', { id: record.id, data: diff, previousData: record });
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={() => update()}>Like</button>;
+ * };
+ *
+ * @example // TypeScript
+ * const [update, { data }] = useUpdate<Product>('products', { id, data: diff, previousData: product });
+ *                    \-- data is Product
+ */
+export const useUpdate = (resource, params = {}, options = {}) => {
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const { mutationMode = 'pessimistic', getMutateWithMiddlewares, ...mutationOptions } = options;
+    const dataProviderUpdate = useEvent((resource, params) => dataProvider.update(resource, params));
+    const [mutate, mutationResult] = useMutationWithMutationMode({ resource, ...params }, {
+        ...mutationOptions,
+        mutationKey: [resource, 'update', params],
+        mutationMode,
+        mutationFn: ({ resource, ...params }) => {
+            if (resource == null) {
+                throw new Error('useUpdate mutation requires a resource');
+            }
+            if (params.id == null) {
+                throw new Error('useUpdate mutation requires a non-empty id');
+            }
+            if (!params.data) {
+                throw new Error('useUpdate mutation requires a non-empty data object');
+            }
+            return dataProviderUpdate(resource, params);
+        },
+        updateCache: ({ resource, ...params }, { mutationMode }, result) => {
+            // hack: only way to tell react-query not to fetch this query for the next 5 seconds
+            // because setQueryData doesn't accept a stale time option
+            const now = Date.now();
+            const updatedAt = mutationMode === 'undoable' ? now + 5 * 1000 : now;
+            // Stringify and parse the data to remove undefined values.
+            // If we don't do this, an update with { id: undefined } as payload
+            // would remove the id from the record, which no real data provider does.
+            const clonedData = JSON.parse(JSON.stringify(mutationMode === 'pessimistic' ? result : params?.data));
+            const updateColl = (old) => {
+                if (!old)
+                    return old;
+                const index = old.findIndex(
+                // eslint-disable-next-line eqeqeq
+                record => record.id == params?.id);
+                if (index === -1) {
+                    return old;
+                }
+                return [
+                    ...old.slice(0, index),
+                    { ...old[index], ...clonedData },
+                    ...old.slice(index + 1),
+                ];
+            };
+            const previousRecord = queryClient.getQueryData([
+                resource,
+                'getOne',
+                { id: String(params?.id), meta: params?.meta },
+            ]);
+            queryClient.setQueryData([
+                resource,
+                'getOne',
+                { id: String(params?.id), meta: params?.meta },
+            ], (record) => ({
+                ...record,
+                ...clonedData,
+            }), { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getList'] }, (res) => res && res.data
+                ? { ...res, data: updateColl(res.data) }
+                : res, { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getInfiniteList'] }, (res) => res && res.pages
+                ? {
+                    ...res,
+                    pages: res.pages.map(page => ({
+                        ...page,
+                        data: updateColl(page.data),
+                    })),
+                }
+                : res, { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getMany'] }, (coll) => coll && coll.length > 0 ? updateColl(coll) : coll, { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getManyReference'] }, (res) => res && res.data
+                ? { ...res, data: updateColl(res.data) }
+                : res, { updatedAt });
+            const optimisticResult = {
+                ...previousRecord,
+                ...clonedData,
+            };
+            return optimisticResult;
+        },
+        getQueryKeys: ({ resource, ...params }) => {
+            const queryKeys = [
+                [
+                    resource,
+                    'getOne',
+                    { id: String(params?.id), meta: params?.meta },
+                ],
+                [resource, 'getList'],
+                [resource, 'getInfiniteList'],
+                [resource, 'getMany'],
+                [resource, 'getManyReference'],
+            ];
+            return queryKeys;
+        },
+        getMutateWithMiddlewares: mutationFn => {
+            if (getMutateWithMiddlewares) {
+                // Immediately get the function with middlewares applied so that even if the middlewares gets unregistered (because of a redirect for instance),
+                // we still have them applied when users have called the mutate function.
+                const mutateWithMiddlewares = getMutateWithMiddlewares(dataProviderUpdate.bind(dataProvider));
+                return args => {
+                    // This is necessary to avoid breaking changes in useUpdate:
+                    // The mutation function must have the same signature as before (resource, params) and not ({ resource, params })
+                    const { resource, ...params } = args;
+                    return mutateWithMiddlewares(resource, params);
+                };
+            }
+            return args => mutationFn(args);
+        },
+    });
+    const update = useEvent((callTimeResource = resource, callTimeParams = {}, callTimeOptions = {}) => {
+        return mutate({
+            resource: callTimeResource,
+            ...callTimeParams,
+        }, callTimeOptions);
+    });
+    return [update, mutationResult];
+};