Allow finishing a json path with single arrow ->

Now a json can be obtained without resorting to casting

- Previously: `/json_arr?select=data->>2::json`
- Now: `/json_arr?select=data->2`

src/PostgREST/Parsers.hs

@@ -81,15 +81,22 @@ pFieldName = do
     dash = isDash *> pure '-'
 
 pJsonPath :: Parser JsonPath
-pJsonPath = (<>) <$> many pJsonPathOp <*> ( (:[]) <$> (string "->>" *> (try pJIdx <|> pJKey)) )
+pJsonPath = many pJsonOperation
   where
-    pJsonPathOp :: Parser JsonPathOp
-    pJsonPathOp = try (string "->" *> pJIdx) <|> try (string "->" *> pJKey)
-    pJKey = JKey . toS <$> pFieldName
-    pJIdx = JIdx . toS <$> ((:) <$> option '+' (char '-') <*> many1 digit) <* pEnd
-    pEnd = try (void $ lookAhead (string "->")) <|>
-           try (void $ lookAhead (string "::")) <|>
-           try eof
+    pJsonOperation :: Parser JsonOperation
+    pJsonOperation = pJsonArrow <*> pJsonOperand
+
+    pJsonArrow   =
+      try (string "->>" $> J2Arrow) <|>
+      try (string "->" $> JArrow)
+
+    pJsonOperand =
+      let pJKey = JKey . toS <$> pFieldName
+          pJIdx = JIdx . toS <$> ((:) <$> option '+' (char '-') <*> many1 digit) <* pEnd
+          pEnd = try (void $ lookAhead (string "->")) <|>
+                 try (void $ lookAhead (string "::")) <|>
+                 try eof in
+      try pJIdx <|> try pJKey
 
 pField :: Parser Field
 pField = lexeme $ (,) <$> pFieldName <*> option [] pJsonPath

src/PostgREST/QueryBuilder.hs

@@ -450,22 +450,22 @@ pgFmtLogicTree qi (Stmnt flt) = pgFmtFilter qi flt
 
 pgFmtJsonPath :: JsonPath -> SqlFragment
 pgFmtJsonPath = \case
-  []     -> ""
-  [x]    -> "->>" <> pgFmtJsonPathOp x
-  (x:xs) -> "->" <> pgFmtJsonPathOp x <> pgFmtJsonPath xs
+  []             -> ""
+  (JArrow x:xs)  -> "->" <> pgFmtJsonOperand x <> pgFmtJsonPath xs
+  (J2Arrow x:xs) -> "->>" <> pgFmtJsonOperand x <> pgFmtJsonPath xs
   where
-    pgFmtJsonPathOp (JKey k) = pgFmtLit k
-    pgFmtJsonPathOp (JIdx i) = pgFmtLit i <> "::int"
+    pgFmtJsonOperand (JKey k) = pgFmtLit k
+    pgFmtJsonOperand (JIdx i) = pgFmtLit i <> "::int"
 
 pgFmtAs :: FieldName -> JsonPath -> Maybe Alias -> SqlFragment
 pgFmtAs _ [] Nothing = ""
-pgFmtAs fName jp Nothing = case lastMay jp of
+pgFmtAs fName jp Nothing = case jOp <$> lastMay jp of
   Just (JKey key) -> " AS " <> pgFmtIdent key
   Just (JIdx _)   -> " AS " <> pgFmtIdent (fromMaybe fName lastKey)
     -- We get the lastKey because on:
     -- `select=data->1->mycol->>2`, we need to show the result as [ {"mycol": ..}, {"mycol": ..} ]
     -- `select=data->3`, we need to show the result as [ {"data": ..}, {"data": ..} ]
-    where lastKey = jpOp <$> find (\case JKey{} -> True; _ -> False) (reverse jp)
+    where lastKey = jVal <$> find (\case JKey{} -> True; _ -> False) (jOp <$> reverse jp)
   Nothing -> ""
 pgFmtAs _ _ (Just alias) = " AS " <> pgFmtIdent alias
 

src/PostgREST/Types.hs

@@ -238,12 +238,15 @@ instance Show LogicOperator where
 data LogicTree = Expr Bool LogicOperator [LogicTree] | Stmnt Filter deriving (Show, Eq)
 
 type FieldName = Text
-type JsonPath = [JsonPathOp]
 {-|
-  Json path operands as specified in https://www.postgresql.org/docs/9.5/static/functions-json.html
-  the array index is Text because we reuse our escaping functons and let pg do the casting with '1'::int
+  Json path operations as specified in https://www.postgresql.org/docs/9.4/static/functions-json.html
 -}
-data JsonPathOp = JKey{jpOp :: Text} | JIdx{jpOp :: Text} deriving (Show, Eq)
+type JsonPath = [JsonOperation]
+-- | Represents the single arrow `->` or double arrow `->>` operators
+data JsonOperation = JArrow{jOp :: JsonOperand} | J2Arrow{jOp :: JsonOperand} deriving (Show, Eq)
+-- | Represents the key(`->'key'`) or index(`->'1`::int`), the index is Text because we reuse our escaping functons and let pg do the casting with '1'::int
+data JsonOperand = JKey{jVal :: Text} | JIdx{jVal :: Text} deriving (Show, Eq)
+
 type Field = (FieldName, JsonPath)
 type Alias = Text
 type Cast = Text