feat: allow ordering using column aliases

src/PostgREST/ApiRequest/QueryParams.hs

@@ -52,7 +52,7 @@ import PostgREST.ApiRequest.Types (AggregateFunction (..),
                                    ListVal, LogicOperator (..),
                                    LogicTree (..), OpExpr (..),
                                    OpQuantifier (..), Operation (..),
-                                   OrderDirection (..),
+                                   OrderDirection (..), OrderElement (..),
                                    OrderNulls (..), OrderTerm (..),
                                    QuantOperator (..),
                                    SelectItem (..),
@@ -762,11 +762,11 @@ pOrder :: Parser [OrderTerm]
 pOrder = lexeme (try pOrderRelationTerm <|> pOrderTerm) `sepBy1` char ','
   where
     pOrderTerm = do
-      fld <- pField
+      elm <- pOrdElem
       dir <- optionMaybe pOrdDir
       nls <- optionMaybe pNulls <* pEnd <|>
              pEnd $> Nothing
-      return $ OrderTerm fld dir nls
+      return $ OrderTerm elm dir nls
 
     pOrderRelationTerm = do
       nam <- pFieldName
@@ -775,6 +775,10 @@ pOrder = lexeme (try pOrderRelationTerm <|> pOrderTerm) `sepBy1` char ','
       nls <- optionMaybe pNulls <* pEnd <|> pEnd $> Nothing
       return $ OrderRelationTerm nam fld dir nls
 
+    pOrdElem :: Parser OrderElement
+    pOrdElem = OrderAlias <$> try (aliasSeparator *> pFieldName) <|>
+               OrderField <$> try pField
+
     pNulls :: Parser OrderNulls
     pNulls = try (pDelimiter *> string "nullsfirst" $> OrderNullsFirst) <|>
              try (pDelimiter *> string "nullslast"  $> OrderNullsLast)

src/PostgREST/ApiRequest/Types.hs

@@ -22,6 +22,7 @@
   , Operation (..)
   , OpQuantifier(..)
   , OrderDirection(..)
+  , OrderElement(..)
   , OrderNulls(..)
   , OrderTerm(..)
   , SingleVal
@@ -65,7 +66,7 @@
 
 data OrderTerm
   = OrderTerm
-    { otTerm      :: Field
+    { otTerm      :: OrderElement
     , otDirection :: Maybe OrderDirection
     , otNullOrder :: Maybe OrderNulls
     }
@@ -77,6 +78,11 @@
     }
   deriving (Eq, Show)
 
+data OrderElement
+  = OrderField Field
+  | OrderAlias FieldName
+  deriving (Eq, Show)
+
 data OrderDirection
   = OrderAsc
   | OrderDesc

src/PostgREST/Plan.hs

@@ -782,7 +782,8 @@ addOrders ctx ApiRequest{..} rReq =
 
 resolveOrder :: ResolverContext -> OrderTerm -> CoercibleOrderTerm
 resolveOrder _ (OrderRelationTerm a b c d) = CoercibleOrderRelationTerm a b c d
-resolveOrder ctx (OrderTerm fld dir nulls) = CoercibleOrderTerm (resolveTypeOrUnknown ctx fld Nothing) dir nulls
+resolveOrder _ (OrderTerm (OrderAlias ali) dir nulls) = CoercibleOrderAliasTerm ali dir nulls
+resolveOrder ctx (OrderTerm (OrderField fld) dir nulls) = CoercibleOrderFieldTerm (resolveTypeOrUnknown ctx fld Nothing) dir nulls
 
 -- Validates that the related resource on the order is an embedded resource,
 -- e.g. if `clients` is inside the `select` in /projects?order=clients(id)&select=*,clients(*),
@@ -792,7 +793,6 @@ addRelatedOrders (Node rp@ReadPlan{order,from} forest) = do
   newOrder <- newRelOrder `traverse` order
   Node rp{order=newOrder} <$> addRelatedOrders `traverse` forest
   where
-    newRelOrder cot@CoercibleOrderTerm{}                   = Right cot
     newRelOrder cot@CoercibleOrderRelationTerm{coRelation} =
       let foundRP = rootLabel <$> find (\(Node ReadPlan{relName, relAlias} _) -> coRelation == fromMaybe relName relAlias) forest in
       case foundRP of
@@ -804,6 +804,8 @@ addRelatedOrders (Node rp@ReadPlan{order,from} forest) = do
             else Left $ RelatedOrderNotToOne (qiName from) name
         Nothing ->
           Left $ NotEmbedded coRelation
+    newRelOrder cot = Right cot
+
 
 -- | Searches for null filters on embeds, e.g. `projects=not.is.null` on `GET /clients?select=*,projects(*)&projects=not.is.null`
 --

src/PostgREST/Plan/Types.hs

@@ -65,11 +65,16 @@
   deriving (Eq, Show)
 
 data CoercibleOrderTerm
-  = CoercibleOrderTerm
+  = CoercibleOrderFieldTerm
     { coField     :: CoercibleField
     , coDirection :: Maybe OrderDirection
     , coNullOrder :: Maybe OrderNulls
     }
+  | CoercibleOrderAliasTerm
+    { coAlias     :: Alias
+    , coDirection :: Maybe OrderDirection
+    , coNullOrder :: Maybe OrderNulls
+    }
   | CoercibleOrderRelationTerm
     { coRelation  :: FieldName
     , coRelTerm   :: Field

src/PostgREST/Query/SqlFragment.hs

@@ -348,7 +348,8 @@ pgFmtOrderTerm qi ot =
     maybe mempty nullOrder $ coNullOrder ot])
   where
     fmtOTerm = \case
-      CoercibleOrderTerm{coField=cof}                            -> pgFmtField qi cof
+      CoercibleOrderFieldTerm{coField=cof}                       -> pgFmtField qi cof
+      CoercibleOrderAliasTerm{coAlias=coa}                       -> pgFmtIdent coa
       CoercibleOrderRelationTerm{coRelation, coRelTerm=(fn, jp)} -> pgFmtField (QualifiedIdentifier mempty coRelation) (unknownField fn jp)
 
     direction OrderAsc  = "ASC"

test/spec/Feature/Query/AggregateFunctionsSpec.hs

@@ -25,6 +25,9 @@ allowed =
       it "returns the count grouped by all provided fields when other fields are selected" $
         get "/projects?select=c:count(),client_id&order=client_id.desc" `shouldRespondWith`
           [json|[{ "c": 1, "client_id": null }, { "c": 2, "client_id": 2 }, { "c": 2, "client_id": 1}]|] { matchHeaders = [matchContentTypeJson] }
+      it "works with a json field accessor and aggregates" $
+        get "/json_table?select=data->foo->>bar,count()&order=:bar.desc.nullslast" `shouldRespondWith`
+          [json|[{ "bar":"baz", "count":1}, {"bar":null, "count":2}]|] {matchHeaders = [matchContentTypeJson] }
 
     context "performing a count by using it as a column (backwards compat)" $ do
       it "returns the count of all rows when no other fields are selected" $