change SET_SORT reducer to accept a order value.

packages/ra-core/src/controller/ListController.js

@@ -211,7 +211,7 @@ export class ListController extends Component {
         );
     }
 
-    setSort = sort => this.changeParams({ type: SET_SORT, payload: sort });
+    setSort = sort => this.changeParams({ type: SET_SORT, payload: { sort } });
 
     setPage = page => this.changeParams({ type: SET_PAGE, payload: page });
 

packages/ra-core/src/reducer/admin/resource/list/queryReducer.spec.ts

@@ -1,5 +1,5 @@
 import assert from 'assert';
-import queryReducer from './queryReducer';
+import queryReducer, { SORT_ASC, SORT_DESC } from './queryReducer';
 
 describe('Query Reducer', () => {
     describe('SET_PAGE action', () => {
@@ -66,4 +66,70 @@ describe('Query Reducer', () => {
             assert.equal(updatedState.page, 1);
         });
     });
+    describe('SET_SORT action', () => {
+        it('should set SORT_ASC order by default when sort value is new', () => {
+            const updatedState = queryReducer(
+                {},
+                {
+                    type: 'SET_SORT',
+                    payload: { sort: 'foo' },
+                }
+            );
+            assert.deepEqual(updatedState, {
+                sort: 'foo',
+                order: SORT_ASC,
+                page: 1,
+            });
+        });
+        it('should set order by payload.order value when sort value is new', () => {
+            const updatedState = queryReducer(
+                {},
+                {
+                    type: 'SET_SORT',
+                    payload: { sort: 'foo', order: SORT_DESC },
+                }
+            );
+            assert.deepEqual(updatedState, {
+                sort: 'foo',
+                order: SORT_DESC,
+                page: 1,
+            });
+        });
+        it("should set order as the opposite of the one in previous state when sort hasn't change", () => {
+            const updatedState = queryReducer(
+                {
+                    sort: 'foo',
+                    order: SORT_DESC,
+                    page: 1,
+                },
+                {
+                    type: 'SET_SORT',
+                    payload: { sort: 'foo' },
+                }
+            );
+            assert.deepEqual(updatedState, {
+                sort: 'foo',
+                order: SORT_ASC,
+                page: 1,
+            });
+        });
+        it("should set order as the opposite of the one in previous state even if order is specified in the payload when sort hasn't change", () => {
+            const updatedState = queryReducer(
+                {
+                    sort: 'foo',
+                    order: SORT_DESC,
+                    page: 1,
+                },
+                {
+                    type: 'SET_SORT',
+                    payload: { sort: 'foo', order: SORT_DESC },
+                }
+            );
+            assert.deepEqual(updatedState, {
+                sort: 'foo',
+                order: SORT_ASC,
+                page: 1,
+            });
+        });
+    });
 });

packages/ra-core/src/reducer/admin/resource/list/queryReducer.ts

@@ -25,7 +25,7 @@ interface State {
 const queryReducer: Reducer<State> = (previousState, { type, payload }) => {
     switch (type) {
         case SET_SORT:
-            if (payload === previousState.sort) {
+            if (payload.sort === previousState.sort) {
                 return {
                     ...previousState,
                     order: oppositeOrder(previousState.order),
@@ -35,8 +35,8 @@ const queryReducer: Reducer<State> = (previousState, { type, payload }) => {
 
             return {
                 ...previousState,
-                sort: payload,
-                order: SORT_ASC,
+                sort: payload.sort,
+                order: payload.order || SORT_ASC,
                 page: 1,
             };