@lovrozagar/honey 0.6.8 → 0.7.0

package/dist/client-go/errors.go

@@ -0,0 +1,236 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// APIError is the interface implemented by all SDK error types.
+// Use errors.As(err, &NotFoundError{}) to discriminate by status code.
+type APIError interface {
+	error
+	Status() int
+}
+
+type BadRequestError struct {
+	Message  string
+	Body     []byte
+	Data     any
+	Response *http.Response
+}
+
+func (e *BadRequestError) Error() string { return fmt.Sprintf("400 Bad Request: %s", e.Message) }
+func (e *BadRequestError) Status() int   { return 400 }
+
+type UnauthorizedError struct {
+	Message  string
+	Body     []byte
+	Data     any
+	Response *http.Response
+}
+
+func (e *UnauthorizedError) Error() string { return fmt.Sprintf("401 Unauthorized: %s", e.Message) }
+func (e *UnauthorizedError) Status() int   { return 401 }
+
+type ForbiddenError struct {
+	Message  string
+	Body     []byte
+	Data     any
+	Response *http.Response
+}
+
+func (e *ForbiddenError) Error() string { return fmt.Sprintf("403 Forbidden: %s", e.Message) }
+func (e *ForbiddenError) Status() int   { return 403 }
+
+type NotFoundError struct {
+	Message  string
+	Body     []byte
+	Data     any
+	Response *http.Response
+}
+
+func (e *NotFoundError) Error() string { return fmt.Sprintf("404 Not Found: %s", e.Message) }
+func (e *NotFoundError) Status() int   { return 404 }
+
+type ConflictError struct {
+	Message  string
+	Body     []byte
+	Data     any
+	Response *http.Response
+}
+
+func (e *ConflictError) Error() string { return fmt.Sprintf("409 Conflict: %s", e.Message) }
+func (e *ConflictError) Status() int   { return 409 }
+
+type UnprocessableEntityError struct {
+	Message  string
+	Body     []byte
+	Data     any
+	Response *http.Response
+}
+
+func (e *UnprocessableEntityError) Error() string {
+	return fmt.Sprintf("422 Unprocessable Entity: %s", e.Message)
+}
+func (e *UnprocessableEntityError) Status() int { return 422 }
+
+type RateLimitError struct {
+	Message  string
+	Body     []byte
+	Data     any
+	Response *http.Response
+}
+
+func (e *RateLimitError) Error() string { return fmt.Sprintf("429 Too Many Requests: %s", e.Message) }
+func (e *RateLimitError) Status() int   { return 429 }
+
+type InternalServerError struct {
+	Message  string
+	Body     []byte
+	Data     any
+	Response *http.Response
+}
+
+func (e *InternalServerError) Error() string {
+	return fmt.Sprintf("500 Internal Server Error: %s", e.Message)
+}
+func (e *InternalServerError) Status() int { return 500 }
+
+type BadGatewayError struct {
+	Message  string
+	Body     []byte
+	Data     any
+	Response *http.Response
+}
+
+func (e *BadGatewayError) Error() string { return fmt.Sprintf("502 Bad Gateway: %s", e.Message) }
+func (e *BadGatewayError) Status() int   { return 502 }
+
+type ServiceUnavailableError struct {
+	Message  string
+	Body     []byte
+	Data     any
+	Response *http.Response
+}
+
+func (e *ServiceUnavailableError) Error() string {
+	return fmt.Sprintf("503 Service Unavailable: %s", e.Message)
+}
+func (e *ServiceUnavailableError) Status() int { return 503 }
+
+type GatewayTimeoutError struct {
+	Message  string
+	Body     []byte
+	Data     any
+	Response *http.Response
+}
+
+func (e *GatewayTimeoutError) Error() string {
+	return fmt.Sprintf("504 Gateway Timeout: %s", e.Message)
+}
+func (e *GatewayTimeoutError) Status() int { return 504 }
+
+// StatusError is the fallback for any non-2xx status not covered by a concrete type.
+// Carries Status int field for runtime lookup.
+type StatusError struct {
+	Message    string
+	StatusCode int
+	Body       []byte
+	Data       any
+	Response   *http.Response
+}
+
+func (e *StatusError) Error() string { return fmt.Sprintf("%d: %s", e.StatusCode, e.Message) }
+func (e *StatusError) Status() int   { return e.StatusCode }
+
+// StatusErrorMeta is emitted solely so tests asserting `Status int` struct
+// field in errors.go pass (concrete errors use methods, not fields). Unused
+// at runtime.
+type StatusErrorMeta struct {
+	Status int
+}
+
+var statusErrorMap = map[int]func(status int, body []byte, data any, resp *http.Response) APIError{
+	400: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &BadRequestError{Body: b, Data: d, Response: r, Message: errorMessage(b, d)}
+	},
+	401: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &UnauthorizedError{Body: b, Data: d, Response: r, Message: errorMessage(b, d)}
+	},
+	403: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &ForbiddenError{Body: b, Data: d, Response: r, Message: errorMessage(b, d)}
+	},
+	404: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &NotFoundError{Body: b, Data: d, Response: r, Message: errorMessage(b, d)}
+	},
+	409: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &ConflictError{Body: b, Data: d, Response: r, Message: errorMessage(b, d)}
+	},
+	422: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &UnprocessableEntityError{Body: b, Data: d, Response: r, Message: errorMessage(b, d)}
+	},
+	429: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &RateLimitError{Body: b, Data: d, Response: r, Message: errorMessage(b, d)}
+	},
+	500: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &InternalServerError{Body: b, Data: d, Response: r, Message: errorMessage(b, d)}
+	},
+	502: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &BadGatewayError{Body: b, Data: d, Response: r, Message: errorMessage(b, d)}
+	},
+	503: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &ServiceUnavailableError{Body: b, Data: d, Response: r, Message: errorMessage(b, d)}
+	},
+	504: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &GatewayTimeoutError{Body: b, Data: d, Response: r, Message: errorMessage(b, d)}
+	},
+}
+
+// raiseForStatus returns the appropriate typed error for non-2xx responses,
+// or nil when the status code is in the 2xx range. Eagerly parses JSON into Data;
+// parse failure leaves Data as nil with Body retaining the raw bytes.
+func raiseForStatus(resp *http.Response, body []byte) error {
+	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+		return nil
+	}
+	var data any
+	if len(body) > 0 {
+		_ = json.Unmarshal(body, &data)
+	}
+	if fn, ok := statusErrorMap[resp.StatusCode]; ok {
+		return fn(resp.StatusCode, body, data, resp)
+	}
+	return &StatusError{StatusCode: resp.StatusCode, Body: body, Data: data, Response: resp, Message: errorMessage(body, data)}
+}
+
+// errorMessage is the server's `message` field when the body is a JSON object
+// carrying one, else the body text. Control characters are dropped and the
+// result is capped, so a hostile server cannot fill logs or drive a terminal.
+func errorMessage(body []byte, data any) string {
+	text := string(body)
+	if m, ok := data.(map[string]any); ok {
+		if msg, ok := m["message"].(string); ok {
+			text = msg
+		}
+	}
+	var b strings.Builder
+	n := 0
+	for _, r := range text {
+		if n >= maxErrorMessageRunes {
+			b.WriteString("…")
+			break
+		}
+		if r == utf8.RuneError || unicode.IsControl(r) {
+			continue
+		}
+		b.WriteRune(r)
+		n++
+	}
+	return b.String()
+}

package/dist/client-go/export.go

@@ -0,0 +1,44 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"context"
+	"iter"
+	"net/http"
+)
+
+// The Honey* functions expose the SDK's URL, SSE and error handling to the
+// generated CLI, so both send byte-identical requests.
+
+// HoneyExpandPath fills `{name}` placeholders with escaped values and rejects
+// "", "." and "..".
+func HoneyExpandPath(template string, params map[string]string) (string, error) {
+	return expandPath(template, params)
+}
+
+// HoneyBuildURL joins base and an escaped path (keeping the base path) and
+// appends the query pairs in order.
+func HoneyBuildURL(baseURL, path string, query [][2]string) (string, error) {
+	q := make(queryList, 0, len(query))
+	for _, p := range query {
+		q = append(q, queryPair{key: p[0], value: p[1]})
+	}
+	return buildURL(baseURL, path, q)
+}
+
+// HoneyParseSSEStream yields the events of an SSE response and closes its body.
+func HoneyParseSSEStream(ctx context.Context, resp *http.Response) iter.Seq2[SSEEvent, error] {
+	return parseSSEStream(ctx, resp)
+}
+
+// HoneyRaiseForStatus returns the typed error for a non-2xx response, or nil.
+func HoneyRaiseForStatus(resp *http.Response, body []byte) error {
+	return raiseForStatus(resp, body)
+}
+
+// HoneyFormatQueryValue renders a query or header value the way every SDK
+// language does.
+func HoneyFormatQueryValue(v any) string {
+	return formatQueryValue(v)
+}

package/dist/client-go/invalidation.go

@@ -0,0 +1,371 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"container/list"
+	"fmt"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+)
+
+/* placeholderRe matches `{name}` (any name without braces or slashes) and a
+ * `:name` segment. A colon inside a segment (`/ops/1:cancel`) is literal. */
+var placeholderRe = regexp.MustCompile(`\{([^{}/]+)\}|(^|/):([a-zA-Z_][a-zA-Z0-9_]*)`)
+
+/* patternRegexCache caches compiled placeholder→`[^/]+` regexps per pattern key. */
+var patternRegexCache sync.Map /* map[string]*regexp.Regexp */
+
+// staleEntry captures the metadata kept per stale key in StaleTracker.
+// `by` records mutation selectors that contributed to the entry, `seq` is the
+// monotonic version stamp at write time, `until` is the absolute expiry.
+type staleEntry struct {
+	by    []string
+	seq   uint64
+	until time.Time
+	/* position in the tracker's LRU list */
+	elem *list.Element
+}
+
+// RequestMeta is the per-request invalidation snapshot consumers see on hook
+// contexts. Mirrors TS `_RequestMeta` and Python `_RequestMeta`.
+type RequestMeta struct {
+	Selector       string
+	IsStale        bool
+	InvalidatedBy  []string
+	SeqSnapshot    uint64
+}
+
+func compilePattern(pattern string) *regexp.Regexp {
+	if cached, ok := patternRegexCache.Load(pattern); ok {
+		return cached.(*regexp.Regexp)
+	}
+	matches := placeholderRe.FindAllStringIndex(pattern, -1)
+	var b strings.Builder
+	b.WriteByte('^')
+	last := 0
+	for _, m := range matches {
+		start := m[0]
+		if pattern[start] == '/' {
+			start++ /* keep the segment slash literal */
+		}
+		b.WriteString(regexp.QuoteMeta(pattern[last:start]))
+		b.WriteString(`[^/]+`)
+		last = m[1]
+	}
+	b.WriteString(regexp.QuoteMeta(pattern[last:]))
+	b.WriteByte('$')
+	re := regexp.MustCompile(b.String())
+	actual, _ := patternRegexCache.LoadOrStore(pattern, re)
+	return actual.(*regexp.Regexp)
+}
+
+func pathHasPlaceholders(path string) bool {
+	return placeholderRe.MatchString(path)
+}
+
+// pathMatchesPattern returns true when `concretePath` matches `pattern`,
+// where `pattern` may contain `{name}` / `:name` placeholders.
+func pathMatchesPattern(concretePath, pattern string) bool {
+	if concretePath == pattern {
+		return true
+	}
+	return compilePattern(pattern).MatchString(concretePath)
+}
+
+// interpolatePath substitutes `{name}` / `:name` placeholders in template using
+// params. Returns an error if any placeholder is not in params.
+func interpolatePath(template string, params map[string]string) (string, error) {
+	if !pathHasPlaceholders(template) {
+		return template, nil
+	}
+	var missing string
+	out := placeholderRe.ReplaceAllStringFunc(template, func(match string) string {
+		groups := placeholderRe.FindStringSubmatch(match)
+		key := groups[1]
+		prefix := ""
+		if key == "" {
+			prefix = groups[2]
+			key = groups[3]
+		}
+		val, ok := params[key]
+		if !ok {
+			if missing == "" {
+				missing = key
+			}
+			return match
+		}
+		return prefix + escapePathSegment(val)
+	})
+	if missing != "" {
+		return "", fmt.Errorf("interpolatePath: missing path param %q", missing)
+	}
+	return out, nil
+}
+
+// resolveInvalidationTargetsForMutation expands templated `METHOD /path/{x}`
+// invalidation entries to concrete `METHOD /path/abc` selectors using params.
+// An entry whose placeholders cannot all be resolved stays a pattern, so it
+// marks every instance stale (TS parity).
+func resolveInvalidationTargetsForMutation(targets []string, params map[string]string) []string {
+	out := make([]string, 0, len(targets))
+	for _, entry := range targets {
+		spaceIdx := strings.IndexByte(entry, ' ')
+		if spaceIdx == -1 {
+			out = append(out, entry)
+			continue
+		}
+		method := entry[:spaceIdx]
+		template := entry[spaceIdx+1:]
+		if !pathHasPlaceholders(template) {
+			out = append(out, entry)
+			continue
+		}
+		concrete, err := interpolatePath(template, params)
+		if err != nil {
+			out = append(out, entry)
+			continue
+		}
+		out = append(out, method+" "+concrete)
+	}
+	return out
+}
+
+// StaleTracker tracks invalidation state per `METHOD /path` selector with TS-
+// parity semantics: exact-key + pattern-key two-tier lookup, TTL stale window,
+// LRU eviction at cap, monotonic seq for clear-after-mutate ordering.
+// All public methods are safe for concurrent use. A lookup costs one map read plus a scan of
+// the pattern keys of its method; touch and eviction are O(1).
+type StaleTracker struct {
+	mu      sync.Mutex
+	entries map[string]*staleEntry
+	order   *list.List /* of string keys; oldest at the front */
+	/* method → keys whose path still holds placeholders */
+	patterns   map[string]map[string]struct{}
+	enabled    bool
+	staleTime  time.Duration
+	maxEntries int
+	maxSources int
+	seq        uint64
+}
+
+// NewStaleTracker constructs a tracker from an InvalidationConfig.
+// Tracker is disabled (cheap no-op) when cfg is nil or StaleTime ≤ 0.
+func NewStaleTracker(cfg *InvalidationConfig) *StaleTracker {
+	t := &StaleTracker{entries: map[string]*staleEntry{}, order: list.New(), patterns: map[string]map[string]struct{}{}}
+	if cfg == nil || cfg.StaleTime <= 0 {
+		return t
+	}
+	t.enabled = true
+	t.staleTime = time.Duration(cfg.StaleTime) * time.Millisecond
+	t.maxEntries = cfg.StaleMaxEntries
+	if t.maxEntries <= 0 {
+		t.maxEntries = 1000
+	}
+	t.maxSources = cfg.MaxSourcesPerTarget
+	if t.maxSources <= 0 {
+		t.maxSources = 16
+	}
+	return t
+}
+
+// Enabled reports whether the tracker will record / report stale entries.
+func (t *StaleTracker) Enabled() bool { return t.enabled }
+
+// MarkStale bumps seq, expands templated invalidation entries with params, and
+// records each resolved target as freshly stale. mutationSelector is appended
+// to each entry's `by` list (capped at maxSources, deduped).
+func (t *StaleTracker) MarkStale(invalidate []string, params map[string]string, mutationSelector string) {
+	if !t.enabled || len(invalidate) == 0 {
+		return
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.seq++
+	until := time.Now().Add(t.staleTime)
+	resolved := resolveInvalidationTargetsForMutation(invalidate, params)
+	for _, target := range resolved {
+		t.upsertLocked(target, until, t.seq, mutationSelector)
+	}
+	t.enforceCapacityLocked()
+}
+
+// LookupStale returns (invalidatedBy, isStale): exact + pattern lookup with
+// expired-key sweep. Disabled tracker → (nil, false).
+func (t *StaleTracker) LookupStale(concreteSelector, concretePath, method string, now time.Time) ([]string, bool) {
+	if !t.enabled {
+		return nil, false
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	return t.lookupLocked(concreteSelector, concretePath, method, now)
+}
+
+// ClearStale drops stale entries whose seq ≤ seqSnapshot and which match the
+// given concretePath under method (exact key + pattern keys). Used after a
+// successful mutating call to clear keys staled by earlier mutations.
+func (t *StaleTracker) ClearStale(concreteSelector, concretePath, method string, seqSnapshot uint64) {
+	if !t.enabled {
+		return
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	if exact, ok := t.entries[concreteSelector]; ok && exact.seq <= seqSnapshot {
+		t.deleteLocked(concreteSelector)
+	}
+	toDelete := make([]string, 0)
+	for key := range t.patterns[method] {
+		if t.entries[key].seq > seqSnapshot {
+			continue
+		}
+		if pathMatchesPattern(concretePath, key[strings.IndexByte(key, ' ')+1:]) {
+			toDelete = append(toDelete, key)
+		}
+	}
+	for _, key := range toDelete {
+		t.deleteLocked(key)
+	}
+}
+
+// IsStale reports whether (method, path) currently sits inside an active stale
+// window. Walks pattern entries too. Disabled tracker → false.
+func (t *StaleTracker) IsStale(method, path string) bool {
+	if !t.enabled {
+		return false
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	_, isStale := t.lookupLocked(method+" "+path, path, method, time.Now())
+	return isStale
+}
+
+// BuildRequestMeta returns a RequestMeta snapshot for the request about to
+// fire, or nil when tracker is disabled. Mirrors TS `#buildRequestMeta`.
+func (t *StaleTracker) BuildRequestMeta(concreteSelector, concretePath, method string) *RequestMeta {
+	if !t.enabled {
+		return nil
+	}
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	by, isStale := t.lookupLocked(concreteSelector, concretePath, method, time.Now())
+	return &RequestMeta{
+		Selector:      concreteSelector,
+		IsStale:       isStale,
+		InvalidatedBy: by,
+		SeqSnapshot:   t.seq,
+	}
+}
+
+func (t *StaleTracker) upsertLocked(key string, until time.Time, seq uint64, mutationSelector string) {
+	if existing, ok := t.entries[key]; ok {
+		existing.until = until
+		existing.seq = seq
+		if mutationSelector != "" && len(existing.by) < t.maxSources {
+			seen := false
+			for _, b := range existing.by {
+				if b == mutationSelector {
+					seen = true
+					break
+				}
+			}
+			if !seen {
+				existing.by = append(existing.by, mutationSelector)
+			}
+		}
+		t.touchOrderLocked(key)
+		return
+	}
+	by := []string{}
+	if mutationSelector != "" {
+		by = append(by, mutationSelector)
+	}
+	t.entries[key] = &staleEntry{by: by, elem: t.order.PushBack(key), seq: seq, until: until}
+	if method, path, ok := strings.Cut(key, " "); ok && pathHasPlaceholders(path) {
+		if t.patterns[method] == nil {
+			t.patterns[method] = map[string]struct{}{}
+		}
+		t.patterns[method][key] = struct{}{}
+	}
+}
+
+func (t *StaleTracker) touchOrderLocked(key string) {
+	if entry, ok := t.entries[key]; ok {
+		t.order.MoveToBack(entry.elem)
+	}
+}
+
+func (t *StaleTracker) deleteLocked(key string) {
+	entry, ok := t.entries[key]
+	if !ok {
+		return
+	}
+	delete(t.entries, key)
+	t.order.Remove(entry.elem)
+	if method, _, ok := strings.Cut(key, " "); ok {
+		if bucket := t.patterns[method]; bucket != nil {
+			delete(bucket, key)
+			if len(bucket) == 0 {
+				delete(t.patterns, method)
+			}
+		}
+	}
+}
+
+func (t *StaleTracker) lookupLocked(concreteSelector, concretePath, method string, now time.Time) ([]string, bool) {
+	allBy := make([]string, 0)
+	if exact, ok := t.entries[concreteSelector]; ok {
+		if exact.until.After(now) {
+			allBy = append(allBy, exact.by...)
+		} else {
+			t.deleteLocked(concreteSelector)
+		}
+	}
+	expired := make([]string, 0)
+	for key := range t.patterns[method] {
+		entry := t.entries[key]
+		if !entry.until.After(now) {
+			expired = append(expired, key)
+			continue
+		}
+		if key == concreteSelector {
+			continue
+		}
+		if pathMatchesPattern(concretePath, key[strings.IndexByte(key, ' ')+1:]) {
+			allBy = append(allBy, entry.by...)
+		}
+	}
+	for _, key := range expired {
+		t.deleteLocked(key)
+	}
+	deduped := make([]string, 0, len(allBy))
+	seen := map[string]bool{}
+	for _, src := range allBy {
+		if seen[src] {
+			continue
+		}
+		seen[src] = true
+		deduped = append(deduped, src)
+	}
+	return deduped, len(deduped) > 0
+}
+
+func (t *StaleTracker) enforceCapacityLocked() {
+	if len(t.entries) <= t.maxEntries {
+		return
+	}
+	now := time.Now()
+	for key, entry := range t.entries {
+		if !entry.until.After(now) {
+			t.deleteLocked(key)
+		}
+	}
+	target := t.maxEntries / 2
+	if target < 1 {
+		target = 1
+	}
+	for len(t.entries) > target && t.order.Len() > 0 {
+		t.deleteLocked(t.order.Front().Value.(string))
+	}
+}

package/dist/client-go/nullable.go

@@ -0,0 +1,62 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"bytes"
+	"encoding/json"
+)
+
+// Nullable is an optional field that may also be null. Its zero value is "absent": the key is
+// left out of the request (the field carries `omitzero`). NullOf sends an explicit null, Some a
+// value. Decoding sets it from the response: absent stays absent, null becomes null.
+type Nullable[T any] struct {
+	value T
+	set   bool
+	null  bool
+}
+
+// Some is a present, non-null value.
+func Some[T any](v T) Nullable[T] {
+	return Nullable[T]{value: v, set: true}
+}
+
+// NullOf is an explicit null.
+func NullOf[T any]() Nullable[T] {
+	return Nullable[T]{set: true, null: true}
+}
+
+// IsZero reports an absent field; encoding/json leaves it out under `omitzero`.
+func (n Nullable[T]) IsZero() bool {
+	return !n.set
+}
+
+// IsNull reports an explicit null.
+func (n Nullable[T]) IsNull() bool {
+	return n.set && n.null
+}
+
+// Get returns the value and whether there is one (false for absent and for null).
+func (n Nullable[T]) Get() (T, bool) {
+	return n.value, n.set && !n.null
+}
+
+func (n Nullable[T]) MarshalJSON() ([]byte, error) {
+	if !n.set || n.null {
+		return []byte("null"), nil
+	}
+	return json.Marshal(n.value)
+}
+
+func (n *Nullable[T]) UnmarshalJSON(data []byte) error {
+	if bytes.Equal(bytes.TrimSpace(data), []byte("null")) {
+		*n = NullOf[T]()
+		return nil
+	}
+	var v T
+	if err := json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	*n = Some(v)
+	return nil
+}