@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/src/client-go/sse.go

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

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