model.corto

in corto.ws
use corto.httpserver

// Setup new connection (client -> server)
struct connect {
    session: string
    version: string
}

// Connection established (server -> client)
struct connected {
    session: string
}

// Connection failed (server -> client)
struct failed {
    version: string
}

// Subscribe for data (client -> server)
struct sub {
    id: string
    parent: string
    expr: string
    type: string
    offset: uint64
    limit: uint64
    summary: bool // Do not send content of collections, shorten strings
    yield_unknown: bool
}

// Confirm subscription (server -> client)
struct subok {
    id: string
}

// Failed to create subscription (server -> client)
struct subfail {
    id: string
    error: string
}

// Unsubscribe for data (client -> server)
struct unsub {
    id: string
}

// Data message (server -> client)
verbatim dataMembers: "text/json"

struct dataObject {
    id: string
    p: string, optional
    s: string, optional
    a: string, optional
    v: verbatim["text/json"], optional
}

struct dataType {
    type: string
    kind: string, optional
    reference: bool, optional
    members: dataMembers, optional
    constants: list[string], optional
    element_type: string, optional
    set: list[dataObject], optional
    del: list[dataObject], optional
}

struct data {
    sub: string
    data: list[dataType], not_null
}

// Delete message (client -> server)
struct delete {
    id: string
}

// Update message (client -> server)
struct update {
    id: string
    v: verbatim["text/json"], optional
}

// WS Server
container service: httpserver.Service, implements:[dispatcher] {
    events: map[null, subscriber_event], private|local // Event queue

    init() int16

    post(event e) void // Post event to event queue
    purge(subscriber sub) void // Purge events from queue for a subscriber
    flush(subscriber sub) void // Flush pending events for a subscriber

override
    on_poll() void // Read events from event queue
    on_message(HTTP.Connection c, string msg) void // Receive data
    on_close(HTTP.Connection c) void // Connection closed

    // Server sessions
    table Session {
        id: string, key // Session id

        // Private members
        conn: HTTP.Connection, private|local // HTTP connection
        typesAligned: list[type], private|local|not_null // Track types aligned for session

        send(object msg) void

        // Subscriptions for session
        table Subscription: subscriber {
            id: string, key // Subscription id
            summary: bool, readonly // Is client requesting summary data
            batch: list[event], private|local|not_null // Events to be handled in next batch

            construct() int16
            addEvent(event e) void
            processEvents() void
        }
    }
}