Make costly bulk call query optional

Bulk Call should be used by specifying
the `Prefer: params=multiple-objects` header.

test/Feature/RpcSpec.hs

@@ -433,24 +433,34 @@ spec actualPgVersion =
 
       it "ignores json keys not included in ?columns" $
         post "/rpc/sayhello?columns=name"
-          [json|{"name": "John", "smth": "here", "other": "stuff", "fake_id": 13}|] `shouldRespondWith`
+          [json|{"name": "John", "smth": "here", "other": "stuff", "fake_id": 13}|]
+          `shouldRespondWith`
           [json|"Hello, John"|]
           { matchHeaders = [matchContentTypeJson] }
 
-    context "bulk RPC" $ do
-      it "works with a scalar function an returns a json array" $
+      it "only takes the first object in case of array of objects payload" $
         post "/rpc/add_them"
           [json|[
             {"a": 1, "b": 2},
             {"a": 4, "b": 6},
-            {"a": 100, "b": 200}
-          ]|] `shouldRespondWith`
+            {"a": 100, "b": 200} ]|]
+          `shouldRespondWith` "3"
+          { matchHeaders = [matchContentTypeJson] }
+
+    context "bulk RPC with params=multiple-objects" $ do
+      it "works with a scalar function an returns a json array" $
+        request methodPost "/rpc/add_them" [("Prefer", "params=multiple-objects")]
+          [json|[
+            {"a": 1, "b": 2},
+            {"a": 4, "b": 6},
+            {"a": 100, "b": 200} ]|]
+          `shouldRespondWith`
           [json|
             [3, 10, 300]
           |] { matchHeaders = [matchContentTypeJson] }
 
       it "works with a scalar function an returns a json array when posting CSV" $
-        request methodPost "/rpc/add_them" [("Content-Type", "text/csv")]
+        request methodPost "/rpc/add_them" [("Content-Type", "text/csv"), ("Prefer", "params=multiple-objects")]
           "a,b\n1,2\n4,6\n100,200"
           `shouldRespondWith`
           [json|
@@ -461,11 +471,11 @@ spec actualPgVersion =
           }
 
       it "works with a non-scalar result" $
-        post "/rpc/get_projects_below?select=id,name"
+        request methodPost "/rpc/get_projects_below?select=id,name" [("Prefer", "params=multiple-objects")]
           [json|[
             {"id": 1},
-            {"id": 5}
-          ]|] `shouldRespondWith`
+            {"id": 5} ]|]
+          `shouldRespondWith`
           [json|
             [{"id":1,"name":"Windows 7"},
              {"id":2,"name":"Windows 10"},

test/QueryCost.hs

@@ -13,8 +13,7 @@ import           Text.Heredoc
 import Protolude hiding (get)
 
 import PostgREST.QueryBuilder (requestToCallProcQuery)
-import PostgREST.Types        (PgArg (..), QualifiedIdentifier (..),
-                               SqlQuery)
+import PostgREST.Types
 
 import SpecHelper (getEnvVarWithDefault)
 
@@ -30,22 +29,37 @@ main = do
     context "call proc query" $ do
       it "should not exceed cost when calling setof composite proc" $ do
         cost <- exec pool [str| {"id": 3} |] $
-          requestToCallProcQuery (QualifiedIdentifier "test" "get_projects_below") [PgArg "id" "int" True] False False
+          requestToCallProcQuery (QualifiedIdentifier "test" "get_projects_below") [PgArg "id" "int" True] False Nothing
         liftIO $
-          cost `shouldSatisfy` (< Just 2100)
+          cost `shouldSatisfy` (< Just 40)
 
       it "should not exceed cost when calling setof composite proc with empty params" $ do
         cost <- exec pool mempty $
-          requestToCallProcQuery (QualifiedIdentifier "test" "getallprojects") [] False False
+          requestToCallProcQuery (QualifiedIdentifier "test" "getallprojects") [] False Nothing
         liftIO $
           cost `shouldSatisfy` (< Just 20)
 
       it "should not exceed cost when calling scalar proc" $ do
         cost <- exec pool [str| {"a": 3, "b": 4} |] $
-          requestToCallProcQuery (QualifiedIdentifier "test" "add_them") [PgArg "a" "int" True, PgArg "b" "int" True] True False
+          requestToCallProcQuery (QualifiedIdentifier "test" "add_them") [PgArg "a" "int" True, PgArg "b" "int" True] True Nothing
         liftIO $
           cost `shouldSatisfy` (< Just 10)
 
+      context "params=multiple-objects" $ do
+        it "should not exceed cost when calling setof composite proc" $ do
+          cost <- exec pool [str| [{"id": 1}, {"id": 4}] |] $
+            requestToCallProcQuery (QualifiedIdentifier "test" "get_projects_below") [PgArg "id" "int" True] False (Just MultipleObjects)
+          liftIO $ do
+            cost `shouldSatisfy` (> Just 2000)
+            cost `shouldSatisfy` (< Just 2100)
+
+        it "should not exceed cost when calling scalar proc" $ do
+          cost <- exec pool [str| [{"a": 3, "b": 4}, {"a": 1, "b": 2}, {"a": 8, "b": 7}] |] $
+            requestToCallProcQuery (QualifiedIdentifier "test" "add_them") [PgArg "a" "int" True, PgArg "b" "int" True] True Nothing
+          liftIO $
+            cost `shouldSatisfy` (< Just 10)
+
+
 exec :: P.Pool -> ByteString -> SqlQuery -> IO (Maybe Int64)
 exec pool input query =
   join . rightToMaybe <$>