Server-Sent Events

import * as BunnySDK from "@bunny.net/edgescript-sdk";

const HEARTBEAT_MS = 15_000;

BunnySDK.net.http.serve(async (request: Request) => {
  const encoder = new TextEncoder();
  let timer: number;
  let onClosed: () => void;

  // Resolves when the client goes away and the runtime cancels the stream.
  const closed = new Promise<void>((resolve) => {
    onClosed = resolve;
  });

  const stream = new ReadableStream({
    start(controller) {
      let id = 0;

      const send = () => {
        id += 1;
        controller.enqueue(
          encoder.encode(
            `id: ${id}\nevent: tick\ndata: ${new Date().toISOString()}\n\n`,
          ),
        );
      };

      // Send the first event at once. The client waits until this byte.
      send();

      timer = setInterval(send, HEARTBEAT_MS);
    },
    cancel() {
      clearInterval(timer);
      onClosed();
    },
  });

  // It is important to call waitUntil; otherwise the script may be evicted
  // while the stream is still open.
  Bunny.v1.waitUntil(closed);

  return new Response(stream, {
    headers: {
      "content-type": "text/event-stream",
      "cache-control": "no-cache",
    },
  });
});

// Wrong. If the subrequest takes longer than 60 seconds, the client gets a 504
// and never sees the stream.
const upstream = await fetch(slowOrigin);
return new Response(upstream.body, { headers });

// Right. The response goes back at once, and the subrequest runs inside the
// stream, so a slow origin delays an event instead of failing the request.
const stream = new ReadableStream({
  async start(controller) {
    const upstream = await fetch(slowOrigin);
    // ... write events from the upstream body
  },
});
return new Response(stream, { headers });