@lovrozagar/honey 0.7.3 → 1.0.0-rc.1

package/src/client-go/realtime.go

@@ -1,354 +0,0 @@
-// 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/src/client-go/result.go

@@ -1,20 +0,0 @@
-// 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
-}