Fix regression for useUpdate and useUpdateMany

Author: djhi

packages/ra-core/src/dataProvider/useCreate.ts

@@ -158,6 +158,21 @@ export const useCreate = <
                     { updatedAt }
                 );
 
+                if (mutationMode === 'pessimistic') {
+                    queryClient.invalidateQueries({
+                        queryKey: [resource, 'getList'],
+                    });
+                    queryClient.invalidateQueries({
+                        queryKey: [resource, 'getInfiniteList'],
+                    });
+                    queryClient.invalidateQueries({
+                        queryKey: [resource, 'getMany'],
+                    });
+                    queryClient.invalidateQueries({
+                        queryKey: [resource, 'getManyReference'],
+                    });
+                }
+
                 return clonedData;
             },
             getSnapshot: ({ resource, ...params }, { mutationMode }) => {

packages/ra-core/src/dataProvider/useDelete.ts

@@ -239,6 +239,17 @@ export const useDelete = <
 
                 return snapshot;
             },
+            onSettled: (
+                result,
+                error,
+                variables,
+                context: { snapshot: Snapshot }
+            ) => {
+                // For deletion, we always refetch after error or success:
+                context.snapshot.forEach(([queryKey]) => {
+                    queryClient.invalidateQueries({ queryKey });
+                });
+            },
         }
     );
 

packages/ra-core/src/dataProvider/useDeleteMany.ts

@@ -266,6 +266,17 @@ export const useDeleteMany = <
                 );
                 return snapshot;
             },
+            onSettled: (
+                result,
+                error,
+                variables,
+                context: { snapshot: Snapshot }
+            ) => {
+                // For deletion, we always refetch after error or success:
+                context.snapshot.forEach(([queryKey]) => {
+                    queryClient.invalidateQueries({ queryKey });
+                });
+            },
         }
     );
 

packages/ra-core/src/dataProvider/useMutationWithMutationMode.ts

@@ -173,10 +173,15 @@ export const useMutationWithMutationMode = <
                 variables = {},
                 context: { snapshot: Snapshot }
             ) => {
-                // Always refetch after error or success:
-                context.snapshot.forEach(([queryKey]) => {
-                    queryClient.invalidateQueries({ queryKey });
-                });
+                if (
+                    mode.current === 'optimistic' ||
+                    mode.current === 'undoable'
+                ) {
+                    // Always refetch after error or success:
+                    context.snapshot.forEach(([queryKey]) => {
+                        queryClient.invalidateQueries({ queryKey });
+                    });
+                }
 
                 if (callTimeOnSettled.current) {
                     return callTimeOnSettled.current(

packages/ra-core/src/dataProvider/useUpdateMany.spec.tsx

@@ -542,7 +542,12 @@ describe('useUpdateMany', () => {
             await waitFor(() => {
                 expect(screen.queryByText('success')).not.toBeNull();
                 expect(
-                    screen.queryByText('Hello World from middleware')
+                    // We could expect 'Hello World from middleware' here, but
+                    // updateMany's result only contains the ids, not the updated data
+                    // so the cache can only be updated with the call-time params,
+                    // which do not include the middleware's result.
+                    // I guess it's OK for most cases though...
+                    screen.queryByText('Hello World')
                 ).not.toBeNull();
                 expect(screen.queryByText('mutating')).toBeNull();
             });