sse

    Server-Sent Events (SSE) support for MoonBit (JS client + Native server)

    Download zip
    Author
    Version
    0.3.1
    License
    Apache-2.0
    Last updated
    6 hours ago
    Downloads
    33

    Dependencies

    #sse.mbt

    Server-Sent Events (SSE) support for MoonBit/JS.

    This library provides a type-safe interface to the browser's EventSource API for receiving server-sent events in MoonBit applications targeting JavaScript.

    #Features

    • Type-safe SSE client implementation
    • Fluent API for event handler registration
    • Automatic reconnection with configurable retry logic
    • Connection state management
    • Event message parsing with optional ID tracking
    • Property-based testing coverage
    • Browser client built on the native EventSource API
    • Native-only server support uses moonbitlang/async/socket

    #Installation

    moon add f4ah6o/sse@0.3.1

    #Usage

    ///|
    import {
    "f4ah6o/sse/src/sse",
    }

    ///|
    fn main {
    let conn = @sse.connect("http://localhost:8080/events")

    conn
    |> @sse.on_message(fn(msg) { println("Received: \{msg.data}") })
    |> @sse.on_error(fn(err) { println("Error: \{err}") })
    |> @sse.on_open(fn(_state) { println("Connection opened") })

    // Close when done
    @sse.close(conn)
    }

    #Named Events

    import {
    "f4ah6o/sse/src/sse" @sse,
    }

    let conn = @sse.connect("http://localhost:8080/events")

    conn
    |> @sse.on("notification", fn(msg) {
    println("Notification: \{msg.data}")
    })
    |> @sse.on("update", fn(msg) {
    println("Update: \{msg.data}")
    })

    #Auto-Reconnection

    ///|
    import {
    "f4ah6o/sse/src/sse",
    }

    ///|
    let conn = @sse.connect("http://localhost:8080/events")
    |> @sse.setup_auto_reconnect
    |> @sse.on_message(fn(msg) { println("Received: \{msg.data}") })

    // Will automatically reconnect on connection loss
    // up to max_retries times with reconnect_interval delay

    #Custom Configuration

    import {
    "f4ah6o/sse" @root,
    "f4ah6o/sse/src/sse" @sse,
    }

    let config = {
    ...@root.default_connection_config("http://localhost:8080/events")
    with_credentials: true
    reconnect_interval: 5000
    max_retries: 5
    }

    let conn = @sse.connect_with_config(config)
    |> @sse.on_message(fn(msg) {
    println("Event: \{msg.event_name}, Data: \{msg.data}")
    })

    #Building & Testing

    # Check formatting and all supported targets moon fmt --check moon check --target all # Check each target-specific subpackage moon check src/sse --target js moon check src/server --target native # Run tests for all supported targets moon test --target all # Update snapshots after behavioral changes moon test --target all --update

    #License

    Apache-2.0

    ConnectionStateHandler

    type ConnectionStateHandler = (EventState) -> Unit

    Connection state handler type

    EventHandler

    type EventHandler = (SseMessage) -> Unit

    Event handler type for SSE events

    ConnectionConfig

    pub struct ConnectionConfig {
    url : String
    with_credentials : Bool
    reconnect_interval : Int
    max_retries : Int
    }

    Connection configuration for SSE

    EventState

    pub enum EventState {
    Connecting
    Open
    Closed
    Error
    } derive(
    Debug
    )

    SSE Event State enumeration
    impl Show for EventState

    EventState::output

    fn EventState::output(self : EventState, logger : &Logger) -> Unit

    EventState::to_string

    fn EventState::to_string(self : EventState) -> String

    SSEEvent

    pub(all) struct SSEEvent {
    data : String
    event : String?
    id : String?
    } derive(Eq,
    Debug
    )

    Server-side SSE event structure
    impl Show for SSEEvent

    SSEEvent::data_only

    fn SSEEvent::data_only(data : String) -> SSEEvent

    SSEEvent::equal

    fn SSEEvent::equal(SSEEvent, SSEEvent) -> Bool

    SSEEvent::new

    fn SSEEvent::new(data : String, event : String, id : String?) -> SSEEvent

    SSEEvent::not_equal

    fn SSEEvent::not_equal(x : SSEEvent, y : SSEEvent) -> Bool

    SSEEvent::output

    fn SSEEvent::output(self : SSEEvent, logger : &Logger) -> Unit

    SSEEvent::to_repr

    SSEEvent::to_string

    fn SSEEvent::to_string(self : SSEEvent) -> String

    SseMessage

    pub struct SseMessage {
    event_name : String
    data : String
    origin : String
    id : String?
    }

    SSE Message structure

    CLOSED

    let CLOSED : Int

    CONNECTING

    let CONNECTING : Int

    EventSource ready state constants

    OPEN

    let OPEN : Int

    default_connection_config

    fn default_connection_config(url : String) -> ConnectionConfig

    Default connection configuration

    format_event

    fn format_event(event : SSEEvent) -> String

    ready_state_to_event_state

    fn ready_state_to_event_state(state : Int) -> EventState

    Convert ready state to EventState

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io