It would be nice if one could open multiple SSE streams by using a path extractor in the SSE handler for each event type. So the diffing of the payload is more efficient.

like this:

pub async fn handle_sse(
    Path(event): Path<Cow<'static, str>>,
) -> Sse<impl Stream<Item = Result<Event, axum::BoxError>>> {
    let state = BACKEND_STATE.read();
    let stream = ServerSentEvents::new(
        event,
        BroadcastStream::new(state.sse_rx.resubscribe()).map_err(|e| e.into()),
    )
    .unwrap();
    Sse::new(stream).keep_alive(KeepAlive::default())
}

Each component could provide it's own stream in it's context. Unfortunately here only the existence of the ServerSignalEventSource type is checked in the context and creation of a new stream is skipped if it already exists.

Would be cool if we also compare the URL and create a new stream in the context, if the URL is different.

Hey, an my app I want to use one SSE endpoint to send different signals to my GUI. I use a serializable enum as event-payload.

#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq)]
pub enum SseSignal {
    #[default]
    Nop,
    UpdateImage(String),
    AcquisitionProgress {
        sequence: (usize, usize),
        frame: (usize, usize),
    },
}

But when I send different enum values through the same stream, I get a panic from here with the error PatchError.

My assumption is, that this error happens if json_patch tries to patch totally unrelated data. Can we maybe handle the error case and return the new data instead of patching the old?

EDIT: My assumption seems to be true, if I wrap my enum in a struct, it works.

EDIT2: After some investigation, it seems as if the patch fails, because the value of doc is still SseSignal::Nop (the default value) but the patch that should be applied is:

Patch([
  Add(AddOperation { path: "/AcquisitionProgress", value: Object {"frame": Array [Number(1), Number(100)], "sequence": Array [Number(0), Number(2)]} }), 
  Remove(RemoveOperation { path: "/UpdateImage" })
])

So it seems to be a synchronisation error between the two signals.