@lovrozagar/honey 0.6.5 → 0.7.0

package/dist/client-go/realtime.go

@@ -0,0 +1,354 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"context"
+	"errors"
+	"math/rand/v2"
+	"sync"
+	"time"
+)
+
+// ConnectionState mirrors the TS / Rust / Python realtime lifecycle.
+type ConnectionState int
+
+// Connection lifecycle states. Order matches TS createResumableConnection:
+// Connecting → Connected → Reconnecting → Disconnected.
+const (
+	StateConnecting ConnectionState = iota
+	StateConnected
+	StateReconnecting
+	StateDisconnected
+)
+
+// String returns the lowercase canonical name used by cross-language parity tests.
+func (s ConnectionState) String() string {
+	switch s {
+	case StateConnecting:
+		return "connecting"
+	case StateConnected:
+		return "connected"
+	case StateReconnecting:
+		return "reconnecting"
+	case StateDisconnected:
+		return "disconnected"
+	}
+	return "unknown"
+}
+
+const (
+	defaultReconnectAttempts = 5
+	defaultReconnectDelay    = time.Second
+	maxReconnectDelay        = 30 * time.Second
+	openTimeout              = 30 * time.Second
+)
+
+// ErrConnectionClosed is returned by Connect after Close.
+var ErrConnectionClosed = errors.New("honey: ResumableConnection closed")
+
+// ResumableConnection orchestrates a pluggable Transport chain with
+// proven-transport memoization + full-chain fallback. Events are delivered over
+// Events(); terminal errors are delivered over Errors(). Close() stops the
+// read goroutine and then closes both channels.
+//
+// Reconnects back off exponentially from ReconnectDelayMs (default 1s, capped
+// at 30s, with jitter) for up to MaxReconnectAttempts (default 5; negative
+// means unlimited). Exhaustion is reported on Errors().
+type ResumableConnection struct {
+	url        string
+	transports []Transport
+	opts       TransportOpts
+
+	events chan any
+	errs   chan error
+	/* ctx is canceled by Close; every wait in the read loop selects on it */
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	mu        sync.Mutex
+	state     ConnectionState
+	conn      TransportConn
+	provenIdx int /* -1 = none yet */
+	closed    bool
+	running   bool
+	loopDone  chan struct{}
+}
+
+// NewResumableConnection constructs a connection with the given adapter chain.
+// Opts is copied; nil → defaults. Panics if transports is empty —
+// misconfiguration at construction is a programmer error, not runtime.
+func NewResumableConnection(baseURL string, transports []Transport, opts *TransportOpts) *ResumableConnection {
+	if len(transports) == 0 {
+		panic("honey: NewResumableConnection requires at least one transport")
+	}
+	var o TransportOpts
+	if opts != nil {
+		o = *opts
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	return &ResumableConnection{
+		url:        baseURL,
+		transports: transports,
+		opts:       o,
+		events:     make(chan any, 16),
+		errs:       make(chan error, 4),
+		ctx:        ctx,
+		cancel:     cancel,
+		state:      StateDisconnected,
+		provenIdx:  -1,
+	}
+}
+
+// Events returns a receive-only channel of decoded payloads.
+func (r *ResumableConnection) Events() <-chan any { return r.events }
+
+// Errors returns a receive-only channel of terminal transport errors.
+func (r *ResumableConnection) Errors() <-chan error { return r.errs }
+
+// State reports the current lifecycle state.
+func (r *ResumableConnection) State() ConnectionState {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	return r.state
+}
+
+// ProvenTransport reports the kind of the last successfully-opened transport,
+// if any. Returns (zero, false) when no transport has succeeded yet.
+func (r *ResumableConnection) ProvenTransport() (TransportKind, bool) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if r.provenIdx < 0 || r.provenIdx >= len(r.transports) {
+		return "", false
+	}
+	return r.transports[r.provenIdx].Kind(), true
+}
+
+// Connect opens the chain and spawns the read goroutine. ctx bounds the open
+// only; the stream lives until Close. Returns once a transport has succeeded,
+// or the last transport error. A no-op while already connected or connecting;
+// after the read goroutine gave up, Connect starts over.
+func (r *ResumableConnection) Connect(ctx context.Context) error {
+	r.mu.Lock()
+	if r.closed {
+		r.mu.Unlock()
+		return ErrConnectionClosed
+	}
+	if r.running {
+		r.mu.Unlock()
+		return nil
+	}
+	r.running = true
+	if r.provenIdx >= 0 {
+		r.state = StateReconnecting
+	} else {
+		r.state = StateConnecting
+	}
+	r.mu.Unlock()
+
+	if err := r.openChain(ctx); err != nil {
+		r.mu.Lock()
+		r.running = false
+		r.state = StateDisconnected
+		r.mu.Unlock()
+		return err
+	}
+	done := make(chan struct{})
+	r.mu.Lock()
+	r.loopDone = done
+	r.mu.Unlock()
+	go r.readLoop(done)
+	return nil
+}
+
+// openChain tries the proven adapter first (if memoized), then walks the full
+// chain in order. First success wins; on success, provenIdx is updated.
+func (r *ResumableConnection) openChain(ctx context.Context) error {
+	r.mu.Lock()
+	proven := r.provenIdx
+	r.mu.Unlock()
+
+	order := make([]int, 0, len(r.transports))
+	if proven >= 0 && proven < len(r.transports) {
+		order = append(order, proven)
+	}
+	for i := range r.transports {
+		if i != proven {
+			order = append(order, i)
+		}
+	}
+
+	var lastErr error
+	for _, i := range order {
+		c, err := r.transports[i].Connect(ctx, r.url, &r.opts)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+		r.mu.Lock()
+		if r.closed {
+			r.mu.Unlock()
+			_ = c.Close()
+			return ErrConnectionClosed
+		}
+		r.conn = c
+		r.provenIdx = i
+		r.state = StateConnected
+		r.mu.Unlock()
+		return nil
+	}
+	if lastErr == nil {
+		lastErr = errors.New("honey: no transports configured")
+	}
+	return lastErr
+}
+
+func (r *ResumableConnection) maxAttempts() int {
+	switch {
+	case r.opts.MaxReconnectAttempts < 0:
+		return -1
+	case r.opts.MaxReconnectAttempts == 0:
+		return defaultReconnectAttempts
+	}
+	return r.opts.MaxReconnectAttempts
+}
+
+// backoff returns the delay before reconnect attempt n (1-based): exponential
+// from the base delay, capped, with jitter so clients do not reconnect in lockstep.
+func (r *ResumableConnection) backoff(n int) time.Duration {
+	base := defaultReconnectDelay
+	if r.opts.ReconnectDelayMs > 0 {
+		base = time.Duration(r.opts.ReconnectDelayMs) * time.Millisecond
+	}
+	d := base
+	for i := 1; i < n && d < maxReconnectDelay; i++ {
+		d *= 2
+	}
+	if d > maxReconnectDelay {
+		d = maxReconnectDelay
+	}
+	half := d / 2
+	return half + time.Duration(rand.Int64N(int64(half)+1))
+}
+
+func (r *ResumableConnection) fail(err error) {
+	select {
+	case r.errs <- err:
+	default:
+	}
+}
+
+// readLoop pumps Recv → events channel. Transport errors trigger reconnect via
+// the full chain (proven is invalidated on failure) with backoff; exhaustion
+// emits on errs and terminates. Close short-circuits every wait.
+func (r *ResumableConnection) readLoop(done chan struct{}) {
+	defer func() {
+		r.mu.Lock()
+		conn := r.conn
+		r.conn = nil
+		r.running = false
+		r.state = StateDisconnected
+		r.mu.Unlock()
+		if conn != nil {
+			_ = conn.Close()
+		}
+		close(done)
+	}()
+
+	attempts := 0
+	limit := r.maxAttempts()
+
+	for {
+		r.mu.Lock()
+		conn := r.conn
+		r.mu.Unlock()
+		if conn == nil {
+			return
+		}
+
+		v, err := conn.Recv(r.ctx)
+
+		if err == nil {
+			attempts = 0
+			select {
+			case r.events <- v:
+			case <-r.ctx.Done():
+				return
+			}
+			continue
+		}
+
+		if r.ctx.Err() != nil {
+			return
+		}
+
+		r.mu.Lock()
+		r.state = StateReconnecting
+		r.conn = nil
+		/* drop proven — prefer full chain on recv failure, matches Python */
+		r.provenIdx = -1
+		r.mu.Unlock()
+		_ = conn.Close()
+
+		for {
+			attempts++
+			if limit >= 0 && attempts > limit {
+				r.fail(err)
+				return
+			}
+			select {
+			case <-time.After(r.backoff(attempts)):
+			case <-r.ctx.Done():
+				return
+			}
+			openCtx, openCancel := context.WithTimeout(r.ctx, openTimeout)
+			err = r.openChain(openCtx)
+			openCancel()
+			if err == nil {
+				break
+			}
+			if errors.Is(err, ErrConnectionClosed) {
+				return
+			}
+		}
+	}
+}
+
+// Close stops the read goroutine, closes the active transport, then closes the
+// Events and Errors channels. Safe to call multiple times and concurrently with
+// Recv; Connect after Close returns ErrConnectionClosed.
+func (r *ResumableConnection) Close() error {
+	r.mu.Lock()
+	if r.closed {
+		r.mu.Unlock()
+		return nil
+	}
+	r.closed = true
+	r.cancel()
+	conn := r.conn
+	r.conn = nil
+	r.state = StateDisconnected
+	done := r.loopDone
+	r.mu.Unlock()
+	if conn != nil {
+		_ = conn.Close()
+	}
+	if done != nil {
+		<-done
+	}
+	close(r.events)
+	close(r.errs)
+	return nil
+}
+
+// Send writes data on the active transport. SSE and long-poll transports are
+// receive-only and return an error.
+func (r *ResumableConnection) Send(ctx context.Context, data any) error {
+	r.mu.Lock()
+	conn := r.conn
+	r.mu.Unlock()
+	if conn == nil {
+		return errors.New("honey: ResumableConnection not connected")
+	}
+	return conn.Send(ctx, data)
+}

package/dist/client-go/result.go

@@ -0,0 +1,20 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import "net/http"
+
+// SDKResult is a generic result container for safe-mode SDK calls (ThrowOnError=false).
+// In safe mode, methods return SDKResult[T] instead of (*T, error).
+// The error is embedded in the result — the outer error return is always nil in safe mode.
+type SDKResult[T any] struct {
+	Data *T
+	Err APIError
+	Status int
+	Response *http.Response
+}
+
+// OK returns true when the result carries no error.
+func (r SDKResult[T]) OK() bool {
+	return r.Err == nil
+}