@lovrozagar/honey 0.1.0

package/src/client-go/runtime.go

@@ -0,0 +1,413 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// RequestContext carries mutable request metadata through OnRequest hook
+// invocations. Hooks may mutate Method, URL, Headers, or Body; mutations are
+// applied to the outgoing request after the full hook chain completes.
+// Selector / IsStale / InvalidatedBy mirror the TS hook ctx and are populated
+// only when the SDK has an active StaleTracker.
+type RequestContext struct {
+	Method        string
+	URL           string
+	Path          string
+	Headers       http.Header
+	Body          []byte
+	IsRetry       bool
+	Selector      string
+	IsStale       bool
+	InvalidatedBy []string
+}
+
+// ResponseContext carries response metadata through OnResponse hook invocations.
+// Hooks may inspect or mutate Body bytes prior to JSON unmarshal in the caller.
+// Status is observational and is not mutated by hooks.
+// Selector / IsStale / InvalidatedBy mirror the TS hook ctx and are populated
+// only when the SDK has an active StaleTracker.
+type ResponseContext struct {
+	Status        int
+	Headers       http.Header
+	Body          []byte
+	IsRetry       bool
+	Selector      string
+	IsStale       bool
+	InvalidatedBy []string
+}
+
+// Config holds all configuration for the SDK client.
+type Config struct {
+	BaseURL string
+	BearerToken string
+	Headers map[string]string
+	Timeout time.Duration
+	ThrowOnError bool
+	StaleMaxEntries int
+	Invalidation *InvalidationConfig
+	OnAuthExpired func(context.Context) (string, error)
+	HTTPClient *http.Client
+	AuthHeaderName string
+	AuthHeaderPrefix string
+	OnRequest []func(*RequestContext) error
+	OnResponse []func(*ResponseContext) error
+	OnLog func(LogEntry)
+}
+
+// LogEntry is the payload passed to Config.OnLog. Consumers plug in their own
+// logger; the SDK never formats, levels, or persists. Status is a pointer so
+// nil encodes "omitted" (request_start) without colliding with a real 0 status.
+// Err is the underlying error on the "error" event; nil otherwise. JSON tags
+// match the TS/Python LogEntry shape for cross-language consumer parity.
+type LogEntry struct {
+	Level      string `json:"level"`
+	Event      string `json:"event"`
+	Operation  string `json:"operation"`
+	DurationMs int64  `json:"duration_ms"`
+	Status     *int   `json:"status,omitempty"`
+	Err        error  `json:"-"`
+}
+
+// emitLog invokes the OnLog callback if configured, swallowing any panic so a
+// faulty logger cannot break the request path. Mirrors Python _emit_log /
+// TS optional-chained call.
+func emitLog(cfg Config, entry LogEntry) {
+	if cfg.OnLog == nil {
+		return
+	}
+	defer func() {
+		_ = recover()
+	}()
+	cfg.OnLog(entry)
+}
+
+func errStatus(err error) *int {
+	var apiErr APIError
+	if errors.As(err, &apiErr) {
+		s := apiErr.Status()
+		return &s
+	}
+	return nil
+}
+
+// InvalidationConfig controls cache invalidation behaviour. StaleTime is in
+// milliseconds; ≤0 disables the tracker. StaleMaxEntries caps the LRU map.
+// MaxSourcesPerTarget caps the `by` list per stale entry.
+type InvalidationConfig struct {
+	StaleTime           int64
+	StaleMaxEntries     int
+	MaxSourcesPerTarget int
+}
+
+type requestResult struct {
+	body   []byte
+	status int
+	resp   *http.Response
+}
+
+// doRequest executes an HTTP request, injects auth, merges headers, fires
+// OnRequest/OnResponse hooks in declaration order, handles OnAuthExpired retry
+// on 401, and wraps context cancellation errors. Emits OnLog lifecycle entries
+// (request_start once at entry, response_received once for the final response,
+// error on terminal failure) — matching TS/Python behavior where retry rounds
+// do not double-emit.
+func doRequest(
+	ctx context.Context,
+	cfg Config,
+	method string,
+	rawURL string,
+	queryParams url.Values,
+	bodyData interface{},
+	bodyReader io.Reader,
+	contentType string,
+	callHeaders map[string]string,
+	operation string,
+	requestMeta *RequestMeta,
+) (result *requestResult, err error) {
+	start := time.Now()
+	defer func() {
+		if err != nil {
+			emitLog(cfg, LogEntry{
+				Level:      "error",
+				Event:      "error",
+				Operation:  operation,
+				DurationMs: time.Since(start).Milliseconds(),
+				Status:     errStatus(err),
+				Err:        err,
+			})
+		}
+	}()
+
+	if ctx.Err() != nil {
+		return nil, fmt.Errorf("honey: request canceled: %w", ctx.Err())
+	}
+
+	emitLog(cfg, LogEntry{
+		Level:     "debug",
+		Event:     "request_start",
+		Operation: operation,
+	})
+
+	result, err = executeRequest(ctx, cfg, method, rawURL, queryParams, bodyData, bodyReader, contentType, callHeaders, cfg.BearerToken, false, requestMeta)
+	if err != nil {
+		return nil, err
+	}
+
+	if result.status == 401 && cfg.OnAuthExpired != nil {
+		newToken, authErr := cfg.OnAuthExpired(ctx)
+		if authErr != nil {
+			err = fmt.Errorf("honey: OnAuthExpired failed: %w", authErr)
+			return nil, err
+		}
+		/* streaming bodies are single-shot: once consumed by the first request,
+		 * retry has no way to replay. Documented as v1 non-goal — consumers
+		 * needing auto-retry on streamed uploads wrap in an outer retry loop. */
+		result, err = executeRequest(ctx, cfg, method, rawURL, queryParams, bodyData, bodyReader, contentType, callHeaders, newToken, true, requestMeta)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	status := result.status
+	level := "info"
+	if status >= 400 {
+		level = "warn"
+	}
+	emitLog(cfg, LogEntry{
+		Level:      level,
+		Event:      "response_received",
+		Operation:  operation,
+		DurationMs: time.Since(start).Milliseconds(),
+		Status:     &status,
+	})
+
+	if err2 := raiseForStatus(result.resp, result.body); err2 != nil {
+		err = err2
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func executeRequest(
+	ctx context.Context,
+	cfg Config,
+	method string,
+	rawURL string,
+	queryParams url.Values,
+	bodyData interface{},
+	bodyReader io.Reader,
+	contentType string,
+	callHeaders map[string]string,
+	bearerToken string,
+	isRetry bool,
+	requestMeta *RequestMeta,
+) (*requestResult, error) {
+	fullURL, err := buildURL(cfg.BaseURL, rawURL, queryParams)
+	if err != nil {
+		return nil, fmt.Errorf("honey: build URL: %w", err)
+	}
+
+	/* bodyReader wins over bodyData — streaming uploads bypass JSON marshal.
+	 * RequestContext.Body stays nil for streams so hook consumers don't try to
+	 * read or re-hash a single-shot reader. */
+	var bodyBytes []byte
+	if bodyReader == nil && bodyData != nil {
+		encoded, encErr := json.Marshal(bodyData)
+		if encErr != nil {
+			return nil, fmt.Errorf("honey: marshal body: %w", encErr)
+		}
+		bodyBytes = encoded
+	}
+	hasBody := bodyReader != nil || bodyData != nil
+
+	headers := mergeHeaders(cfg, callHeaders, bearerToken, hasBody, contentType)
+
+	reqCtx := &RequestContext{
+		Method:  method,
+		URL:     fullURL,
+		Path:    rawURL,
+		Headers: headers,
+		Body:    bodyBytes,
+		IsRetry: isRetry,
+	}
+	if requestMeta != nil {
+		reqCtx.Selector = requestMeta.Selector
+		reqCtx.IsStale = requestMeta.IsStale
+		reqCtx.InvalidatedBy = requestMeta.InvalidatedBy
+	}
+
+	for _, hook := range cfg.OnRequest {
+		if hookErr := hook(reqCtx); hookErr != nil {
+			return nil, fmt.Errorf("honey: OnRequest hook: %w", hookErr)
+		}
+	}
+
+	var reader io.Reader
+	if bodyReader != nil {
+		reader = bodyReader
+	} else if reqCtx.Body != nil {
+		reader = bytes.NewReader(reqCtx.Body)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, reqCtx.Method, reqCtx.URL, reader)
+	if err != nil {
+		return nil, fmt.Errorf("honey: build request: %w", err)
+	}
+	req.Header = reqCtx.Headers
+
+	resp, err := cfg.HTTPClient.Do(req)
+	if err != nil {
+		if ctx.Err() != nil {
+			if errors.Is(ctx.Err(), context.DeadlineExceeded) {
+				return nil, fmt.Errorf("honey: request timed out: %w", ctx.Err())
+			}
+			if errors.Is(ctx.Err(), context.Canceled) {
+				return nil, fmt.Errorf("honey: request canceled: %w", ctx.Err())
+			}
+			return nil, fmt.Errorf("honey: context error: %w", ctx.Err())
+		}
+		return nil, fmt.Errorf("honey: http do: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, readErr := io.ReadAll(resp.Body)
+	if readErr != nil {
+		return nil, fmt.Errorf("honey: read body: %w", readErr)
+	}
+
+	respCtx := &ResponseContext{
+		Status:  resp.StatusCode,
+		Headers: resp.Header,
+		Body:    body,
+		IsRetry: isRetry,
+	}
+	if requestMeta != nil {
+		respCtx.Selector = requestMeta.Selector
+		respCtx.IsStale = requestMeta.IsStale
+		respCtx.InvalidatedBy = requestMeta.InvalidatedBy
+	}
+
+	for _, hook := range cfg.OnResponse {
+		if hookErr := hook(respCtx); hookErr != nil {
+			return nil, fmt.Errorf("honey: OnResponse hook: %w", hookErr)
+		}
+	}
+
+	return &requestResult{body: respCtx.Body, status: resp.StatusCode, resp: resp}, nil
+}
+
+func buildURL(baseURL, path string, queryParams url.Values) (string, error) {
+	base, err := url.Parse(baseURL)
+	if err != nil {
+		return "", err
+	}
+	ref, err := url.Parse(path)
+	if err != nil {
+		return "", err
+	}
+	resolved := base.ResolveReference(ref)
+	if len(queryParams) > 0 {
+		existing := resolved.Query()
+		for k, vals := range queryParams {
+			for _, v := range vals {
+				existing.Add(k, v)
+			}
+		}
+		resolved.RawQuery = existing.Encode()
+	}
+	return resolved.String(), nil
+}
+
+// mergeHeaders builds the final http.Header for a request by merging in order:
+// config Headers → call Headers (per-call wins per key) → Content-Type when
+// hasBody → Authorization when bearerToken non-empty. Returned header is owned
+// by the caller and may be mutated freely (e.g. by OnRequest hooks).
+// contentType is the explicit Content-Type for the request body; when empty
+// and hasBody is true, defaults to application/json. Callers pass
+// application/octet-stream for streaming-upload ops.
+func mergeHeaders(
+	cfg Config,
+	callHeaders map[string]string,
+	bearerToken string,
+	hasBody bool,
+	contentType string,
+) http.Header {
+	h := http.Header{}
+	if hasBody {
+		ct := contentType
+		if ct == "" {
+			ct = "application/json"
+		}
+		h.Set("Content-Type", ct)
+	}
+	for k, v := range cfg.Headers {
+		h.Set(k, v)
+	}
+	for k, v := range callHeaders {
+		h.Set(k, v)
+	}
+	if bearerToken != "" {
+		name := cfg.AuthHeaderName
+		if name == "" {
+			name = "Authorization"
+		}
+		prefix := cfg.AuthHeaderPrefix
+		if prefix == "" {
+			prefix = "Bearer "
+		}
+		h.Set(name, prefix+bearerToken)
+	}
+	return h
+}
+
+func unmarshalBody[T any](body []byte) (*T, error) {
+	if len(body) == 0 {
+		return nil, nil
+	}
+	var out T
+	if err := json.Unmarshal(body, &out); err != nil {
+		return nil, fmt.Errorf("honey: unmarshal response: %w", err)
+	}
+	return &out, nil
+}
+
+// newUUIDv4 returns a freshly generated RFC 4122 §4.4 random UUID string.
+// Uses crypto/rand for entropy; sets version (4) and variant (10xx) bits per
+// the spec, then formats canonical 8-4-4-4-12 lower-case hex. Zero external
+// deps so generated SDKs add no third-party rows to consumer go.sum files.
+func newUUIDv4() string {
+	var b [16]byte
+	if _, err := rand.Read(b[:]); err != nil {
+		/* crypto/rand.Read is documented to never return non-nil err on supported
+		 * platforms; if it does the OS entropy source is broken — silent fallback
+		 * would corrupt dedupe semantics, so panic mirrors google/uuid. */
+		panic("honey: crypto/rand failed: " + err.Error())
+	}
+	b[6] = (b[6] & 0x0f) | 0x40 /* version 4 */
+	b[8] = (b[8] & 0x3f) | 0x80 /* variant 10xx */
+	const hex = "0123456789abcdef"
+	out := make([]byte, 36)
+	j := 0
+	for i, by := range b {
+		if i == 4 || i == 6 || i == 8 || i == 10 {
+			out[j] = '-'
+			j++
+		}
+		out[j] = hex[by>>4]
+		out[j+1] = hex[by&0x0f]
+		j += 2
+	}
+	return string(out)
+}

package/src/client-go/sse.go

@@ -0,0 +1,149 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"bufio"
+	"context"
+	"io"
+	"iter"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+// SSEEvent represents a single server-sent event.
+type SSEEvent struct {
+	Data  string
+	Event string
+	ID    string
+	Retry int
+}
+
+const sseMaxBuffer = 1024 * 1024
+
+// 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.
+//
+// Ported from public/honey/core/src/client/sse.ts:62-102 — bufio.Scanner with
+// double-newline split mirrors the TextDecoder+split(/\r\n\r\n|…/) approach.
+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, _ := io.ReadAll(resp.Body)
+			apiErr := raiseForStatus(resp, body)
+			yield(SSEEvent{}, apiErr)
+			return
+		}
+
+		scanner := bufio.NewScanner(resp.Body)
+		scanner.Buffer(make([]byte, 0, 4096), sseMaxBuffer)
+		scanner.Split(splitDoubleNewline)
+
+		for scanner.Scan() {
+			if ctx.Err() != nil {
+				return
+			}
+			block := scanner.Text()
+			if strings.TrimSpace(block) == "" {
+				continue
+			}
+			ev, ok := parseSSEBlock(block)
+			if !ok {
+				continue
+			}
+			if !yield(ev, nil) {
+				return
+			}
+		}
+
+		if err := scanner.Err(); err != nil {
+			yield(SSEEvent{}, err)
+		}
+	}
+}
+
+// splitDoubleNewline is a bufio.SplitFunc that splits on \r\n\r\n, \n\n, or \r\r.
+func splitDoubleNewline(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	delimiters := []string{"\r\n\r\n", "\n\n", "\r\r"}
+	for _, d := range delimiters {
+		db := []byte(d)
+		for i := 0; i <= len(data)-len(db); i++ {
+			match := true
+			for j := range db {
+				if data[i+j] != db[j] {
+					match = false
+					break
+				}
+			}
+			if match {
+				return i + len(db), data[:i], nil
+			}
+		}
+	}
+	if atEOF && len(data) > 0 {
+		return len(data), data, nil
+	}
+	return 0, nil, nil
+}
+
+func parseSSEBlock(block string) (SSEEvent, bool) {
+	lines := strings.Split(block, "\n")
+	isComment := true
+	var data string
+	hasData := false
+	var event string
+	var id string
+	retry := 0
+
+	for _, rawLine := range lines {
+		line := strings.TrimRight(rawLine, "\r")
+		if strings.HasPrefix(line, ":") {
+			continue
+		}
+		isComment = false
+
+		colonIdx := strings.IndexByte(line, ':')
+		var field, val string
+		if colonIdx == -1 {
+			field = line
+			val = ""
+		} else {
+			field = line[:colonIdx]
+			val = line[colonIdx+1:]
+			if strings.HasPrefix(val, " ") {
+				val = val[1:]
+			}
+		}
+
+		switch field {
+		case "data":
+			if !hasData {
+				data = val
+			} else {
+				data = data + "\n" + val
+			}
+			hasData = true
+		case "event":
+			event = val
+		case "id":
+			/* per spec: id containing null byte must be ignored */
+			if !strings.ContainsRune(val, 0) {
+				id = val
+			}
+		case "retry":
+			if n, err := strconv.Atoi(val); err == nil && n >= 0 {
+				retry = n
+			}
+		}
+	}
+
+	if isComment || !hasData {
+		return SSEEvent{}, false
+	}
+
+	return SSEEvent{Data: data, Event: event, ID: id, Retry: retry}, true
+}