Go SDK

go get github.com/NoLagApp/go-sdk

package main

import (
    "fmt"
    "time"

    nolag "github.com/NoLagApp/go-sdk"
)

func main() {
    client := nolag.New("dev-token-alice", nolag.Options{
        URL: "ws://localhost:8080/ws",
    })

    // Broker errors (no grant for a topic, and so on) are asynchronous:
    // register the handler before Connect
    client.OnError(func(err *nolag.ServerError) {
        fmt.Printf("nolag: %v\n", err)
    })

    if err := client.Connect(); err != nil {
        panic(err)
    }
    defer client.Close()

    // A room context prefixes topics with app/room, so this is demo/general/*
    room := client.SetApp("demo").SetRoom("general")

    err := room.Subscribe("messages", func(data any, meta nolag.MessageMeta) {
        fmt.Printf("Received: %v\n", data)
    })
    if err != nil {
        panic(err)
    }

    if err := room.Emit("messages", map[string]any{"hello": "world"}); err != nil {
        fmt.Printf("Emit failed: %v\n", err)
    }

    fmt.Println("Actor ID:", client.ActorID())
    time.Sleep(60 * time.Second)
}

options := nolag.Options{
    URL:                  "ws://localhost:8080/ws",             // Your kraken's WebSocket URL (always set this)
    Reconnect:            nolag.Bool(true),                     // Reconnect automatically (default: true)
    ReconnectInterval:    5 * time.Second,                      // Wait between attempts (default: 5s)
    MaxReconnectAttempts: 10,                                   // Default 10; 0 keeps the default, -1 is unlimited
    HeartbeatInterval:    30 * time.Second,                     // Default 30s; 0 keeps the default, -1 disables
    QoS:                  nolag.QoSLevel(nolag.QoSAtLeastOnce), // Default QoS (default: QoSAtLeastOnce)
    LoadBalance:          false,                                // Load-balance every subscription (default: false)
    LoadBalanceGroup:     "workers",                            // Group name (default: the actor's id)
    Debug:                true,                                 // Log protocol traffic (default: false)
}

client := nolag.New("dev-token-alice", options)

client := nolag.New("dev-token-alice", nolag.Options{URL: "ws://localhost:8080/ws"})
room := client.SetApp("demo").SetRoom("general")

client.On("connected", func(args ...any) {
    room.SetPresence(map[string]any{"username": "alice", "status": "online"})
})
client.On("disconnected", func(args ...any) {
    fmt.Println("Disconnected")
})
client.On("reconnecting", func(args ...any) {
    fmt.Printf("Reconnecting, attempt %d\n", args[0].(int))
})

if err := client.Connect(); err != nil {
    log.Fatal(err)
}

// Plain subscriptions are re-subscribed by the SDK after a reconnect
room.Subscribe("messages", func(data any, meta nolag.MessageMeta) {
    fmt.Println(data)
})

package main

import (
    "log"
    "sync/atomic"
    "time"

    nolag "github.com/NoLagApp/go-sdk"
)

func main() {
    client := nolag.New("dev-token-alice", nolag.Options{
        URL:       "ws://localhost:8080/ws",
        Reconnect: nolag.Bool(false), // reconnect below, so options are re-applied
    })
    room := client.SetApp("demo").SetRoom("general")

    subscribe := func() {
        err := room.Subscribe("messages", func(data any, meta nolag.MessageMeta) {
            log.Println("vip message:", data)
        }, nolag.SubscribeOptions{Filters: []any{"vip"}})
        if err != nil {
            log.Println("subscribe:", err)
        }
    }

    var closing, reconnecting atomic.Bool
    client.On("disconnected", func(args ...any) {
        if closing.Load() || !reconnecting.CompareAndSwap(false, true) {
            return
        }
        go func() {
            defer reconnecting.Store(false)
            for !closing.Load() {
                time.Sleep(5 * time.Second)
                if err := client.Connect(); err == nil {
                    subscribe()
                    return
                }
            }
        }()
    })

    if err := client.Connect(); err != nil {
        log.Fatal(err)
    }
    subscribe()

    // To stop for good: closing.Store(true), then client.Close()
    select {}
}

client := nolag.New("dev-token-alice", nolag.Options{URL: "ws://localhost:8080/ws"})
if err := client.Connect(); err != nil {
    log.Fatal(err)
}

room := client.SetApp("demo").SetRoom("general")
handler := func(data any, meta nolag.MessageMeta) {
    fmt.Printf("Message: %v (filter %q)\n", data, meta.Filter)
}

// Basic subscription
if err := room.Subscribe("messages", handler); err != nil {
    fmt.Printf("Subscribe failed: %v\n", err)
}

// With options (QoS, load balancing, filters)
err := room.Subscribe("messages", handler, nolag.SubscribeOptions{
    QoS:              nolag.QoSLevel(nolag.QoSAtLeastOnce),
    LoadBalance:      nolag.Bool(true),
    LoadBalanceGroup: "workers",
    Filters:          []any{"priority:high", "region:us"},
})
if err != nil {
    fmt.Printf("Subscribe failed: %v\n", err)
}

// Client-level equivalent: the full app/room/topic path
err = client.Subscribe("demo/general/messages", handler)

// Unsubscribe
if err := room.Unsubscribe("messages"); err != nil {
    fmt.Printf("Unsubscribe failed: %v\n", err)
}

client := nolag.New("dev-token-alice", nolag.Options{URL: "ws://localhost:8080/ws"})
if err := client.Connect(); err != nil {
    log.Fatal(err)
}

room := client.SetApp("demo").SetRoom("general")

// Publish any MessagePack-encodable data (maps, structs, strings, numbers)
if err := room.Emit("messages", map[string]any{"text": "Hello!"}); err != nil {
    fmt.Printf("Emit failed: %v\n", err)
}

// With options
err := room.Emit("messages", map[string]any{"online": true}, nolag.EmitOptions{
    QoS:    nolag.QoSLevel(nolag.QoSAtLeastOnce), // Override the default QoS
    Retain: true,                                 // Keep the last message for later subscribers
    Filter: "priority:high",                      // Route to subscribers filtering on this value
    Echo:   nolag.Bool(false),                    // Do not deliver this message back to this connection
})
if err != nil {
    fmt.Printf("Emit failed: %v\n", err)
}

// Client-level equivalent: the full path
err = client.Emit("demo/general/messages", map[string]any{"text": "Hello!"})

client := nolag.New("dev-token-alice", nolag.Options{URL: "ws://localhost:8080/ws"})
if err := client.Connect(); err != nil {
    log.Fatal(err)
}

room := client.SetApp("demo").SetRoom("general")
handler := func(data any, meta nolag.MessageMeta) {
    fmt.Printf("Order (filter %s): %v\n", meta.Filter, data)
}

// Subscribe with initial filters: strings are OR, []string items are AND groups
err := room.Subscribe("messages", handler, nolag.SubscribeOptions{
    Filters: []any{"region:us", "status:pending"},
})

// Replace all filters (an empty slice receives everything again)
err = room.SetFilters("messages", []any{"region:eu", "status:shipped"})

// Add to or remove from the current set
err = room.AddFilters("messages", []string{"status:delivered"})
err = room.RemoveFilters("messages", []string{"status:shipped"})

// Publish with a filter value
err = room.Emit("messages", map[string]any{"id": 42}, nolag.EmitOptions{
    Filter: "region:us",
})
if err != nil {
    fmt.Println(err)
}

client := nolag.New("dev-token-alice", nolag.Options{URL: "ws://localhost:8080/ws"})

// Inside every successful Connect, including automatic reconnects
client.On("connected", func(args ...any) {
    fmt.Println("Connected")
})

client.On("disconnected", func(args ...any) {
    fmt.Println("Disconnected")
})

// args[0] is the attempt number
client.On("reconnecting", func(args ...any) {
    fmt.Printf("Reconnecting, attempt %d\n", args[0].(int))
})

// Broker errors, typed (see Error handling)
client.OnError(func(err *nolag.ServerError) {
    fmt.Printf("Error: %v\n", err)
})

// The app's hydration webhook response, once per subscribe.
// args[0] is the bare topic name, for example "messages"; args[1] is the data
client.On("hydration", func(args ...any) {
    topic := args[0].(string)
    fmt.Printf("Initial state for %s: %v\n", topic, args[1])
})

// Remove every handler for an event
client.Off("hydration")

if err := client.Connect(); err != nil {
    log.Fatal(err)
}

if client.Status() == nolag.StatusConnected {
    fmt.Println("Connected as", client.ActorID(), "protocol", client.ProtocolVersion())
}

client := nolag.New("dev-token-alice", nolag.Options{URL: "ws://localhost:8080/ws"})

// Presence events are client-level: args[0] is a nolag.ActorPresence
client.On("presence:join", func(args ...any) {
    actor := args[0].(nolag.ActorPresence)
    fmt.Printf("%s joined with %v\n", actor.ActorTokenID, actor.Presence)
})
client.On("presence:update", func(args ...any) {
    actor := args[0].(nolag.ActorPresence)
    fmt.Printf("%s updated: %v\n", actor.ActorTokenID, actor.Presence)
})
client.On("presence:leave", func(args ...any) {
    actor := args[0].(nolag.ActorPresence)
    fmt.Printf("%s left\n", actor.ActorTokenID)
})

if err := client.Connect(); err != nil {
    log.Fatal(err)
}

room := client.SetApp("demo").SetRoom("general")

// Set presence in the room
if err := room.SetPresence(map[string]any{"status": "online"}); err != nil {
    fmt.Printf("SetPresence failed: %v\n", err)
}

// Or name the room slug explicitly
if err := client.SetPresence(map[string]any{"status": "online"}, "general"); err != nil {
    fmt.Printf("SetPresence failed: %v\n", err)
}

// The room's list from kraken, by room slug
present, err := client.GetPresence("general")
if err == nil {
    for _, actor := range present {
        fmt.Printf("%s: %v\n", actor.ActorTokenID, actor.Presence)
    }
}

client := nolag.New("dev-token-alice", nolag.Options{URL: "ws://localhost:8080/ws"})
if err := client.Connect(); err != nil {
    log.Fatal(err)
}

// The actor needs a grant for the lobby (see Lobbies)
lobby := client.SetApp("demo").SetLobby("online")

// A snapshot keyed by room slug, then actor id
snapshot, err := lobby.Subscribe()
if err != nil {
    log.Fatal(err)
}
fmt.Println("Rooms:", len(snapshot))

lobby.On("presence:join", func(event nolag.LobbyPresenceEvent) {
    fmt.Printf("%s joined %s: %v\n", event.ActorID, event.RoomID, event.Data)
})
lobby.On("presence:leave", func(event nolag.LobbyPresenceEvent) {
    fmt.Printf("%s left %s\n", event.ActorID, event.RoomID)
})

latest, _ := lobby.FetchPresence()
fmt.Println(len(latest))
lobby.Unsubscribe()

client := nolag.New("dev-token-alice", nolag.Options{URL: "ws://localhost:8080/ws"})

client.OnError(func(err *nolag.ServerError) {
    // err also satisfies the error interface
    log.Printf("nolag: %v", err)

    switch err.Name {
    case "unknown_topic":
        log.Printf("no grant covers %s", err.Topic)
    case "rate_limit_exceeded", "message_too_large":
        log.Printf("publish refused on %s", err.Topic)
    }
})

if err := client.Connect(); err != nil {
    // errors.Is(err, nolag.ErrAuthFailed) when kraken refused the token
    log.Fatal(err)
}

processTask := func(data any, meta nolag.MessageMeta) {
    fmt.Printf("Processing: %v\n", data)
}

// For every subscription on this client. Connection-level settings
// also survive automatic reconnects
worker := nolag.New("dev-token-alice", nolag.Options{
    URL:              "ws://localhost:8080/ws",
    LoadBalance:      true,
    LoadBalanceGroup: "task-workers",
})
if err := worker.Connect(); err != nil {
    log.Fatal(err)
}
worker.SetApp("demo").SetRoom("general").Subscribe("messages", processTask)

// Or per subscription
client := nolag.New("dev-token-bob", nolag.Options{URL: "ws://localhost:8080/ws"})
if err := client.Connect(); err != nil {
    log.Fatal(err)
}
err := client.SetApp("demo").SetRoom("general").Subscribe("messages", processTask, nolag.SubscribeOptions{
    LoadBalance:      nolag.Bool(true),
    LoadBalanceGroup: "task-workers",
})
if err != nil {
    fmt.Printf("Subscribe failed: %v\n", err)
}