Async generator handler should follow text/event-stream protocol

[remorses]

What version of Elysia.JS is running?

"elysia": "^1.1.3"

What platform is your computer?

Darwin 23.5.0 arm64 arm

What steps can reproduce the bug?

import { treaty } from '@elysiajs/eden'

import { Elysia } from 'elysia'

const app = new Elysia()
    .get('/', async function* generator() {
        await sleep(100)
        yield JSON.stringify({ body: 'Hello Elysia' })
        yield JSON.stringify({ body: 'Hello Elysia' })
        yield JSON.stringify({ body: 'Hello Elysia' })
        yield JSON.stringify({ body: 'Hello Elysia' })
        yield JSON.stringify({ body: 'Hello Elysia' })
    })
    .listen(3000, async () => {
        const app = treaty<App>('localhost:3000')

        {
            const { data: gen, error } = await app.index.get({})
            if (error) throw error

            for await (const res of gen) {
                console.log(res)
            }
        }
    })

export type App = typeof app

console.log(
    `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`,
)

function sleep(ms: number) {
    return new Promise(resolve => setTimeout(resolve, ms))
}

The output of this code will be:

{"body":"Hello Elysia"}{"body":"Hello Elysia"}{"body":"Hello Elysia"}
{
  body: "Hello Elysia",
}
{
  body: "Hello Elysia",
}

There are several problems with this code:

1. In Eden some items will be objects, sometimes strings. This is because Elysia cannot distinguish what separate each yieled item. This is because the server does not separate yielded items with new lines
2. The type inference of Eden is wrong because when you yield a string it will be converted to an object. The server should call JSON.stringify on all yielded items if the handler is an async generator. (also this is what the text/event-stream spec says)
3. Elysia just calls .toString() on the yielded items, this will cause problems where when you yield objects you will get [object Object] Async generator yielding an object results in [object Object] output #741

elysia/src/handler.ts

Line 156 in 8173d90

controller.enqueue(Buffer.from(chunk.toString()))

What is the expected behavior?

Elysia should return a text/event-stream compatible output if the handler is an async generator:

1. Separate each yielded object with a new line
2. JSON.stringify each item

What do you see instead?

Elysia concatenates the outputs inline calling .toString() on each of them

Additional information

No response

[macabeus]

I noticed that there are already two PRs fixing it, but it's stalled for a while...
Is there something that I can do to unblock them? I really would like to have it merged and released.

[remorses]

I created an alternative framework called Spiceflow inspired by Elysia here: https://github.com/remorses/spiceflow

It has support for Zod, async generators using server sent events and a lot more

[canadaduane]

I'm unsure about how to transfer Elysia's types to this function, but here is a transformer that can be called with an async generator that transforms the Elysia response from the more general long-polling HTTP response to the more specific Server Sent Event spec:

const sseEvent = (data: string) => `data: ${data}\n\n`;

export function sse(generator: any) {
  return async function* (ctx: any) {
    ctx.set = {
      ...ctx.set,
      headers: {
        ...ctx.set.headers,
        "x-accel-buffering": "no",
        "content-type": "text/event-stream",
        "cache-control": "no-cache",
      },
    };

    for await (const data of generator(ctx)) {
      yield sseEvent(JSON.stringify(data));
    }
  };
}

It can be called like this:

new Elysia()
  .get(
    "/source/:docId",
    sse(async function* ({ params: { docId } }) {
      while (true) {
        yield { msg: "Hello world!", docId };
        await delay(1000);
        yield { msg: "Goodbye!" };
        await delay(1000);
      }
    }),
  )