Mark Request/Response bodys with Content-Lengths, closes #522 (#545)

Previously, using a `Request`/`Response` `body` in another `fetch`
request, without copying over headers would send the request with
`Transfer-Encoding: chunked`. The Workers runtime will remember the
`Content-Length` here, so we now attach it to the stream.

Author: mrbbot

packages/core/src/standards/http.ts

@@ -270,6 +270,17 @@ export class Body<Inner extends BaseRequest | BaseResponse> {
     // TODO: maybe set { highWaterMark: 0 } as a strategy here?
     bodyStream = new ReadableStream(source);
     Object.defineProperty(bodyStream, kBodyStreamBrand, { value: true });
+
+    // If this body has a known content length, attach it to the body
+    // https://github.com/cloudflare/miniflare/issues/522
+    // (note `parseInt(null)` is `NaN`)
+    const maybeContentLength = parseInt(this.headers.get("Content-Length")!);
+    if (!isNaN(maybeContentLength)) {
+      Object.defineProperty(bodyStream, kContentLength, {
+        value: maybeContentLength,
+      });
+    }
+
     return (this[kBodyStream] = bodyStream);
   }
   get bodyUsed(): boolean {
@@ -835,17 +846,8 @@ export async function fetch(
 
   await waitForOpenOutputGate();
 
-  // Don't pass our strange hybrid Request to undici
-  if (input instanceof Request) input = input[_kInner];
-  if (init instanceof Request) init = init[_kInner] as RequestInit;
-  if (!(init instanceof BaseRequest) && init?.body instanceof ReadableStream) {
-    // We mutate `init` here, make sure this isn't visible to the caller
-    init = cloneRequestInit(init);
-    init.duplex = "half";
-  }
-
   // Set the headers guard to "none" so we can delete the "Host" header
-  const req = new BaseRequest(input, init);
+  const req = new Request(input, init);
   // @ts-expect-error internal kGuard isn't included in type definitions
   req.headers[fetchSymbols.kGuard] = "none";
   // Delete the "Host" header, the correct value will be added by undici
@@ -877,7 +879,8 @@ export async function fetch(
     this instanceof Dispatcher ? this : getGlobalDispatcher(),
     removeHeaders
   );
-  const baseRes = await baseFetch(req, { dispatcher });
+  // Don't pass our strange hybrid Request to undici
+  const baseRes = await baseFetch(req[_kInner], { dispatcher });
 
   // Increment the subrequest count by the number of redirects
   // TODO (someday): technically we should check the subrequest count before

packages/core/test/standards/http.spec.ts

@@ -1248,6 +1248,28 @@ test("fetch: accepts stream body", async (t) => {
   res = await fetch(upstream, { method: "POST", body: stream });
   t.is(await res.text(), "chunk2");
 });
+test("fetch: uses known content length if possible", async (t) => {
+  // https://github.com/cloudflare/miniflare/issues/522
+  const upstream = (
+    await useServer(t, (req, res) => {
+      res.end(String(req.headers["transfer-encoding"]));
+    })
+  ).http;
+
+  const body = new ReadableStream({
+    start(controller) {
+      controller.enqueue(utf8Encode("chunk"));
+      controller.close();
+    },
+  });
+  const request = new Request("http://localhost", {
+    method: "POST",
+    headers: { "Content-Length": "5" },
+    body,
+  });
+  const res = await fetch(upstream, { method: "POST", body: request.body });
+  t.is(await res.text(), "undefined");
+});
 test('fetch: returns full Response for "manual" redirect', async (t) => {
   const upstream = (await useServer(t, redirectingServerListener)).http;
   const url = new URL("/?n=3", upstream);