feat(cache): cache event handler stream response

src/runtime/internal/cache.ts

@@ -5,6 +5,7 @@ import {
   fetchWithEvent,
   handleCacheHeaders,
   isEvent,
+  isStream,
   splitCookiesString,
 } from "h3";
 import type { EventHandlerRequest, EventHandlerResponse, H3Event } from "h3";
@@ -406,11 +407,26 @@ export function defineCachedEventHandler<
         headers["cache-control"] = cacheControl.join(", ");
       }
 
+      let cachedBody = body as any;
+      // When handler response is a stream, we cache the result of this stream
+      if (body instanceof ReadableStream) {
+        const td = new TextDecoder();
+        let buffer = "";
+        await body.pipeTo(
+          new WritableStream({
+            write(chunk) {
+              buffer += td.decode(chunk);
+            },
+          })
+        );
+        cachedBody = buffer;
+      }
+
       // Create cache entry for response
       const cacheEntry: ResponseCacheEntry<Response> = {
         code: event.node.res.statusCode,
         headers,
-        body,
+        body: cachedBody,
       };
 
       return cacheEntry;

test/fixture/nitro.config.ts

@@ -91,6 +91,7 @@ export default defineNitroConfig({
     "/rules/_/cached/noncached": { cache: false, swr: false, isr: false },
     "/rules/_/cached/**": { swr: true },
     "/api/proxy/**": { proxy: "/api/echo" },
+    "/stream-cached": { swr: true },
   },
   prerender: {
     crawlLinks: true,

test/fixture/routes/stream-cached.ts

@@ -0,0 +1,13 @@
+export default eventHandler(() => {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode("nitro"));
+      controller.enqueue(encoder.encode("is"));
+      controller.enqueue(encoder.encode("awesome,"));
+      controller.enqueue(encoder.encode(Date.now().toString()));
+      controller.close();
+    },
+  });
+  return stream;
+});

test/presets/netlify-legacy.test.ts

@@ -71,6 +71,7 @@ describe("nitro:preset:netlify-legacy", async () => {
         /rules/isr-ttl/*	/.netlify/builders/server 200
         /rules/isr/*	/.netlify/builders/server 200
         /rules/dynamic	/.netlify/functions/server 200
+        /stream-cached	/.netlify/builders/server 200
         /build/* /build/:splat 200
         /* /.netlify/functions/server 200"
       `);

test/presets/vercel.test.ts

@@ -142,6 +142,10 @@ describe("nitro:preset:vercel", async () => {
                 "dest": "/__nitro--rules-swr-ttl?url=$url",
                 "src": "(?<url>/rules/swr-ttl/.*)",
               },
+              {
+                "dest": "/stream-cached?url=$url",
+                "src": "/stream-cached",
+              },
               {
                 "dest": "/__nitro",
                 "src": "/(.*)",

test/tests.ts

@@ -729,6 +729,34 @@ export function testNitro(
         }
       }
     );
+
+    it.skipIf(
+      ctx.isIsolated ||
+        (isWindows && ctx.preset === "nitro-dev") ||
+        ctx.isLambda
+    )("should cache stream result", async () => {
+      const { data } = await callHandler({
+        url: "/stream-cached",
+      });
+
+      const [str, timestamp] = data.split(",") as string[];
+
+      expect(str).toBe(
+        ctx.isLambda ? btoa("nitroisawesome") : "nitroisawesome"
+      );
+
+      const calls = await Promise.all([
+        callHandler({ url: "/stream-cached" }),
+        callHandler({ url: "/stream-cached" }),
+        callHandler({ url: "/stream-cached" }),
+      ]);
+
+      for (const call of calls) {
+        expect(call.data).toBe(
+          ctx.isLambda ? btoa(`${str},${timestamp}`) : `${str},${timestamp}`
+        );
+      }
+    });
   });
 
   describe("scanned files", () => {