@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/client-go/invalidation.go

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

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