Ensure calltime parameters all take priority in useMutation

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

@@ -34,6 +34,7 @@ describe('useCreate', () => {
     it('returns a callback that can be used with mutation payload', () => {
         const dataProvider: Partial<DataProvider> = {
             create: jest.fn(() => Promise.resolve({ data: { id: 1 } } as any)),
+            update: jest.fn(() => Promise.resolve({ data: { id: 1 } } as any)),
         };
         let localCreate;
         const Dummy = () => {
@@ -55,7 +56,8 @@ describe('useCreate', () => {
                 data: { bar: 'baz' },
             },
         });
-        expect(dataProvider.create).toHaveBeenCalledWith('foo', {
+        expect(dataProvider.create).not.toHaveBeenCalled();
+        expect(dataProvider.update).toHaveBeenCalledWith('foo', {
             data: { bar: 'baz' },
         });
     });

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

@@ -76,6 +76,50 @@ describe('useMutation', () => {
         expect(action.meta.meta).toEqual('baz');
     });
 
+    it('should use callTimeQuery over definition query', () => {
+        const dataProvider = {
+            mytype: jest.fn(() => Promise.resolve({ data: { foo: 'bar' } })),
+            callTimeType: jest.fn(() =>
+                Promise.resolve({ data: { foo: 'bar' } })
+            ),
+        };
+
+        const myPayload = { foo: 1 };
+        const { getByText, dispatch } = renderWithRedux(
+            <DataProviderContext.Provider value={dataProvider}>
+                <Mutation
+                    type="mytype"
+                    resource="myresource"
+                    payload={myPayload}
+                >
+                    {mutate => (
+                        <button
+                            onClick={e =>
+                                mutate(
+                                    {
+                                        resource: 'callTimeResource',
+                                        type: 'callTimeType',
+                                        payload: { bar: 2 },
+                                    },
+                                    { meta: 'baz' }
+                                )
+                            }
+                        >
+                            Hello
+                        </button>
+                    )}
+                </Mutation>
+            </DataProviderContext.Provider>
+        );
+        fireEvent.click(getByText('Hello'));
+        const action = dispatch.mock.calls[0][0];
+        expect(action.payload).toEqual({ foo: 1, bar: 2 });
+        expect(action.meta.resource).toEqual('callTimeResource');
+        expect(action.meta.meta).toEqual('baz');
+        expect(dataProvider.mytype).not.toHaveBeenCalled();
+        expect(dataProvider.callTimeType).toHaveBeenCalled();
+    });
+
     it('should update the loading state when the mutation callback is triggered', () => {
         const dataProvider = {
             mytype: jest.fn(() => Promise.resolve({ data: { foo: 'bar' } })),

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

@@ -290,17 +290,20 @@ const mergeDefinitionAndCallTimeParameters = (
     if (!query && (!callTimeQuery || callTimeQuery instanceof Event)) {
         throw new Error('Missing query either at definition or at call time');
     }
-    if (callTimeQuery instanceof Event)
+
+    const event = callTimeQuery as Event;
+    if (callTimeQuery instanceof Event || !!event?.preventDefault)
         return {
             type: query.type,
             resource: query.resource,
             payload: query.payload,
             options: sanitizeOptions(options),
         };
-    if (query)
+
+    if (query) {
         return {
-            type: query.type || callTimeQuery.type,
-            resource: query.resource || callTimeQuery.resource,
+            type: callTimeQuery?.type || query.type,
+            resource: callTimeQuery?.resource || query.resource,
             payload: callTimeQuery
                 ? merge({}, query.payload, callTimeQuery.payload)
                 : query.payload,
@@ -312,6 +315,7 @@ const mergeDefinitionAndCallTimeParameters = (
                   )
                 : sanitizeOptions(options),
         };
+    }
     return {
         type: callTimeQuery.type,
         resource: callTimeQuery.resource,