@lovrozagar/honey 0.1.0

package/src/client-go/errors.go

@@ -0,0 +1,207 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// 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: string(b)}
+	},
+	401: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &UnauthorizedError{Body: b, Data: d, Response: r, Message: string(b)}
+	},
+	403: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &ForbiddenError{Body: b, Data: d, Response: r, Message: string(b)}
+	},
+	404: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &NotFoundError{Body: b, Data: d, Response: r, Message: string(b)}
+	},
+	409: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &ConflictError{Body: b, Data: d, Response: r, Message: string(b)}
+	},
+	422: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &UnprocessableEntityError{Body: b, Data: d, Response: r, Message: string(b)}
+	},
+	429: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &RateLimitError{Body: b, Data: d, Response: r, Message: string(b)}
+	},
+	500: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &InternalServerError{Body: b, Data: d, Response: r, Message: string(b)}
+	},
+	502: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &BadGatewayError{Body: b, Data: d, Response: r, Message: string(b)}
+	},
+	503: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &ServiceUnavailableError{Body: b, Data: d, Response: r, Message: string(b)}
+	},
+	504: func(s int, b []byte, d any, r *http.Response) APIError {
+		return &GatewayTimeoutError{Body: b, Data: d, Response: r, Message: string(b)}
+	},
+}
+
+// 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: string(body)}
+}

package/src/client-go/invalidation.go

@@ -0,0 +1,373 @@
+// Code generated by honey. DO NOT EDIT.
+
+package sdk
+
+import (
+	"fmt"
+	"net/url"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+)
+
+/* placeholderRe matches `{name}` and `:name` placeholders. */
+var placeholderRe = regexp.MustCompile(`\{([a-zA-Z_][a-zA-Z0-9_]*)\}|:([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
+}
+
+// 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 {
+		b.WriteString(regexp.QuoteMeta(pattern[last:m[0]]))
+		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]
+		if key == "" {
+			key = groups[2]
+		}
+		val, ok := params[key]
+		if !ok {
+			if missing == "" {
+				missing = key
+			}
+			return match
+		}
+		return url.PathEscape(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.
+// Pattern-only entries (no params provided) pass through; entries whose
+// placeholders cannot be resolved are dropped.
+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 {
+			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.
+type StaleTracker struct {
+	mu         sync.Mutex
+	entries    map[string]*staleEntry
+	order      []string /* insertion order; oldest at index 0 */
+	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{}}
+	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, entry := range t.entries {
+		if entry.seq > seqSnapshot {
+			continue
+		}
+		if !strings.Contains(key, "{") && !strings.Contains(key, ":") {
+			continue
+		}
+		spaceIdx := strings.IndexByte(key, ' ')
+		if spaceIdx == -1 {
+			continue
+		}
+		if key[:spaceIdx] != method {
+			continue
+		}
+		if pathMatchesPattern(concretePath, key[spaceIdx+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, seq: seq, until: until}
+	t.order = append(t.order, key)
+}
+
+func (t *StaleTracker) touchOrderLocked(key string) {
+	for i, k := range t.order {
+		if k == key {
+			t.order = append(t.order[:i], t.order[i+1:]...)
+			break
+		}
+	}
+	t.order = append(t.order, key)
+}
+
+func (t *StaleTracker) deleteLocked(key string) {
+	if _, ok := t.entries[key]; !ok {
+		return
+	}
+	delete(t.entries, key)
+	for i, k := range t.order {
+		if k == key {
+			t.order = append(t.order[:i], t.order[i+1:]...)
+			return
+		}
+	}
+}
+
+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, entry := range t.entries {
+		if !entry.until.After(now) {
+			expired = append(expired, key)
+			continue
+		}
+		if key == concreteSelector {
+			continue
+		}
+		if !strings.Contains(key, "{") && !strings.Contains(key, ":") {
+			continue
+		}
+		spaceIdx := strings.IndexByte(key, ' ')
+		if spaceIdx == -1 {
+			continue
+		}
+		if key[:spaceIdx] != method {
+			continue
+		}
+		if pathMatchesPattern(concretePath, key[spaceIdx+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 && len(t.order) > 0 {
+		oldest := t.order[0]
+		t.deleteLocked(oldest)
+	}
+}