Method SWRWithFallback

pkg/cache/cache.go:474–540

(
	ctx context.Context,
	candidates []K,
	refreshFromOrigin func(context.Context) (V, K, error),
	op func(error) Op,
)

}

func (c *cache[K, V]) SWRWithFallback(
	ctx context.Context,
	candidates []K,
	refreshFromOrigin func(context.Context) (V, K, error),
	op func(error) Op,
) (V, CacheHit, error) {
	start := time.Now()
	now := c.clock.Now()

	// Check all candidate keys for cache hits
	for _, key := range candidates {
		e, ok := c.get(ctx, key)
		if !ok {
			continue
		}

		// Found in cache
		if now.Before(e.Fresh) {
			// Fresh - return immediately
			c.recordTiming(ctx, "cache_swr_fallback", "fresh", start)
			return e.Value, e.Hit, nil
		}

		if now.Before(e.Stale) {
			// Stale - return but queue background revalidation with deduplication
			c.inflightMu.Lock()
			if !c.inflightRefreshes[key] {
				c.inflightRefreshes[key] = true
				dedupeKey := key // capture for closure
				c.revalidateC <- func() {
					c.revalidateWithCanonicalKey(context.WithoutCancel(ctx), dedupeKey, refreshFromOrigin, op)
				}
			}
			c.inflightMu.Unlock()
			c.recordTiming(ctx, "cache_swr_fallback", "stale", start)
			return e.Value, e.Hit, nil
		}

		// Expired - delete and continue checking other candidates
		c.otter.Delete(key)
	}

	// Cache miss on all candidates - fetch from origin
	v, canonicalKey, err := refreshFromOrigin(ctx)
	c.recordTiming(ctx, "cache_swr_fallback", "miss", start)

	operation := op(err)

	if err != nil {
		var zero V
		return zero, Miss, err
	}

	var hit CacheHit
	switch operation {
	case WriteValue:
		c.Set(ctx, canonicalKey, v)
		hit = Hit