@lovrozagar/honey 0.1.0

package/src/client-go/realtime.go

@@ -0,0 +1,317 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"context"
+	"errors"
+	"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"
+}
+
+// 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() signals the
+// internal goroutine to stop and closes both channels.
+//
+// Mirrors TS createResumableConnection, Rust ResumableConnection::connect, and
+// Python ResumableConnection behavior.
+type ResumableConnection struct {
+	url        string
+	transports []Transport
+	opts       TransportOpts
+
+	events  chan any
+	errs    chan error
+	closeCh chan struct{}
+
+	mu        sync.Mutex
+	state     ConnectionState
+	conn      TransportConn
+	provenIdx int /* -1 = none yet */
+	closed    bool
+	closeOnce sync.Once
+}
+
+// NewResumableConnection constructs a connection with the given adapter chain.
+// Opts is copied; nil → zero-value 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
+	}
+	return &ResumableConnection{
+		url:        baseURL,
+		transports: transports,
+		opts:       o,
+		events:     make(chan any, 16),
+		errs:       make(chan error, 4),
+		closeCh:    make(chan struct{}),
+		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. Returns once the first
+// transport has succeeded. Full-chain failure returns the last transport error.
+// Idempotent when already connected.
+func (r *ResumableConnection) Connect(ctx context.Context) error {
+	r.mu.Lock()
+	if r.closed {
+		r.mu.Unlock()
+		return errors.New("honey: ResumableConnection closed")
+	}
+	if r.state == StateConnected {
+		r.mu.Unlock()
+		return nil
+	}
+	if r.conn != nil || r.provenIdx >= 0 {
+		r.state = StateReconnecting
+	} else {
+		r.state = StateConnecting
+	}
+	r.mu.Unlock()
+
+	if err := r.openChain(ctx); err != nil {
+		r.mu.Lock()
+		r.state = StateDisconnected
+		r.mu.Unlock()
+		return err
+	}
+	go r.readLoop()
+	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()
+
+	var lastErr error
+	if proven >= 0 && proven < len(r.transports) {
+		c, err := r.transports[proven].Connect(ctx, r.url, &r.opts)
+		if err == nil {
+			r.mu.Lock()
+			r.conn = c
+			r.state = StateConnected
+			r.mu.Unlock()
+			return nil
+		}
+		lastErr = err
+	}
+	for i, t := range r.transports {
+		if i == proven {
+			continue
+		}
+		c, err := t.Connect(ctx, r.url, &r.opts)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+		r.mu.Lock()
+		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
+}
+
+// readLoop pumps Recv → events channel. Transport errors trigger reconnect via
+// the full chain (proven is invalidated on failure) up to MaxReconnectAttempts;
+// exhaustion emits on errs and terminates. Close signal short-circuits via ctx.
+func (r *ResumableConnection) readLoop() {
+	defer func() {
+		r.mu.Lock()
+		r.state = StateDisconnected
+		if r.conn != nil {
+			_ = r.conn.Close()
+			r.conn = nil
+		}
+		r.mu.Unlock()
+		r.closeOnce.Do(func() {
+			close(r.events)
+			close(r.errs)
+		})
+	}()
+
+	attempts := 0
+	maxAttempts := r.opts.MaxReconnectAttempts
+	delay := time.Duration(r.opts.ReconnectDelayMs) * time.Millisecond
+
+	for {
+		select {
+		case <-r.closeCh:
+			return
+		default:
+		}
+
+		r.mu.Lock()
+		conn := r.conn
+		r.mu.Unlock()
+		if conn == nil {
+			return
+		}
+
+		recvCtx, cancel := context.WithCancel(context.Background())
+		cancelDone := make(chan struct{})
+		go func() {
+			select {
+			case <-r.closeCh:
+				cancel()
+			case <-cancelDone:
+			}
+		}()
+		v, err := conn.Recv(recvCtx)
+		cancel()
+		close(cancelDone)
+
+		if err == nil {
+			select {
+			case r.events <- v:
+				attempts = 0
+			case <-r.closeCh:
+				return
+			}
+			continue
+		}
+
+		/* transport died — attempt reconnect unless capped */
+		select {
+		case <-r.closeCh:
+			return
+		default:
+		}
+		attempts++
+		if maxAttempts > 0 && attempts > maxAttempts {
+			select {
+			case r.errs <- err:
+			default:
+			}
+			return
+		}
+		r.mu.Lock()
+		r.state = StateReconnecting
+		if r.conn != nil {
+			_ = r.conn.Close()
+			r.conn = nil
+		}
+		/* drop proven — prefer full chain on recv failure, matches Python */
+		r.provenIdx = -1
+		r.mu.Unlock()
+		if delay > 0 {
+			select {
+			case <-time.After(delay):
+			case <-r.closeCh:
+				return
+			}
+		}
+		reopenCtx, reopenCancel := context.WithCancel(context.Background())
+		reopenDone := make(chan struct{})
+		go func() {
+			select {
+			case <-r.closeCh:
+				reopenCancel()
+			case <-reopenDone:
+			}
+		}()
+		reopenErr := r.openChain(reopenCtx)
+		reopenCancel()
+		close(reopenDone)
+		if reopenErr != nil {
+			select {
+			case r.errs <- reopenErr:
+			default:
+			}
+			return
+		}
+	}
+}
+
+// Close signals the read goroutine to stop, closes the active transport, and
+// closes events / errs channels. Safe to call multiple times.
+func (r *ResumableConnection) Close() error {
+	r.mu.Lock()
+	if r.closed {
+		r.mu.Unlock()
+		return nil
+	}
+	r.closed = true
+	close(r.closeCh)
+	conn := r.conn
+	r.conn = nil
+	r.state = StateDisconnected
+	r.mu.Unlock()
+	if conn != nil {
+		_ = conn.Close()
+	}
+	/* when Connect was never called (or failed before spawning readLoop) the
+	 * defer in readLoop never runs; closeOnce guards against double-close from
+	 * both paths. */
+	r.closeOnce.Do(func() {
+		close(r.events)
+		close(r.errs)
+	})
+	return nil
+}

package/src/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
+}