fix: prefer async iteration vs callbacks

packages/next/src/experimental/testmode/proxy/server.ts

@@ -5,17 +5,14 @@ import { UNHANDLED } from './types'
 import type { FetchHandler } from './fetch-api'
 import { handleFetch } from './fetch-api'
 
-function readBody(req: IncomingMessage): Promise<Buffer> {
-  return new Promise<Buffer>((resolve, reject) => {
-    const acc: Buffer[] = []
-    req.on('data', (chunk) => {
-      acc.push(chunk)
-    })
-    req.on('end', () => {
-      resolve(Buffer.concat(acc))
-    })
-    req.on('error', reject)
-  })
+async function readBody(req: IncomingMessage): Promise<Buffer> {
+  const acc: Buffer[] = []
+
+  for await (const chunk of req) {
+    acc.push(chunk)
+  }
+
+  return Buffer.concat(acc)
 }
 
 export async function createProxyServer({

packages/next/src/server/app-render/action-handler.ts

@@ -46,18 +46,11 @@ function nodeToWebReadableStream(nodeReadable: import('stream').Readable) {
     }
 
     return new ReadableStream({
-      start(controller) {
-        nodeReadable.on('data', (chunk) => {
+      start: async (controller) => {
+        for await (const chunk of nodeReadable) {
           controller.enqueue(chunk)
-        })
-
-        nodeReadable.on('end', () => {
-          controller.close()
-        })
-
-        nodeReadable.on('error', (error) => {
-          controller.error(error)
-        })
+        }
+        controller.close()
       },
     })
   } else {

packages/next/src/server/body-streams.ts

@@ -8,12 +8,11 @@ export function requestToBodyStream(
   stream: Readable
 ) {
   return new context.ReadableStream({
-    start(controller) {
-      stream.on('data', (chunk) =>
+    start: async (controller) => {
+      for await (const chunk of stream) {
         controller.enqueue(new KUint8Array([...new Uint8Array(chunk)]))
-      )
-      stream.on('end', () => controller.close())
-      stream.on('error', (err) => controller.error(err))
+      }
+      controller.close()
     },
   })
 }