@strato-admin/core 0.1.0 → 0.3.0

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

@@ -0,0 +1,171 @@
+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.delete() method, the result and the loading state.
+ *
+ * @param {string} resource
+ * @param {Params} params The delete parameters { id, previousData }
+ * @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.previousData The record before the update is applied
+ *
+ * @returns The current mutation state. Destructure as [deleteOne, { data, error, isPending }].
+ *
+ * The return value updates according to the request state:
+ *
+ * - initial: [deleteOne, { isPending: false, isIdle: true }]
+ * - start:   [deleteOne, { isPending: true }]
+ * - success: [deleteOne, { data: [data from response], isPending: false, isSuccess: true }]
+ * - error:   [deleteOne, { error: [error from response], isPending: false, isError: true }]
+ *
+ * The deleteOne() function must be called with a resource and a parameter object: deleteOne(resource, { id, previousData, meta }, 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://tanstack.com/query/v5/docs/react/reference/useMutation
+ *
+ * @example // set params when calling the deleteOne callback
+ *
+ * import { useDelete, useRecordContext } from 'react-admin';
+ *
+ * const DeleteButton = () => {
+ *     const record = useRecordContext();
+ *     const [deleteOne, { isPending, error }] = useDelete();
+ *     const handleClick = () => {
+ *         deleteOne('likes', { id: record.id, previousData: record })
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Delete</div>;
+ * };
+ *
+ * @example // set params when calling the hook
+ *
+ * import { useDelete, useRecordContext } from 'react-admin';
+ *
+ * const DeleteButton = () => {
+ *     const record = useRecordContext();
+ *     const [deleteOne, { isPending, error }] = useDelete('likes', { id: record.id, previousData: record });
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={() => deleteOne()}>Delete</button>;
+ * };
+ *
+ * @example // TypeScript
+ * const [delete, { data }] = useDelete<Product>('products', { id, previousData: product });
+ *                    \-- data is Product
+ */
+export const useDelete = (resource, params = {}, options = {}) => {
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const { mutationMode = 'pessimistic', onSettled, ...mutationOptions } = options;
+    const [mutate, mutationResult] = useMutationWithMutationMode({ resource, ...params }, {
+        ...mutationOptions,
+        mutationKey: [resource, 'delete', params],
+        mutationMode,
+        mutationFn: ({ resource, ...params }) => {
+            if (resource == null) {
+                throw new Error('useDelete mutation requires a resource');
+            }
+            if (params.id == null) {
+                throw new Error('useDelete mutation requires a non-empty id');
+            }
+            return dataProvider.delete(resource, params);
+        },
+        updateCache: ({ resource, ...params }, { mutationMode }) => {
+            // 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;
+            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.slice(index + 1)];
+            };
+            queryClient.setQueriesData({ queryKey: [resource, 'getList'] }, (res) => {
+                if (!res || !res.data)
+                    return res;
+                const newCollection = updateColl(res.data);
+                const recordWasFound = newCollection.length < res.data.length;
+                return recordWasFound
+                    ? {
+                        data: newCollection,
+                        total: res.total ? res.total - 1 : undefined,
+                        pageInfo: res.pageInfo,
+                    }
+                    : res;
+            }, { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getInfiniteList'] }, (res) => {
+                if (!res || !res.pages)
+                    return res;
+                return {
+                    ...res,
+                    pages: res.pages.map(page => {
+                        const newCollection = updateColl(page.data);
+                        const recordWasFound = newCollection.length < page.data.length;
+                        return recordWasFound
+                            ? {
+                                ...page,
+                                data: newCollection,
+                                total: page.total
+                                    ? page.total - 1
+                                    : undefined,
+                                pageInfo: page.pageInfo,
+                            }
+                            : page;
+                    }),
+                };
+            }, { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getMany'] }, (coll) => coll && coll.length > 0 ? updateColl(coll) : coll, { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getManyReference'] }, (res) => {
+                if (!res || !res.data)
+                    return res;
+                const newCollection = updateColl(res.data);
+                const recordWasFound = newCollection.length < res.data.length;
+                return recordWasFound
+                    ? {
+                        ...res,
+                        data: newCollection,
+                        total: res.total - 1,
+                    }
+                    : res;
+            }, { updatedAt });
+            return params.previousData;
+        },
+        getQueryKeys: ({ resource }) => {
+            const queryKeys = [
+                [resource, 'getList'],
+                [resource, 'getInfiniteList'],
+                [resource, 'getMany'],
+                [resource, 'getManyReference'],
+            ];
+            return queryKeys;
+        },
+        onSettled: (...args) => {
+            const [, , , mutateResult] = args;
+            // For deletion, we always refetch after error or success:
+            mutateResult.snapshot.forEach(([queryKey]) => {
+                queryClient.invalidateQueries({ queryKey });
+            });
+            onSettled?.(...args);
+        },
+    });
+    const deleteOne = useEvent((callTimeResource = resource, callTimeParams = {}, callTimeOptions = {}) => {
+        return mutate({
+            resource: callTimeResource,
+            ...callTimeParams,
+        }, callTimeOptions);
+    });
+    return [deleteOne, mutationResult];
+};

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

@@ -0,0 +1,81 @@
+import { type UseMutationOptions, type UseMutationResult, type MutateOptions } from '@tanstack/react-query';
+import type { RaRecord, DeleteManyParams, MutationMode } from '../types';
+/**
+ * Get a callback to call the dataProvider.delete() method, the result and the loading state.
+ *
+ * @param {string} resource
+ * @param {Params} params The delete parameters { ids }
+ * @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.ids The resource identifiers, e.g. [123, 456]
+ *
+ * @returns The current mutation state. Destructure as [deleteMany, { data, error, isPending }].
+ *
+ * The return value updates according to the request state:
+ *
+ * - initial: [deleteMany, { isPending: false, isIdle: true }]
+ * - start:   [deleteMany, { isPending: true }]
+ * - success: [deleteMany, { data: [data from response], isPending: false, isSuccess: true }]
+ * - error:   [deleteMany, { error: [error from response], isPending: false, isError: true }]
+ *
+ * The deleteMany() function must be called with a resource and a parameter object: deleteMany(resource, { ids, meta }, 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://tanstack.com/query/v5/docs/react/reference/useMutation
+ *
+ * @example // set params when calling the deleteMany callback
+ *
+ * import { useDeleteMany } from 'react-admin';
+ *
+ * const BulkDeletePostsButton = ({ selectedIds }) => {
+ *     const [deleteMany, { isPending, error }] = useDeleteMany();
+ *     const handleClick = () => {
+ *         deleteMany('posts', { ids: selectedIds })
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Delete selected posts</button>;
+ * };
+ *
+ * @example // set params when calling the hook
+ *
+ * import { useDeleteMany } from 'react-admin';
+ *
+ * const BulkDeletePostsButton = ({ selectedIds }) => {
+ *     const [deleteMany, { isPending, error }] = useDeleteMany('posts', { ids: selectedIds });
+ *     const handleClick = () => {
+ *         deleteMany()
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Delete selected posts</button>;
+ * };
+ *
+ * @example // TypeScript
+ * const [deleteMany, { data }] = useDeleteMany<Product>('products', { ids });
+ *                        \-- data is Product
+ */
+export declare const useDeleteMany: <RecordType extends RaRecord = any, MutationError = unknown>(resource?: string, params?: Partial<DeleteManyParams<RecordType>>, options?: UseDeleteManyOptions<RecordType, MutationError>) => UseDeleteManyResult<RecordType, MutationError>;
+export interface UseDeleteManyMutateParams<RecordType extends RaRecord = any> {
+    resource?: string;
+    ids?: Array<RecordType['id']>;
+    meta?: any;
+}
+export type UseDeleteManyOptions<RecordType extends RaRecord = any, MutationError = unknown, TReturnPromise extends boolean = boolean> = Omit<UseMutationOptions<Array<RecordType['id']> | undefined, MutationError, Partial<UseDeleteManyMutateParams<RecordType>>>, 'mutationFn'> & {
+    mutationMode?: MutationMode;
+    returnPromise?: TReturnPromise;
+};
+export type UseDeleteManyResult<RecordType extends RaRecord = any, MutationError = unknown, TReturnPromise extends boolean = boolean> = [
+    (resource?: string, params?: Partial<DeleteManyParams<RecordType>>, options?: MutateOptions<Array<RecordType['id']> | undefined, MutationError, Partial<UseDeleteManyMutateParams<RecordType>>, unknown> & {
+        mutationMode?: MutationMode;
+        returnPromise?: TReturnPromise;
+    }) => Promise<TReturnPromise extends true ? Array<RecordType['id']> | undefined : void>,
+    UseMutationResult<Array<RecordType['id']> | undefined, MutationError, Partial<DeleteManyParams<RecordType> & {
+        resource?: string;
+    }>, unknown> & {
+        isLoading: boolean;
+    }
+];

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

@@ -0,0 +1,193 @@
+import { useQueryClient, } from '@tanstack/react-query';
+import { useDataProvider } from './useDataProvider';
+import { useEvent } from '../util';
+import { useMutationWithMutationMode, } from './useMutationWithMutationMode';
+/**
+ * Get a callback to call the dataProvider.delete() method, the result and the loading state.
+ *
+ * @param {string} resource
+ * @param {Params} params The delete parameters { ids }
+ * @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.ids The resource identifiers, e.g. [123, 456]
+ *
+ * @returns The current mutation state. Destructure as [deleteMany, { data, error, isPending }].
+ *
+ * The return value updates according to the request state:
+ *
+ * - initial: [deleteMany, { isPending: false, isIdle: true }]
+ * - start:   [deleteMany, { isPending: true }]
+ * - success: [deleteMany, { data: [data from response], isPending: false, isSuccess: true }]
+ * - error:   [deleteMany, { error: [error from response], isPending: false, isError: true }]
+ *
+ * The deleteMany() function must be called with a resource and a parameter object: deleteMany(resource, { ids, meta }, 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://tanstack.com/query/v5/docs/react/reference/useMutation
+ *
+ * @example // set params when calling the deleteMany callback
+ *
+ * import { useDeleteMany } from 'react-admin';
+ *
+ * const BulkDeletePostsButton = ({ selectedIds }) => {
+ *     const [deleteMany, { isPending, error }] = useDeleteMany();
+ *     const handleClick = () => {
+ *         deleteMany('posts', { ids: selectedIds })
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Delete selected posts</button>;
+ * };
+ *
+ * @example // set params when calling the hook
+ *
+ * import { useDeleteMany } from 'react-admin';
+ *
+ * const BulkDeletePostsButton = ({ selectedIds }) => {
+ *     const [deleteMany, { isPending, error }] = useDeleteMany('posts', { ids: selectedIds });
+ *     const handleClick = () => {
+ *         deleteMany()
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Delete selected posts</button>;
+ * };
+ *
+ * @example // TypeScript
+ * const [deleteMany, { data }] = useDeleteMany<Product>('products', { ids });
+ *                        \-- data is Product
+ */
+export const useDeleteMany = (resource, params = {}, options = {}) => {
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const { mutationMode = 'pessimistic', onSettled, ...mutationOptions } = options;
+    const [mutate, mutationResult] = useMutationWithMutationMode({ resource, ...params }, {
+        ...mutationOptions,
+        mutationKey: [resource, 'deleteMany', params],
+        mutationMode,
+        mutationFn: ({ resource, ...params }) => {
+            if (resource == null) {
+                throw new Error('useDeleteMany mutation requires a resource');
+            }
+            if (params.ids == null) {
+                throw new Error('useDeleteMany mutation requires an array of ids');
+            }
+            return dataProvider.deleteMany(resource, params);
+        },
+        updateCache: ({ resource, ...params }, { mutationMode }) => {
+            // 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;
+            const updateColl = (old) => {
+                if (!old)
+                    return old;
+                let newCollection = [...old];
+                params.ids?.forEach(id => {
+                    const index = newCollection.findIndex(
+                    // eslint-disable-next-line eqeqeq
+                    record => record.id == id);
+                    if (index === -1) {
+                        return;
+                    }
+                    newCollection = [
+                        ...newCollection.slice(0, index),
+                        ...newCollection.slice(index + 1),
+                    ];
+                });
+                return newCollection;
+            };
+            queryClient.setQueriesData({ queryKey: [resource, 'getList'] }, (res) => {
+                if (!res || !res.data)
+                    return res;
+                const newCollection = updateColl(res.data);
+                const recordWasFound = newCollection.length < res.data.length;
+                return recordWasFound
+                    ? {
+                        ...res,
+                        data: newCollection,
+                        total: res.total
+                            ? res.total -
+                                (res.data.length - newCollection.length)
+                            : undefined,
+                    }
+                    : res;
+            }, { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getInfiniteList'] }, (res) => {
+                if (!res || !res.pages)
+                    return res;
+                return {
+                    ...res,
+                    pages: res.pages.map(page => {
+                        const newCollection = updateColl(page.data);
+                        const recordWasFound = newCollection.length < page.data.length;
+                        return recordWasFound
+                            ? {
+                                ...page,
+                                data: newCollection,
+                                total: page.total
+                                    ? page.total -
+                                        (page.data.length -
+                                            newCollection.length)
+                                    : undefined,
+                            }
+                            : page;
+                    }),
+                };
+            }, { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getMany'] }, (coll) => coll && coll.length > 0 ? updateColl(coll) : coll, { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getManyReference'] }, (res) => {
+                if (!res || !res.data)
+                    return res;
+                const newCollection = updateColl(res.data);
+                const recordWasFound = newCollection.length < res.data.length;
+                if (!recordWasFound) {
+                    return res;
+                }
+                if (res.total) {
+                    return {
+                        ...res,
+                        data: newCollection,
+                        total: res.total -
+                            (res.data.length - newCollection.length),
+                    };
+                }
+                if (res.pageInfo) {
+                    return {
+                        ...res,
+                        data: newCollection,
+                    };
+                }
+                throw new Error('Found getManyReference result in cache without total or pageInfo');
+            }, { updatedAt });
+            return params.ids;
+        },
+        getQueryKeys: ({ resource }) => {
+            const queryKeys = [
+                [resource, 'getList'],
+                [resource, 'getInfiniteList'],
+                [resource, 'getMany'],
+                [resource, 'getManyReference'],
+            ];
+            return queryKeys;
+        },
+        onSettled: (...args) => {
+            const [, , , mutateResult] = args;
+            // For deletion, we always refetch after error or success:
+            mutateResult.snapshot.forEach(([queryKey]) => {
+                queryClient.invalidateQueries({ queryKey });
+            });
+            onSettled?.(...args);
+        },
+    });
+    const deleteMany = useEvent((callTimeResource = resource, callTimeParams = {}, callTimeOptions = {}) => {
+        return mutate({
+            resource: callTimeResource,
+            ...callTimeParams,
+        }, callTimeOptions);
+    });
+    return [deleteMany, mutationResult];
+};

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

@@ -0,0 +1,58 @@
+import { UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { RaRecord, GetListParams, GetListResult } from '../types';
+/**
+ * Call the dataProvider.getList() method and return the resolved result
+ * as well as the loading state.
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true, refetch }
+ * - success: { data: [data from store], total: [total from response], isPending: false, refetch }
+ * - error: { error: [error from response], isPending: false, refetch }
+ *
+ * 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: () => { refresh(); } }
+ *
+ * @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, refetch }.
+ *
+ * @example
+ *
+ * import { useGetList } from 'react-admin';
+ *
+ * const LatestNews = () => {
+ *     const { data, total, isPending, error } = useGetList(
+ *         '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.map(item =>
+ *         <li key={item.id}>{item.title}</li>
+ *     )}</ul>;
+ * };
+ */
+export declare const useGetList: <RecordType extends RaRecord = any, ErrorType = Error>(resource: string, params?: Partial<GetListParams>, options?: UseGetListOptions<RecordType, ErrorType>) => UseGetListHookValue<RecordType>;
+export type UseGetListOptions<RecordType extends RaRecord = any, ErrorType = Error> = Omit<UseQueryOptions<GetListResult<RecordType>, ErrorType>, 'queryKey' | 'queryFn'> & {
+    onSuccess?: (value: GetListResult<RecordType>) => void;
+    onError?: (error: ErrorType) => void;
+    onSettled?: (data?: GetListResult<RecordType>, error?: ErrorType | null) => void;
+};
+export type UseGetListHookValue<RecordType extends RaRecord = any> = UseQueryResult<RecordType[], Error> & {
+    total?: number;
+    pageInfo?: {
+        hasNextPage?: boolean;
+        hasPreviousPage?: boolean;
+    };
+    meta?: any;
+};

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

@@ -0,0 +1,131 @@
+import { useEffect, useMemo, useRef } from 'react';
+import { useQuery, useQueryClient, } from '@tanstack/react-query';
+import { useDataProvider } from './useDataProvider';
+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 value updates according to the request state:
+ *
+ * - start: { isPending: true, refetch }
+ * - success: { data: [data from store], total: [total from response], isPending: false, refetch }
+ * - error: { error: [error from response], isPending: false, refetch }
+ *
+ * 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: () => { refresh(); } }
+ *
+ * @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, refetch }.
+ *
+ * @example
+ *
+ * import { useGetList } from 'react-admin';
+ *
+ * const LatestNews = () => {
+ *     const { data, total, isPending, error } = useGetList(
+ *         '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.map(item =>
+ *         <li key={item.id}>{item.title}</li>
+ *     )}</ul>;
+ * };
+ */
+export const useGetList = (resource, params = {}, options = {}) => {
+    const { pagination = { page: 1, perPage: 25 }, sort = { field: 'id', order: 'DESC' }, filter = {}, meta, } = params;
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const { onError = noop, onSuccess = noop, onSettled = noop, ...queryOptions } = options;
+    const onSuccessEvent = useEvent(onSuccess);
+    const onErrorEvent = useEvent(onError);
+    const onSettledEvent = useEvent(onSettled);
+    const result = useQuery({
+        queryKey: [resource, 'getList', { pagination, sort, filter, meta }],
+        queryFn: queryParams => dataProvider
+            .getList(resource, {
+            pagination,
+            sort,
+            filter,
+            meta,
+            signal: dataProvider.supportAbortSignal === true
+                ? queryParams.signal
+                : undefined,
+        })
+            .then(({ data, total, pageInfo, meta }) => ({
+            data,
+            total,
+            pageInfo,
+            meta,
+        })),
+        ...queryOptions,
+    });
+    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
+        if (result.data?.data &&
+            result.data.data.length <= MAX_DATA_LENGTH_TO_CACHE) {
+            result.data.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 useMemo(() => result.data
+        ? {
+            ...result,
+            ...result.data,
+        }
+        : result, [result]);
+};
+const noop = () => undefined;