swr.go

package swr

import (
	"errors"
	"sync"
	"time"
)

type Fetcher[T any] func() (T, error)

type Cache[T any] struct {
	fetcher Fetcher[T]
	refresh time.Duration

	mu        sync.Mutex
	value     *T
	err       error
	timestamp time.Time
	fetching  chan struct{}
}

func New[T any](fetcher Fetcher[T], refresh time.Duration) (*Cache[T], error) {
	if fetcher == nil {
		return nil, errors.New("swr cache fetcher must not be nil")
	}
	if refresh <= 0 {
		return nil, errors.New("swr cache refresh must be greater than 0")
	}

	c := &Cache[T]{
		refresh: refresh,
		fetcher: fetcher,
	}
	return c, nil
}

func (c *Cache[T]) Get() (T, error) {
	if c == nil {
		var zero T
		return zero, errors.New("swr cache is nil")
	}

	defer c.mu.Unlock()
	c.mu.Lock()

	// Subsequent fetches
	if c.value != nil {
		// Background refresh
		if time.Since(c.timestamp) > c.refresh && c.fetching == nil {
			c.fetching = make(chan struct{})
			go c.backgroundFetch(c.fetching)
		}

		return *c.value, nil
	}

	// Initial fetches
	if c.fetching != nil {
		// Await initial fetch in another goroutine
		ch := c.fetching
		c.mu.Unlock()
		<-ch
		c.mu.Lock()
	} else {
		c.initialFetch()
	}

	if c.err != nil {
		var zero T
		return zero, c.err
	}

	return *c.value, nil
}

func (c *Cache[T]) initialFetch() {
	// Start initial fetch (don't block other go routines by holding a lock)
	c.fetching = make(chan struct{})
	c.mu.Unlock()
	v, err := c.fetcher()
	c.mu.Lock()

	if err == nil {
		c.timestamp = time.Now()
		c.value = &v
	}

	// Update error and close channel
	c.err = err
	ch := c.fetching
	c.fetching = nil
	close(ch)
}

func (c *Cache[T]) backgroundFetch(fetching chan struct{}) {
	v, err := c.fetcher()
	defer c.mu.Unlock()
	c.mu.Lock()
	if err == nil {
		c.timestamp = time.Now()
		c.value = &v
	}
	c.err = err
	close(fetching)
	c.fetching = nil
}