Add withStreamBody

Fetch needs `duplex: half` when setting a stream request body.

https://developer.chrome.com/docs/capabilities/web-apis/fetch-streaming-requests#half_duplex

This also adds an error case to the legacy streams api when configuring a request with `withStreamBody`

Author: andrewMacmurray

integration-tests/http-client/src/Tests.gren

@@ -139,6 +139,70 @@ suite permission =
                     test "succeeds with empty record"
                         (\_ -> Expect.equal {} res.data)
                 )
+            , await
+                (Stream.fromArray [ meaningOfLifeInBytes ]
+                    |> Task.mapError StreamErr
+                    |> Task.andThen
+                        (\body ->
+                            HttpClient.post "/echo"
+                                |> HttpClient.withStreamBody "application/octet-stream" body
+                                |> HttpClient.expectBytes
+                                |> send
+                                |> Task.mapError HttpErr
+                        )
+                )
+                "with streaming request body"
+                (\res ->
+                    test "streams request body" (\_ -> Expect.equal meaningOfLifeInBytes res.data)
+                )
+            , await
+                (Stream.identityTransformation
+                    |> Task.andThen
+                        (\transform ->
+                            Stream.writable transform
+                                |> Stream.writeStringAsBytes "Hello!"
+                                |> Task.andThen Stream.closeWritable
+                                |> Task.map (\_ -> Stream.readable transform)
+                                |> Task.mapError StreamErr
+                        )
+                    |> Task.andThen
+                        (\body ->
+                            HttpClient.post "/echo"
+                                |> HttpClient.withStreamBody "application/octet-stream" body
+                                |> HttpClient.expectString
+                                |> HttpClient.send permission
+                                |> Task.mapError HttpErr
+                        )
+                )
+                "with writable stream"
+                (\res ->
+                    test "streams request body" (\_ -> Expect.equal "Hello!" res.data)
+                )
+            , await
+                (let
+                    request1 : Task Error (HttpClient.Response (Stream.Readable Bytes))
+                    request1 =
+                        HttpClient.post "/echo"
+                            |> HttpClient.withBytesBody "application/octet-stream" meaningOfLifeInBytes
+                            |> HttpClient.expectStream
+                            |> send
+                            |> Task.mapError HttpErr
+
+                    request2 : Stream.Readable Bytes -> Task Error (HttpClient.Response Bytes)
+                    request2 streamBody =
+                        HttpClient.post "/echo"
+                            |> HttpClient.withStreamBody "application/octet-stream" streamBody
+                            |> HttpClient.expectBytes
+                            |> send
+                            |> Task.mapError HttpErr
+                 in
+                 request1
+                    |> Task.andThen (\res -> request2 res.data)
+                )
+                "with piped streaming requests"
+                (\res ->
+                    test "receives bytes through piped request chain" (\_ -> Expect.equal meaningOfLifeInBytes res.data)
+                )
             , await
                 (HttpClient.post "/echo"
                     |> HttpClient.withBytesBody "application/octet-stream" meaningOfLifeInBytes

src/Gren/Kernel/HttpClient.js

@@ -40,6 +40,7 @@ var _HttpClient_request = function (config) {
         {},
         config.__$headers,
       ),
+      duplex: "half",
       body: _HttpClient_extractRequestBody(config),
       signal: controller.signal,
     })
@@ -189,7 +190,13 @@ var _HttpClient_stream = F4(function (cleanup, sendToApp, request, config) {
 
     const body = _HttpClient_extractRequestBody(config);
 
-    if (body == null) {
+    if (config.__$bodyType === "STREAM") {
+      send(
+        __HttpClient_UnknownError(
+          "stream request body not supported in legacy api",
+        ),
+      );
+    } else if (body == null) {
       send(__HttpClient_SentChunk(request));
     } else {
       req.write(body, () => {
@@ -303,6 +310,8 @@ var _HttpClient_extractRequestBody = function (config) {
       return config.__$body.a;
     case "BYTES":
       return _HttpClient_prepBytes(config.__$body.a);
+    case "STREAM":
+      return config.__$body.a;
   }
 };
 

src/HttpClient.gren

@@ -4,7 +4,7 @@ effect module HttpClient where { command = MyCmd } exposing
     , RequestConfiguration, get, post, request
     , defaultTimeout, withTimeout
     , withHeader, withDuplicatedHeader
-    , Body, withEmptyBody, withStringBody, withJsonBody, withBytesBody
+    , Body, withEmptyBody, withStringBody, withJsonBody, withBytesBody, withStreamBody
     , Expect, expectAnything, expectNothing, expectString, expectJson, expectBytes, expectStream
     , send
     , Response
@@ -55,7 +55,7 @@ It might be interesting to read this [list of HTTP header fields](https://en.wik
 
 The request body is the actual data that you wish to send to a server.
 
-@docs Body, withEmptyBody, withStringBody, withJsonBody, withBytesBody
+@docs Body, withEmptyBody, withStringBody, withJsonBody, withBytesBody, withStreamBody
 
 ## Expected response body
 
@@ -78,6 +78,8 @@ Once your `Response` is configured, you'll want to actually send the request.
 
 ## Streaming
 
+**DEPRECATED** - this api will be removed in the next major version, prefer using the newer [withStreamBody](#withStreamBody) and [expectStream](#expectStream) for streaming requests.
+
 Streaming is the more advanced way to perform a HTTP request. This requires that you follow the Elm
 architecture, as you'll receive messages for every chunk of data sent and received. The benefit of this
 extra complexity, is that you can perform actions while the request is being performed.
@@ -225,6 +227,7 @@ type Body
     = BodyEmpty
     | BodyString String
     | BodyBytes Bytes
+    | BodyStream (Stream.Readable Bytes)
 
 
 bodyTypeAsString : Body -> String
@@ -239,6 +242,9 @@ bodyTypeAsString body =
         BodyBytes _ ->
             "BYTES"
 
+        BodyStream _ ->
+            "STREAM"
+
 
 {-| Removes the body from the [RequestConfiguration](#RequestConfiguration).
 You normally don't have to use this function, as an empty body is the default.
@@ -286,6 +292,44 @@ withBytesBody mimeType value req =
     }
 
 
+{-| Sets the provided Readable Bytes stream as the request body. You need to provide a mime type to
+desribe what the bytes represent. This mime type will be set as the "Content-Type" header,
+potentially overwriting the header if it has already been set.
+
+You could use a stream body for sending a large file in an http request for example:
+
+    import HttpClient
+    import FileSystem
+    import FileSystem.Path as Path
+
+
+    type Error
+        = FsErr FileSystem.Error
+        | HttpErr HttpClient.Error
+
+
+    upload : HttpClient.Permission -> FileSystem.Permission -> Task Error (HttpClient.Response {})
+    upload httpPerm fsPerm =
+        Path.fromPosixString "/large-file.csv"
+            |> FileSystem.readFileStream fsPerm FileSystem.Beginning
+            |> Task.mapError FsErr
+            |> Task.andThen (\fileStream ->
+                HttpClient.post "/upload"
+                    |> HttpClient.withStreamBody fileStream
+                    |> HttpClient.send httpPerm
+                    |> Task.mapError HttpErr
+            )
+
+-}
+withStreamBody : String -> Stream.Readable Bytes -> RequestConfiguration a -> RequestConfiguration a
+withStreamBody mimeType value req =
+    { req
+        | headers = Dict.set "content-type" [mimeType] req.headers
+        , body = BodyStream value
+    }
+
+
+
 -- EXPECT