Requesting Clarity for new Streaming Feature

[pg-wtatum]

A few issues related to the new async generator feature for streaming responses, one of which applied to the legacy method as well.

• What is the exact return type used to signal streaming and is it possible to do this without a generator? In the event an underlying operation is callback based the ergonomics of adapting that into yield calls can be difficult since you cannot yield inside a callback. Here is an example of how I "got this to work" for the listen/notify mechanism of postgresjs. I was able to wrap the notify call in a ReadableStream and then iterate the stream but maybe I'm missing something that allows skipping some of the ceremony

  .get("/funky", async function* ({}) {
  let ul: ListenMeta;
  
  try {
    const rs = new ReadableStream<{}>({
      async start(controller) {
        ul = await sql.listen(
          "test",
          // Onnotify
          (payload) => {
            controller.enqueue({
              kind: "notify",
              payload,
            });
          },
          // Onconnect
          () => {
            controller.enqueue({
              kind: "connected",
            });
          }
        );
  
        setTimeout(() => {
          controller.enqueue({
            kind: "timeout",
          });
          controller.close();
        }, 10_000);
      },
    });
  
    for await (const item of rs) {
      console.log(item);
      yield item;
    }
  } finally {
    ul?.unlisten();
  }
  })

  • The content-type is automatically set to text/event-stream but the call from browser client using treaty is not made using EventSource so the semantics are different (no automatic reconnect, no tracking of IDs, etc)
  • It seems like instead of using the typical Elysia automatic object -> JSON I instead get the toString version is this intended?

[pg-wtatum]

To elaborate further on the object -> JSON question, if I implement my server side as a typed generator that produces something other than string the inferred client type in treaty is AsyncGenerator but in fact I just get the string [object Object] instead

[pg-wtatum]

Sorry for the drip feed of info but the behavior is actually weirder than I first thought -- if I manually call JSON.stringify on the server, the values produced by

  const res = await client.funky.get();
  if (!res.error) {
    for await (const d of res.data) {
      console.log(d);
    }
  }

are objects rather than strings. This causes some significant typescript issues as I need to type the generator as string (but it actually returns objects)

edit to add I see that 1.1.3 was released today to address other issues related to the stream feature. I have updated and this appears to still be the case.

[directormac]

Currently implementing it using the Generator function as described in the docs, using for await in both ends when data is string or a certain type, it's being inferred correctly but can't parse them well as sometimes it yields 2 or more at once. i think this needs to be moved at eden repo

[pg-wtatum]

Not sure it's strictly on the Eden side -- I've definitely seen cases where only one object is emitted and it still serializes onto the wire as [object Object], but if manually stringified with JSON.stringify it goes onto the wire as JSON (of course) and is parsed by Eden.

Given the content type is text/event-stream I would expect that the wire format is newline delimited and simultaneous emissions should not be an issue?