@lovrozagar/honey 0.6.5 → 0.7.0

package/dist/client-go/sse.go

@@ -0,0 +1,159 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"io"
+	"iter"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+// SSEEvent represents a single server-sent event. ID is the last event ID seen
+// on the stream so far (the spec's sticky "last event ID buffer").
+type SSEEvent struct {
+	Data  string
+	Event string
+	ID    string
+	Retry int
+}
+
+// sseMaxLine caps one line, and sseMaxEvent the data of one event.
+const (
+	sseMaxLine  = 1024 * 1024
+	sseMaxEvent = 8 * 1024 * 1024
+)
+
+// ErrSSELineTooLong is returned when a single SSE line exceeds the cap.
+var ErrSSELineTooLong = errors.New("honey: sse line exceeds 1 MiB")
+
+// parseSSEStream returns an iter.Seq2 that yields SSEEvent values read from resp.Body.
+// On non-2xx response it yields a typed error immediately then terminates.
+// The response body is closed when the iterator returns.
+func parseSSEStream(ctx context.Context, resp *http.Response) iter.Seq2[SSEEvent, error] {
+	return func(yield func(SSEEvent, error) bool) {
+		defer resp.Body.Close()
+
+		if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+			body, _ := readBody(resp.Body, 64<<10)
+			yield(SSEEvent{}, raiseForStatus(resp, body))
+			return
+		}
+
+		for ev, err := range parseSSE(resp.Body) {
+			if ctx.Err() != nil {
+				return
+			}
+			if !yield(ev, err) || err != nil {
+				return
+			}
+		}
+	}
+}
+
+// parseSSE implements the WHATWG event-stream parser: lines end in CRLF, LF or
+// CR; a blank line dispatches; a final event without its blank line is
+// discarded; the id is sticky across events; retry needs only ASCII digits.
+func parseSSE(r io.Reader) iter.Seq2[SSEEvent, error] {
+	return func(yield func(SSEEvent, error) bool) {
+		br := bufio.NewReaderSize(r, 64*1024)
+		var (
+			data      strings.Builder
+			hasData   bool
+			event     string
+			lastID    string
+			retry     int
+			firstLine = true
+		)
+		for {
+			line, err := readSSELine(br)
+			if err != nil {
+				if !errors.Is(err, io.EOF) {
+					yield(SSEEvent{}, err)
+				}
+				return
+			}
+			if firstLine {
+				line = strings.TrimPrefix(line, string(rune(0xFEFF)))
+				firstLine = false
+			}
+			if line == "" {
+				if hasData {
+					ev := SSEEvent{Data: data.String(), Event: event, ID: lastID, Retry: retry}
+					if !yield(ev, nil) {
+						return
+					}
+				}
+				data.Reset()
+				hasData = false
+				event = ""
+				retry = 0
+				continue
+			}
+			if strings.HasPrefix(line, ":") {
+				continue
+			}
+			field, value := line, ""
+			if i := strings.IndexByte(line, ':'); i >= 0 {
+				field, value = line[:i], strings.TrimPrefix(line[i+1:], " ")
+			}
+			switch field {
+			case "data":
+				if hasData {
+					data.WriteByte('\n')
+				}
+				if data.Len()+len(value) > sseMaxEvent {
+					yield(SSEEvent{}, errors.New("honey: sse event exceeds 8 MiB"))
+					return
+				}
+				data.WriteString(value)
+				hasData = true
+			case "event":
+				event = value
+			case "id":
+				if !strings.ContainsRune(value, 0) {
+					lastID = value
+				}
+			case "retry":
+				if value != "" && strings.Trim(value, "0123456789") == "" {
+					if n, convErr := strconv.Atoi(value); convErr == nil {
+						retry = n
+					}
+				}
+			}
+		}
+	}
+}
+
+// readSSELine reads one line without its terminator. A CR may be followed by
+// an LF that belongs to the same terminator. io.EOF is returned only when no
+// complete line remains, so a truncated final line is never parsed.
+func readSSELine(br *bufio.Reader) (string, error) {
+	var b strings.Builder
+	for {
+		c, err := br.ReadByte()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				return "", io.EOF
+			}
+			return "", err
+		}
+		switch c {
+		case '\n':
+			return b.String(), nil
+		case '\r':
+			if next, peekErr := br.Peek(1); peekErr == nil && next[0] == '\n' {
+				_, _ = br.ReadByte()
+			}
+			return b.String(), nil
+		}
+		if b.Len() >= sseMaxLine {
+			return "", ErrSSELineTooLong
+		}
+		b.WriteByte(c)
+	}
+}

package/dist/client-go/transport.go

@@ -0,0 +1,495 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"nhooyr.io/websocket"
+)
+
+// TransportKind tags which transport a connection was opened with.
+// Mirrors Rust TransportKind / Python TransportKind.
+type TransportKind string
+
+const (
+	TransportWs       TransportKind = "ws"
+	TransportSse      TransportKind = "sse"
+	TransportLongpoll TransportKind = "longpoll"
+)
+
+// TransportOpts is handed to each Transport.Connect call. Mirrors the TS
+// TransportOpts plus per-language extras (HTTPClient for SSE/longpoll dial).
+//
+// MaxMessageBytes caps one inbound WebSocket message (zero means 16 MiB).
+// PollTimeout bounds one long-poll request (zero means 60s).
+type TransportOpts struct {
+	ReconnectToken       string
+	LastEventID          string
+	Headers              http.Header
+	MaxReconnectAttempts int
+	ReconnectDelayMs     int
+	Protocols            []string
+	HTTPClient           *http.Client
+	MaxMessageBytes      int64
+	PollTimeout          time.Duration
+}
+
+const (
+	defaultMaxMessageBytes = 16 << 20
+	defaultPollTimeout     = 60 * time.Second
+)
+
+func (o *TransportOpts) maxMessageBytes() int64 {
+	if o == nil || o.MaxMessageBytes <= 0 {
+		return defaultMaxMessageBytes
+	}
+	return o.MaxMessageBytes
+}
+
+// TransportConn is the live per-transport connection object. Each built-in
+// adapter returns its own impl (wsConn, sseConn, longpollConn). Recv returns
+// decoded JSON (map[string]any, []any, string, number, bool) or raw string
+// fallback when the payload is not JSON.
+type TransportConn interface {
+	Recv(ctx context.Context) (any, error)
+	Send(ctx context.Context, data any) error
+	Close() error
+	Kind() TransportKind
+}
+
+// Transport is the pluggable adapter interface. Consumers swap in their own
+// WS/SSE/longpoll impls by implementing this. Mirrors Rust trait Transport
+// and Python TransportAdapter Protocol.
+type Transport interface {
+	Name() string
+	Kind() TransportKind
+	Connect(ctx context.Context, url string, opts *TransportOpts) (TransportConn, error)
+}
+
+/* errTransportNotImplemented remains as a transitional sentinel from the 8.b.3
+ * stub phase. Real Connect bodies below no longer return it; kept to avoid
+ * breaking any consumer that wrote defensive errors.Is checks. Removal deferred
+ * to 8.d cleanup. */
+var errTransportNotImplemented = errors.New("honey: transport adapter Connect not implemented")
+
+/* ───────────────────────── WebSocket adapter ───────────────────────── */
+
+// WsTransport is the default WebSocket adapter. Wraps nhooyr.io/websocket.
+type WsTransport struct {
+	Subprotocols []string
+}
+
+// Name returns "ws".
+func (t *WsTransport) Name() string { return "ws" }
+
+// Kind returns TransportWs.
+func (t *WsTransport) Kind() TransportKind { return TransportWs }
+
+// Connect dials the WebSocket endpoint. Auth + resume tokens ride as query
+// params on the URL; protocols + headers come from opts. Returned conn is a
+// *wsConn satisfying TransportConn.
+func (t *WsTransport) Connect(ctx context.Context, rawURL string, opts *TransportOpts) (TransportConn, error) {
+	wsURL := toWsURL(rawURL)
+	if opts != nil {
+		q := url.Values{}
+		if opts.ReconnectToken != "" {
+			q.Set("reconnect_token", opts.ReconnectToken)
+		}
+		if opts.LastEventID != "" {
+			q.Set("last_event_id", opts.LastEventID)
+		}
+		if len(q) > 0 {
+			sep := "?"
+			if strings.Contains(wsURL, "?") {
+				sep = "&"
+			}
+			wsURL = wsURL + sep + q.Encode()
+		}
+	}
+	dialOpts := &websocket.DialOptions{}
+	if opts != nil {
+		if len(opts.Protocols) > 0 {
+			dialOpts.Subprotocols = opts.Protocols
+		}
+		if len(opts.Headers) > 0 {
+			dialOpts.HTTPHeader = opts.Headers.Clone()
+		}
+		dialOpts.HTTPClient = opts.HTTPClient
+	}
+	if dialOpts.Subprotocols == nil && len(t.Subprotocols) > 0 {
+		dialOpts.Subprotocols = t.Subprotocols
+	}
+	conn, _, err := websocket.Dial(ctx, wsURL, dialOpts)
+	if err != nil {
+		return nil, err
+	}
+	conn.SetReadLimit(opts.maxMessageBytes())
+	return &wsConn{conn: conn}, nil
+}
+
+type wsConn struct {
+	conn *websocket.Conn
+}
+
+func (c *wsConn) Kind() TransportKind { return TransportWs }
+
+func (c *wsConn) Recv(ctx context.Context) (any, error) {
+	_, data, err := c.conn.Read(ctx)
+	if err != nil {
+		return nil, err
+	}
+	var v any
+	if jsonErr := json.Unmarshal(data, &v); jsonErr != nil {
+		/* non-JSON payload — fall through to raw string (matches Python decode). */
+		return string(data), nil
+	}
+	return v, nil
+}
+
+func (c *wsConn) Send(ctx context.Context, data any) error {
+	switch v := data.(type) {
+	case []byte:
+		return c.conn.Write(ctx, websocket.MessageBinary, v)
+	case string:
+		return c.conn.Write(ctx, websocket.MessageText, []byte(v))
+	default:
+		encoded, err := json.Marshal(v)
+		if err != nil {
+			return err
+		}
+		return c.conn.Write(ctx, websocket.MessageText, encoded)
+	}
+}
+
+func (c *wsConn) Close() error {
+	return c.conn.Close(websocket.StatusNormalClosure, "client close")
+}
+
+// toWsURL swaps the scheme only; a URL inside the query string is untouched.
+func toWsURL(u string) string {
+	if strings.HasPrefix(u, "https://") {
+		return "wss://" + u[len("https://"):]
+	}
+	if strings.HasPrefix(u, "http://") {
+		return "ws://" + u[len("http://"):]
+	}
+	return u
+}
+
+/* ────────────────────────────── SSE adapter ────────────────────────────── */
+
+// SseTransport is the default SSE adapter. Uses net/http streaming GET via
+// parseSSEStream. A background goroutine bridges the iterator to a Recv channel
+// so ResumableConnection.Recv has uniform blocking semantics across transports.
+type SseTransport struct {
+	HTTPClient *http.Client
+}
+
+// Name returns "sse".
+func (t *SseTransport) Name() string { return "sse" }
+
+// Kind returns TransportSse.
+func (t *SseTransport) Kind() TransportKind { return TransportSse }
+
+// Connect opens the SSE byte stream. Reconnect token rides as a query param;
+// Last-Event-ID rides as a request header (HTML spec).
+func (t *SseTransport) Connect(ctx context.Context, rawURL string, opts *TransportOpts) (TransportConn, error) {
+	client := t.HTTPClient
+	if opts != nil && opts.HTTPClient != nil {
+		client = opts.HTTPClient
+	}
+	if client == nil {
+		client = http.DefaultClient
+	}
+
+	u := rawURL
+	if opts != nil && opts.ReconnectToken != "" {
+		sep := "?"
+		if strings.Contains(u, "?") {
+			sep = "&"
+		}
+		u = u + sep + "reconnect_token=" + url.QueryEscape(opts.ReconnectToken)
+	}
+	/* ctx bounds the open only; the stream lives until Close cancels streamCtx */
+	streamCtx, cancel := context.WithCancel(context.Background())
+	stop := context.AfterFunc(ctx, cancel)
+	req, err := http.NewRequestWithContext(streamCtx, "GET", u, nil)
+	if err != nil {
+		stop()
+		cancel()
+		return nil, err
+	}
+	req.Header.Set("Accept", "text/event-stream")
+	if opts != nil {
+		for k, vv := range opts.Headers {
+			for _, v := range vv {
+				req.Header.Add(k, v)
+			}
+		}
+		if opts.LastEventID != "" {
+			req.Header.Set("Last-Event-ID", opts.LastEventID)
+		}
+	}
+	if req.Header.Get("X-Request-Id") == "" {
+		req.Header.Set("X-Request-Id", newUUIDv4())
+	}
+	resp, err := client.Do(req)
+	opened := stop()
+	if err != nil {
+		cancel()
+		return nil, err
+	}
+	if !opened {
+		/* ctx ended while the headers arrived */
+		_ = resp.Body.Close()
+		cancel()
+		return nil, ctx.Err()
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		_ = resp.Body.Close()
+		cancel()
+		return nil, fmt.Errorf("honey: sse transport: status %d", resp.StatusCode)
+	}
+	if ct := resp.Header.Get("Content-Type"); !strings.HasPrefix(strings.ToLower(ct), "text/event-stream") {
+		_ = resp.Body.Close()
+		cancel()
+		return nil, fmt.Errorf("honey: sse transport: unexpected content type %q", ct)
+	}
+	sc := &sseConn{
+		resp:   resp,
+		next:   make(chan sseResult, 1),
+		done:   make(chan struct{}),
+		cancel: cancel,
+	}
+	go sc.run(streamCtx)
+	return sc, nil
+}
+
+type sseResult struct {
+	value any
+	err   error
+}
+
+type sseConn struct {
+	resp   *http.Response
+	next   chan sseResult
+	done   chan struct{}
+	cancel context.CancelFunc
+	mu     sync.Mutex
+	closed bool
+	once   sync.Once
+}
+
+func (c *sseConn) Kind() TransportKind { return TransportSse }
+
+func (c *sseConn) run(ctx context.Context) {
+	defer c.finish()
+	for ev, err := range parseSSEStream(ctx, c.resp) {
+		select {
+		case <-c.done:
+			return
+		default:
+		}
+		if err != nil {
+			select {
+			case c.next <- sseResult{err: err}:
+			case <-c.done:
+			}
+			return
+		}
+		var v any
+		if jsonErr := json.Unmarshal([]byte(ev.Data), &v); jsonErr != nil {
+			v = ev.Data
+		}
+		select {
+		case c.next <- sseResult{value: v}:
+		case <-c.done:
+			return
+		}
+	}
+}
+
+func (c *sseConn) finish() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.closed {
+		return
+	}
+	c.closed = true
+	close(c.next)
+}
+
+func (c *sseConn) Recv(ctx context.Context) (any, error) {
+	select {
+	case r, ok := <-c.next:
+		if !ok {
+			return nil, io.EOF
+		}
+		return r.value, r.err
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+}
+
+func (c *sseConn) Send(ctx context.Context, data any) error {
+	return errors.New("honey: sse transport is receive-only")
+}
+
+func (c *sseConn) Close() error {
+	c.once.Do(func() {
+		close(c.done)
+		c.cancel()
+	})
+	return c.resp.Body.Close()
+}
+
+/* ──────────────────────────── Longpoll adapter ─────────────────────────── */
+
+// LongpollTransport is the default long-poll adapter. Each Recv fires a GET
+// against the configured URL with cursor query params and blocks until the
+// server replies. Payloads that look like JSON objects have their
+// reconnect_token / id / last_event_id fields harvested to advance the cursor.
+type LongpollTransport struct {
+	HTTPClient *http.Client
+}
+
+// Name returns "longpoll".
+func (t *LongpollTransport) Name() string { return "longpoll" }
+
+// Kind returns TransportLongpoll.
+func (t *LongpollTransport) Kind() TransportKind { return TransportLongpoll }
+
+// Connect constructs the longpoll conn; no wire traffic until first Recv.
+func (t *LongpollTransport) Connect(ctx context.Context, rawURL string, opts *TransportOpts) (TransportConn, error) {
+	client := t.HTTPClient
+	if opts != nil && opts.HTTPClient != nil {
+		client = opts.HTTPClient
+	}
+	if client == nil {
+		client = http.DefaultClient
+	}
+	lp := &longpollConn{
+		client:      client,
+		url:         rawURL,
+		headers:     http.Header{},
+		pollTimeout: defaultPollTimeout,
+	}
+	if opts != nil && opts.PollTimeout > 0 {
+		lp.pollTimeout = opts.PollTimeout
+	}
+	if opts != nil {
+		lp.reconnectToken = opts.ReconnectToken
+		lp.lastEventID = opts.LastEventID
+		if opts.Headers != nil {
+			lp.headers = opts.Headers.Clone()
+		}
+	}
+	return lp, nil
+}
+
+type longpollConn struct {
+	pollTimeout    time.Duration
+	client         *http.Client
+	url            string
+	headers        http.Header
+	reconnectToken string
+	lastEventID    string
+	mu             sync.Mutex
+	closed         bool
+}
+
+func (c *longpollConn) Kind() TransportKind { return TransportLongpoll }
+
+func (c *longpollConn) Recv(ctx context.Context) (any, error) {
+	c.mu.Lock()
+	if c.closed {
+		c.mu.Unlock()
+		return nil, io.EOF
+	}
+	token := c.reconnectToken
+	lastID := c.lastEventID
+	headers := c.headers
+	c.mu.Unlock()
+
+	q := url.Values{}
+	if token != "" {
+		q.Set("reconnect_token", token)
+	}
+	if lastID != "" {
+		q.Set("last_event_id", lastID)
+	}
+	u := c.url
+	if len(q) > 0 {
+		sep := "?"
+		if strings.Contains(u, "?") {
+			sep = "&"
+		}
+		u = u + sep + q.Encode()
+	}
+	pollCtx, cancel := context.WithTimeout(ctx, c.pollTimeout)
+	defer cancel()
+	req, err := http.NewRequestWithContext(pollCtx, "GET", u, nil)
+	if err != nil {
+		return nil, err
+	}
+	for k, vv := range headers {
+		for _, v := range vv {
+			req.Header.Add(k, v)
+		}
+	}
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, fmt.Errorf("honey: longpoll transport: status %d", resp.StatusCode)
+	}
+	body, err := readBody(resp.Body, defaultMaxMessageBytes)
+	if err != nil {
+		return nil, err
+	}
+	var v any
+	if jsonErr := json.Unmarshal(body, &v); jsonErr != nil {
+		v = string(body)
+	}
+	if m, ok := v.(map[string]any); ok {
+		c.mu.Lock()
+		if tok, ok := m["reconnect_token"].(string); ok {
+			c.reconnectToken = tok
+		}
+		if id, ok := m["id"].(string); ok {
+			c.lastEventID = id
+		}
+		if id, ok := m["last_event_id"].(string); ok {
+			c.lastEventID = id
+		}
+		c.mu.Unlock()
+	}
+	return v, nil
+}
+
+func (c *longpollConn) Send(ctx context.Context, data any) error {
+	return errors.New("honey: longpoll transport is receive-only")
+}
+
+func (c *longpollConn) Close() error {
+	c.mu.Lock()
+	c.closed = true
+	c.mu.Unlock()
+	return nil
+}
+
+/* internal sentinel used by tests; exported-like lowercase to keep public
+ * surface unchanged from 8.b.3. */
+var _ = errTransportNotImplemented