@strato-admin/faker-ecommerce 0.1.1 → 0.3.0

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

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

@@ -0,0 +1,81 @@
+import { type UseMutationOptions, type UseMutationResult, type MutateOptions } from '@tanstack/react-query';
+import type { RaRecord, UpdateManyParams, MutationMode, DataProvider } from '../types';
+/**
+ * Get a callback to call the dataProvider.updateMany() method, the result and the loading state.
+ *
+ * @param {string} resource
+ * @param {Params} params The updateMany parameters { ids, data, 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.ids The resource identifiers, e.g. [123, 456]
+ * @prop params.data The updates to merge into the record, e.g. { views: 10 }
+ * @prop params.meta Optional meta parameters
+ *
+ * @returns The current mutation state. Destructure as [updateMany, { data, error, isPending }].
+ *
+ * The return value updates according to the request state:
+ *
+ * - initial: [updateMany, { isPending: false, isIdle: true }]
+ * - start:   [updateMany, { isPending: true }]
+ * - success: [updateMany, { data: [data from response], isPending: false, isSuccess: true }]
+ * - error:   [updateMany, { error: [error from response], isPending: false, isError: true }]
+ *
+ * The updateMany() function must be called with a resource and a parameter object: updateMany(resource, { ids, 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://tanstack.com/query/v5/docs/react/reference/useMutation
+ *
+ * @example // set params when calling the updateMany callback
+ *
+ * import { useUpdateMany, useListContext } from 'react-admin';
+ *
+ * const BulkResetViewsButton = () => {
+ *     const { selectedIds } = useListContext();
+ *     const [updateMany, { isPending, error }] = useUpdateMany();
+ *     const handleClick = () => {
+ *         updateMany('posts', { ids: selectedIds, data: { views: 0 } });
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Reset views</button>;
+ * };
+ *
+ * @example // set params when calling the hook
+ *
+ * import { useUpdateMany, useListContext } from 'react-admin';
+ *
+ * const BulkResetViewsButton = () => {
+ *     const { selectedIds } = useListContext();
+ *     const [updateMany, { isPending, error }] = useUpdateMany('posts', { ids: selectedIds, data: { views: 0 } });
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={() => updateMany()}>Reset views</button>;
+ * };
+ */
+export declare const useUpdateMany: <RecordType extends RaRecord = any, MutationError = unknown>(resource?: string, params?: Partial<UpdateManyParams<Partial<RecordType>>>, options?: UseUpdateManyOptions<RecordType, MutationError>) => UseUpdateManyResult<RecordType, boolean, MutationError>;
+export interface UseUpdateManyMutateParams<RecordType extends RaRecord = any> {
+    resource?: string;
+    ids?: Array<RecordType['id']>;
+    data?: Partial<RecordType>;
+    previousData?: any;
+    meta?: any;
+}
+export type UseUpdateManyOptions<RecordType extends RaRecord = any, MutationError = unknown> = Omit<UseMutationOptions<Array<RecordType['id']>, MutationError, Partial<UseUpdateManyMutateParams<RecordType>>>, 'mutationFn'> & {
+    mutationMode?: MutationMode;
+    returnPromise?: boolean;
+    getMutateWithMiddlewares?: <UpdateFunctionType extends DataProvider['updateMany'] = DataProvider['updateMany']>(mutate: UpdateFunctionType) => (...Params: Parameters<UpdateFunctionType>) => ReturnType<UpdateFunctionType>;
+};
+export type UseUpdateManyResult<RecordType extends RaRecord = any, TReturnPromise extends boolean = boolean, MutationError = unknown> = [
+    (resource?: string, params?: Partial<UpdateManyParams<RecordType>>, options?: MutateOptions<Array<RecordType['id']>, MutationError, Partial<UseUpdateManyMutateParams<RecordType>>, unknown> & {
+        mutationMode?: MutationMode;
+        returnPromise?: TReturnPromise;
+    }) => Promise<TReturnPromise extends true ? Array<RecordType['id']> : void>,
+    UseMutationResult<Array<RecordType['id']> | undefined, MutationError, Partial<UpdateManyParams<Partial<RecordType>> & {
+        resource?: string;
+    }>, unknown> & {
+        isLoading: boolean;
+    }
+];

package/dist/ra-core/src/dataProvider/useUpdateMany.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.updateMany() method, the result and the loading state.
+ *
+ * @param {string} resource
+ * @param {Params} params The updateMany parameters { ids, data, 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.ids The resource identifiers, e.g. [123, 456]
+ * @prop params.data The updates to merge into the record, e.g. { views: 10 }
+ * @prop params.meta Optional meta parameters
+ *
+ * @returns The current mutation state. Destructure as [updateMany, { data, error, isPending }].
+ *
+ * The return value updates according to the request state:
+ *
+ * - initial: [updateMany, { isPending: false, isIdle: true }]
+ * - start:   [updateMany, { isPending: true }]
+ * - success: [updateMany, { data: [data from response], isPending: false, isSuccess: true }]
+ * - error:   [updateMany, { error: [error from response], isPending: false, isError: true }]
+ *
+ * The updateMany() function must be called with a resource and a parameter object: updateMany(resource, { ids, 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://tanstack.com/query/v5/docs/react/reference/useMutation
+ *
+ * @example // set params when calling the updateMany callback
+ *
+ * import { useUpdateMany, useListContext } from 'react-admin';
+ *
+ * const BulkResetViewsButton = () => {
+ *     const { selectedIds } = useListContext();
+ *     const [updateMany, { isPending, error }] = useUpdateMany();
+ *     const handleClick = () => {
+ *         updateMany('posts', { ids: selectedIds, data: { views: 0 } });
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Reset views</button>;
+ * };
+ *
+ * @example // set params when calling the hook
+ *
+ * import { useUpdateMany, useListContext } from 'react-admin';
+ *
+ * const BulkResetViewsButton = () => {
+ *     const { selectedIds } = useListContext();
+ *     const [updateMany, { isPending, error }] = useUpdateMany('posts', { ids: selectedIds, data: { views: 0 } });
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={() => updateMany()}>Reset views</button>;
+ * };
+ */
+export const useUpdateMany = (resource, params = {}, options = {}) => {
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const { mutationMode = 'pessimistic', getMutateWithMiddlewares, ...mutationOptions } = options;
+    const dataProviderUpdateMany = useEvent((resource, params) => dataProvider.updateMany(resource, params));
+    const [mutate, mutationResult] = useMutationWithMutationMode({ resource, ...params }, {
+        ...mutationOptions,
+        mutationKey: [resource, 'updateMany', params],
+        mutationMode,
+        mutationFn: ({ resource, ...params }) => {
+            if (resource == null) {
+                throw new Error('useUpdateMany mutation requires a resource');
+            }
+            if (params.ids == null) {
+                throw new Error('useUpdateMany mutation requires an array of ids');
+            }
+            if (!params.data) {
+                throw new Error('useUpdateMany mutation requires a non-empty data object');
+            }
+            return dataProviderUpdateMany(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 updatedAt = mutationMode === 'undoable'
+                ? Date.now() + 1000 * 5
+                : Date.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 = params?.data
+                ? JSON.parse(JSON.stringify(params?.data))
+                : undefined;
+            const updateColl = (old) => {
+                if (!old)
+                    return old;
+                let newCollection = [...old];
+                (params?.ids ?? []).forEach(id => {
+                    // eslint-disable-next-line eqeqeq
+                    const index = old.findIndex(record => record.id == id);
+                    if (index === -1) {
+                        return;
+                    }
+                    newCollection = [
+                        ...newCollection.slice(0, index),
+                        { ...newCollection[index], ...clonedData },
+                        ...newCollection.slice(index + 1),
+                    ];
+                });
+                return newCollection;
+            };
+            (params?.ids ?? []).forEach(id => {
+                queryClient.setQueryData([
+                    resource,
+                    'getOne',
+                    { id: String(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 });
+            return params?.ids;
+        },
+        getQueryKeys: ({ resource }) => {
+            const queryKeys = [
+                [resource, 'getOne'],
+                [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(dataProviderUpdateMany.bind(dataProvider));
+                return args => {
+                    // This is necessary to avoid breaking changes in useUpdateMany:
+                    // 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 updateMany = useEvent((callTimeResource = resource, callTimeParams = {}, callTimeOptions = {}) => {
+        return mutate({
+            resource: callTimeResource,
+            ...callTimeParams,
+        }, callTimeOptions);
+    });
+    return [updateMany, mutationResult];
+};

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

@@ -0,0 +1,5 @@
+declare function validateResponseFormat(response: any, type: any, logger?: {
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+}): void;
+export default validateResponseFormat;

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

@@ -0,0 +1,35 @@
+import { fetchActionsWithRecordResponse, fetchActionsWithArrayOfIdentifiedRecordsResponse, fetchActionsWithArrayOfRecordsResponse, fetchActionsWithTotalResponse, } from './dataFetchActions';
+function validateResponseFormat(response, type, logger = console.error) {
+    if (!response) {
+        logger(`The dataProvider returned an empty response for '${type}'.`);
+        throw new Error("strato.notification.data_provider_error');
+    }
+    if (!response.hasOwnProperty('data')) {
+        logger(`The response to '${type}' must be like { data: ... }, but the received response does not have a 'data' key. The dataProvider is probably wrong for '${type}'.`);
+        throw new Error("strato.notification.data_provider_error');
+    }
+    if (fetchActionsWithArrayOfRecordsResponse.includes(type) &&
+        !Array.isArray(response.data)) {
+        logger(`The response to '${type}' must be like { data : [...] }, but the received data is not an array. The dataProvider is probably wrong for '${type}'`);
+        throw new Error("strato.notification.data_provider_error');
+    }
+    if (fetchActionsWithArrayOfIdentifiedRecordsResponse.includes(type) &&
+        Array.isArray(response.data) &&
+        response.data.length > 0 &&
+        !response.data[0].hasOwnProperty('id')) {
+        logger(`The response to '${type}' must be like { data : [{ id: 123, ...}, ...] }, but the received data items do not have an 'id' key. The dataProvider is probably wrong for '${type}'`);
+        throw new Error("strato.notification.data_provider_error');
+    }
+    if (fetchActionsWithRecordResponse.includes(type) &&
+        !response.data.hasOwnProperty('id')) {
+        logger(`The response to '${type}' must be like { data: { id: 123, ... } }, but the received data does not have an 'id' key. The dataProvider is probably wrong for '${type}'`);
+        throw new Error("strato.notification.data_provider_error');
+    }
+    if (fetchActionsWithTotalResponse.includes(type) &&
+        !response.hasOwnProperty('total') &&
+        !response.hasOwnProperty('pageInfo')) {
+        logger(`The response to '${type}' must be like { data: [...], total: 123 } or { data: [...], pageInfo: {...} }, but the received response has neither a 'total' nor a 'pageInfo' key. The dataProvider is probably wrong for '${type}'`);
+        throw new Error("strato.notification.data_provider_error');
+    }
+}
+export default validateResponseFormat;