[feat] provide SSE (ServerSentEvents) as alternative to websocket

[nimo23]

Describe the problem

Currently we need to use @tauriApps/plugin-websocket for unidirectional streaming (from server to client). However, there is another web standard specifically for such unidirectional streaming: Server Sent Events (SSE).

Describe the solution you'd like

Would be nice to also have @tauriApps/plugin-sse to support "server sent events".

Especially for mobile applications, SSE is a much more energy-saving alternative. Btw, in contrast to the use of the "web's native implementation", Tauri can even improve SSE communication by

• optionally bypassing a "push proxy" (https://stackoverflow.com/questions/46799463/server-sent-events-sse-connection-loss-on-mobile-phones)
• leaving SSE communication intact for the native application, use the native timer for SSE retry field (instead of the web timer)
• enabling GZIP compression of SSE message

Alternatives considered

No response

Additional context

No response

[lloydzhou]

here is stream_fetch command for tauri
rust code: stream.rs

mod stream;
fn main() {
  tauri::Builder::default()
    .invoke_handler(tauri::generate_handler![stream::stream_fetch])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");
}

js code: stream.ts

import { fetch as tauriStreamFetch } from "./stream"
import { fetchEventSource } from '@microsoft/fetch-event-source';

await fetchEventSource('/api/sse', {
    fetch: tauriStreamFetch,
    onmessage(ev) {
        console.log(ev.data);
    }
});

[jffaust]

I'm pretty new to Tauri so maybe I'm missing something but I was able to connect to a server emitting SSE with this JS in my frontend

      eventSource = new EventSource(`http://localhost:5000/stream`);

      eventSource.onmessage = function (event) {
        const item = JSON.parse(event.data);
        console.log("New item received!!!:", item);
      };

The server was either running on the side manually or embedding with the app as a sidecar. Maybe it would not work if the SSE were emitted directly by the Rust Tauri backend?

[AndrooFrowns]

@jffaust

My understanding of the OP is that they want to send SSE from the tauri rust backend. The frontend being a webview, it makes sense that they can get data from the stream since it is more or less just a fancy get request from the front end's point of view.

[amitnos123]

I'm starting to write a plugin for SSE.
In Typescript, I'm trying to do it similar to Monzila's implementation.

I'm working on it slowly. If someone wants to contribute, do feel free.

The generic idea is to tell Rust to send request to wait for server event.
On getting server event, send an event via Tauri's event system for frontend.

[AndrooFrowns]

@amitnos123 Would your approach work with systems that already use SSE, for example Datastar?

[amitnos123]

@AndrooFrowns
If you would like to contribute, this is the repository https://github.com/amitnos123/tauri-plugin-sse

I'm making a wrapper for crate sse_client

The Rust (Tauri's backend) will trigger event to tell the Tauri's frontend the SSE occoured.

Server -> Rust (Tauri's backend) -> Tauri's frontend

• Server -> Rust (Tauri's backend): SSE
• Rust (Tauri's backend) -> Tauri's frontend: Event

[amitnos123]

@AndrooFrowns Wanted to tell you
The plugin almost done.
There is a single bug I need to fix.
After that I know it works on Linux.