Support custom SSE event

[linrium]

• I have looked for existing issues (including closed) about this

Feature Request

Enable advanced customization of the SSE (Server-Sent Events) Event struct by introducing the EventExt trait.

Motivation

In certain use cases, users may require additional customization options for the SSE Event struct in the Axum library. For instance, Vercel AI SDK doesn't follow the standard and only accepts raw text. So it is impossible to use Axum which always includes the key such as data, id, etc.

Proposal

The proposed solution involves introducing a trait, EventExt, with methods for customizing the SSE Event. Users can implement this trait to add their own logic and fields to the event. The trait includes methods for setting the data field and finalizing the event.

pub trait EventExt {
    fn data<T>(mut self, data: T) -> Self
    where
        T: AsRef<str>;

    fn finalize(self) -> Bytes;
}

Users can then implement this trait for the SSE Event struct at the application level to provide their own customizations.

impl EventExt for Event {
    fn data<T>(mut self, data: T) -> Self
    where
        T: AsRef<str>,
    {
        // Custom logic to handle data customization
        self.data = data.as_ref().to_string();
        self
    }

    fn finalize(self) -> Bytes {
        // Custom logic for finalizing the event
        // Convert the event to Bytes and return
        // ...
    }
}

fn handle_event() -> Sse<impl Stream<Item = Result<TextEvent, Infallible>>, TextEvent> {
  ...
   yield Ok(TextEvent::default().data(content));
  ...
}

This approach allows users to have fine-grained control over the SSE Event without modifying the core Axum library.

I also tried to implement in in this branch https://github.com/linrium/axum/tree/feat/support-custom-sse-event

Alternatives

[SabrinaJewson]

Given that users can quite easily implement SSE themselves, what would Axum actually be providing here? Given some user-supplied function that makes Bytes, it’s very easy to return that from a handler directly:

async fn custom_sse() -> Response {
    let mut response = Response::new(StreamBody::new(stream! {
        yield Ok(http_body::Frame::data(generate_your_bytes()));
    }));
    response.header.insert(header::CONTENT_TYPE, HeaderValue::from_static("text/event-stream"));
    response
}