Repeating the same sort attribute with reverse direction overwrites the previous direction for that attribute

Bắt đầu bằng cách tái hiện GET /foos?sort=bar,baz,-bar và kiểm tra cách việc sắp xếp chỉ mục tài nguyên được truyền vào phương thức order của ActiveRecord. Xác nhận rằng hướng đầu tiên của một thuộc tính lặp lại được giữ nguyên, sau đó kiểm tra hành vi ORDER BY được tạo ra so với thứ tự ưu tiên mong đợi được mô tả trong issue.

This issue is a (choose one):

• Problem/bug report.

Checklist before submitting:

• I've searched for an existing issue.
• I've asked my question on Gitter and have not received a satisfactory answer.
• I've included a complete bug report template. This step helps us and allows us to see the bug without trying to reproduce the problem from your description. It helps you because you will frequently detect if it's a problem specific to your project.
• The feature I'm asking for is compliant with the JSON:API spec.

Description

So, this is a pretty slim edge case. It concerns repetition of an attribute in the sort param, which can yield some arguably weird results that are possibly not compliant with the JSON:API spec recommendations:

Sort fields SHOULD be applied in the order specified.

Scenario

The index of a resource is called with a sort param, where the same attribute occurs more than once with different directions:

GET /foos?sort=bar,baz,-bar

Expected outcome

The records are ordered as specified by all the sort params, with an order of precedence from left to right. Any repetitions of the same attribute can be ignored, since they won't make a difference.

ORDER BY `foos`.`bar` ASC, `foos`.`baz` ASC, `foos`.`bar` DESC

or, equivalently, ignoring the repeated attributes:

ORDER BY `foos`.`bar` ASC, `foos`.`baz` ASC

Actual outcome

Whenever a sort attribute is repeated, its direction overwrites the previous direction of that same attribute.

ORDER BY `foos`.`bar` DESC, `foos`.`baz` ASC

Since ActiveRecord's order uses keyword arguments, calling it with repeated arguments will result in the repeated value overwriting the original value (with a warning). So it could be argued that the present behavior is consistent with how ActiveRecord works.

However, considering sort order in a more general sense or in the context of an SQL query it seems reasonable to me that a repeating value should not overwrite the original value.