@strato-admin/faker-ecommerce 0.1.1 → 0.3.0

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

@@ -0,0 +1,64 @@
+import { InfiniteData, QueryKey, UseInfiniteQueryOptions, UseInfiniteQueryResult } from '@tanstack/react-query';
+import { RaRecord, GetListParams, GetInfiniteListResult } from '../types';
+/**
+ * Call the dataProvider.getList() method and return the resolved result
+ * as well as the loading state. The return from useInfiniteGetList is equivalent to the return from react-hook form useInfiniteQuery.
+ *
+ * @see https://tanstack.com/query/v5/docs/react/reference/useInfiniteQuery
+ *
+ * This hook will return the cached result when called a second time
+ * with the same parameters, until the response arrives.
+ *
+ * @param {string} resource The resource name, e.g. 'posts'
+ * @param {Params} params The getList parameters { pagination, sort, filter, 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: () => { fetchNextPage(); } }
+ *
+ * @typedef Params
+ * @prop params.pagination The request pagination { page, perPage }, e.g. { page: 1, perPage: 10 }
+ * @prop params.sort The request sort { field, order }, e.g. { field: 'id', order: 'DESC' }
+ * @prop params.filter The request filters, e.g. { title: 'hello, world' }
+ * @prop params.meta Optional meta parameters
+ *
+ * @returns The current request state. Destructure as { data, total, error, isPending, isSuccess, hasNextPage, fetchNextPage }.
+ *
+ * @example
+ *
+ * import { useInfiniteGetList } from 'react-admin';
+ *
+ * const LatestNews = () => {
+ *     const { data, total, isPending, error, hasNextPage, fetchNextPage } = useInfiniteGetList(
+ *         'posts',
+ *         { pagination: { page: 1, perPage: 10 }, sort: { field: 'published_at', order: 'DESC' } }
+ *     );
+ *     if (isPending) { return <Loading />; }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return (
+ *        <>
+ *            <ul>
+ *                {data?.pages.map(page => {
+ *                    return page.data.map(post => (
+ *                        <li key={post.id}>{post.title}</li>
+ *                    ));
+ *                })}
+ *            </ul>
+ *            <div>
+ *                <button disabled={!hasNextPage} onClick={() => fetchNextPage()}>
+ *                    Fetch next page
+ *                </button>
+ *            </div>
+ *        </>
+ *    );
+ * };
+ */
+export declare const useInfiniteGetList: <RecordType extends RaRecord = any, ErrorType = Error>(resource: string, params?: Partial<GetListParams>, options?: UseInfiniteGetListOptions<RecordType, ErrorType>) => UseInfiniteGetListHookValue<RecordType, ErrorType>;
+export type UseInfiniteGetListOptions<RecordType extends RaRecord = any, ErrorType = Error> = Omit<UseInfiniteQueryOptions<GetInfiniteListResult<RecordType>, ErrorType, InfiniteData<GetInfiniteListResult<RecordType>>, QueryKey, number>, 'queryKey' | 'queryFn' | 'getNextPageParam' | 'getPreviousPageParam' | 'initialPageParam'> & {
+    onSuccess?: (data: InfiniteData<GetInfiniteListResult<RecordType>>) => void;
+    onError?: (error: ErrorType) => void;
+    onSettled?: (data?: InfiniteData<GetInfiniteListResult<RecordType>>, error?: ErrorType | null) => void;
+};
+export type UseInfiniteGetListHookValue<RecordType extends RaRecord = any, ErrorType = Error> = UseInfiniteQueryResult<InfiniteData<GetInfiniteListResult<RecordType>>, ErrorType> & {
+    total?: number;
+    pageParam?: number;
+    meta?: any;
+};

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

@@ -0,0 +1,177 @@
+import { useInfiniteQuery, useQueryClient, } from '@tanstack/react-query';
+import { useDataProvider } from './useDataProvider';
+import { useEffect, useRef } from 'react';
+import { useEvent } from '../util';
+const MAX_DATA_LENGTH_TO_CACHE = 100;
+/**
+ * Call the dataProvider.getList() method and return the resolved result
+ * as well as the loading state. The return from useInfiniteGetList is equivalent to the return from react-hook form useInfiniteQuery.
+ *
+ * @see https://tanstack.com/query/v5/docs/react/reference/useInfiniteQuery
+ *
+ * This hook will return the cached result when called a second time
+ * with the same parameters, until the response arrives.
+ *
+ * @param {string} resource The resource name, e.g. 'posts'
+ * @param {Params} params The getList parameters { pagination, sort, filter, 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: () => { fetchNextPage(); } }
+ *
+ * @typedef Params
+ * @prop params.pagination The request pagination { page, perPage }, e.g. { page: 1, perPage: 10 }
+ * @prop params.sort The request sort { field, order }, e.g. { field: 'id', order: 'DESC' }
+ * @prop params.filter The request filters, e.g. { title: 'hello, world' }
+ * @prop params.meta Optional meta parameters
+ *
+ * @returns The current request state. Destructure as { data, total, error, isPending, isSuccess, hasNextPage, fetchNextPage }.
+ *
+ * @example
+ *
+ * import { useInfiniteGetList } from 'react-admin';
+ *
+ * const LatestNews = () => {
+ *     const { data, total, isPending, error, hasNextPage, fetchNextPage } = useInfiniteGetList(
+ *         'posts',
+ *         { pagination: { page: 1, perPage: 10 }, sort: { field: 'published_at', order: 'DESC' } }
+ *     );
+ *     if (isPending) { return <Loading />; }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return (
+ *        <>
+ *            <ul>
+ *                {data?.pages.map(page => {
+ *                    return page.data.map(post => (
+ *                        <li key={post.id}>{post.title}</li>
+ *                    ));
+ *                })}
+ *            </ul>
+ *            <div>
+ *                <button disabled={!hasNextPage} onClick={() => fetchNextPage()}>
+ *                    Fetch next page
+ *                </button>
+ *            </div>
+ *        </>
+ *    );
+ * };
+ */
+export const useInfiniteGetList = (resource, params = {}, options = {}) => {
+    const { pagination = { page: 1, perPage: 25 }, sort = { field: 'id', order: 'DESC' }, filter = {}, meta, } = params;
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const { onSuccess = noop, onError = noop, onSettled = noop, ...queryOptions } = options;
+    const onSuccessEvent = useEvent(onSuccess);
+    const onErrorEvent = useEvent(onError);
+    const onSettledEvent = useEvent(onSettled);
+    const result = useInfiniteQuery({
+        queryKey: [
+            resource,
+            'getInfiniteList',
+            { pagination, sort, filter, meta },
+        ],
+        queryFn: queryParams => {
+            const { pageParam = pagination.page } = queryParams;
+            return dataProvider
+                .getList(resource, {
+                pagination: {
+                    page: pageParam,
+                    perPage: pagination.perPage,
+                },
+                sort,
+                filter,
+                meta,
+                signal: dataProvider.supportAbortSignal === true
+                    ? queryParams.signal
+                    : undefined,
+            })
+                .then(({ data, pageInfo, total, meta }) => ({
+                data,
+                total,
+                pageParam,
+                pageInfo,
+                meta,
+            }));
+        },
+        initialPageParam: pagination.page,
+        ...queryOptions,
+        getNextPageParam: lastLoadedPage => {
+            if (lastLoadedPage.pageInfo) {
+                return lastLoadedPage.pageInfo.hasNextPage
+                    ? lastLoadedPage.pageParam + 1
+                    : undefined;
+            }
+            const totalPages = Math.ceil((lastLoadedPage.total || 0) / pagination.perPage);
+            return lastLoadedPage.pageParam < totalPages
+                ? Number(lastLoadedPage.pageParam) + 1
+                : undefined;
+        },
+        getPreviousPageParam: lastLoadedPage => {
+            if (lastLoadedPage.pageInfo) {
+                return lastLoadedPage.pageInfo.hasPreviousPage
+                    ? lastLoadedPage.pageParam - 1
+                    : undefined;
+            }
+            return lastLoadedPage.pageParam === 1
+                ? undefined
+                : lastLoadedPage.pageParam - 1;
+        },
+    });
+    const metaValue = useRef(meta);
+    const resourceValue = useRef(resource);
+    useEffect(() => {
+        metaValue.current = meta;
+    }, [meta]);
+    useEffect(() => {
+        resourceValue.current = resource;
+    }, [resource]);
+    useEffect(() => {
+        if (result.data === undefined ||
+            result.error != null ||
+            result.isFetching)
+            return;
+        // optimistically populate the getOne cache
+        const allPagesDataLength = result.data.pages.reduce((acc, page) => acc + page.data.length, 0);
+        if (allPagesDataLength <= MAX_DATA_LENGTH_TO_CACHE) {
+            result.data.pages.forEach(page => {
+                page.data.forEach(record => {
+                    queryClient.setQueryData([
+                        resourceValue.current,
+                        'getOne',
+                        { id: String(record.id), meta: metaValue.current },
+                    ], oldRecord => oldRecord ?? record);
+                });
+            });
+        }
+        onSuccessEvent(result.data);
+    }, [
+        onSuccessEvent,
+        queryClient,
+        result.data,
+        result.error,
+        result.isFetching,
+    ]);
+    useEffect(() => {
+        if (result.error == null || result.isFetching)
+            return;
+        onErrorEvent(result.error);
+    }, [onErrorEvent, result.error, result.isFetching]);
+    useEffect(() => {
+        if (result.status === 'pending' || result.isFetching)
+            return;
+        onSettledEvent(result.data, result.error);
+    }, [
+        onSettledEvent,
+        result.data,
+        result.error,
+        result.status,
+        result.isFetching,
+    ]);
+    return (result.data
+        ? {
+            ...result,
+            data: result.data,
+            total: result.data?.pages[0]?.total ?? undefined,
+            meta: result.data?.pages[0]?.meta,
+        }
+        : result);
+};
+const noop = () => undefined;

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

@@ -0,0 +1,13 @@
+/**
+ * Check if react-query has already fetched data for a query key.
+ *
+ * This hook is reactive.
+ *
+ * @example
+ * const isCustomerLoaded = useIsDataLoaded(['customers', 'getOne', { id: customerId }]);
+ *
+ * @returns {boolean} true if the data is loaded, false otherwise
+ */
+export declare const useIsDataLoaded: (queryKey: any, options?: {
+    enabled?: boolean;
+}) => boolean;

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

@@ -0,0 +1,35 @@
+import { useEffect, useState } from 'react';
+import { useQueryClient, QueryObserver } from '@tanstack/react-query';
+/**
+ * Check if react-query has already fetched data for a query key.
+ *
+ * This hook is reactive.
+ *
+ * @example
+ * const isCustomerLoaded = useIsDataLoaded(['customers', 'getOne', { id: customerId }]);
+ *
+ * @returns {boolean} true if the data is loaded, false otherwise
+ */
+export const useIsDataLoaded = (queryKey, options = {}) => {
+    const { enabled = true } = options;
+    const queryClient = useQueryClient();
+    const [isDataLoaded, setDataLoaded] = useState(() => {
+        if (!enabled) {
+            return false;
+        }
+        return queryClient.getQueryData(queryKey) !== undefined;
+    });
+    useEffect(() => {
+        if (!enabled)
+            return;
+        if (queryClient.getQueryData(queryKey) === undefined) {
+            const observer = new QueryObserver(queryClient, { queryKey });
+            const unsubscribe = observer.subscribe(result => {
+                setDataLoaded(!result.isPending);
+                unsubscribe();
+            });
+            return unsubscribe;
+        }
+    }, [enabled, queryKey, queryClient]);
+    return isDataLoaded;
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Get the state of the dataProvider connection.
+ *
+ * Returns true if a query or a mutation is pending.
+ *
+ * Custom implementation because react-query's useIsFetching and useIsMutating
+ * render each time the number of active queries changes, which is too often.
+ *
+ * @see useIsFetching
+ * @see useIsMutating
+ */
+export declare const useLoading: () => boolean;

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

@@ -0,0 +1,41 @@
+import React from 'react';
+import { notifyManager, useQueryClient } from '@tanstack/react-query';
+/**
+ * Get the state of the dataProvider connection.
+ *
+ * Returns true if a query or a mutation is pending.
+ *
+ * Custom implementation because react-query's useIsFetching and useIsMutating
+ * render each time the number of active queries changes, which is too often.
+ *
+ * @see useIsFetching
+ * @see useIsMutating
+ */
+export const useLoading = () => {
+    const client = useQueryClient();
+    const mountedRef = React.useRef(false);
+    const isFetchingRef = React.useRef(client.isFetching() > 0);
+    const isMutatingRef = React.useRef(client.isMutating() > 0);
+    const [isLoading, setIsLoading] = React.useState(isFetchingRef.current || isMutatingRef.current);
+    React.useEffect(() => {
+        mountedRef.current = true;
+        const unsubscribeQueryCache = client.getQueryCache().subscribe(notifyManager.batchCalls(() => {
+            if (mountedRef.current) {
+                isFetchingRef.current = client.isFetching() > 0;
+                setIsLoading(isFetchingRef.current || isMutatingRef.current);
+            }
+        }));
+        const unsubscribeMutationCache = client.getMutationCache().subscribe(notifyManager.batchCalls(() => {
+            if (mountedRef.current) {
+                isMutatingRef.current = client.isMutating() > 0;
+                setIsLoading(isFetchingRef.current || isMutatingRef.current);
+            }
+        }));
+        return () => {
+            mountedRef.current = false;
+            unsubscribeQueryCache();
+            unsubscribeMutationCache();
+        };
+    }, [client]);
+    return isLoading;
+};

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]);
+};