driver_memory.go

package cache

import (
	"context"
	"sync"
	"time"
)

var _ Driver[string] = (*MemoryDriver[string])(nil)

// MemoryConfig holds configuration for memory driver
type MemoryConfig struct {
	DefaultTTL time.Duration
}

// MemoryOption is a function that configures memory driver
type MemoryOption func(*MemoryConfig)

// WithMemoryDefaultTTL sets the default TTL for memory driver
func WithMemoryDefaultTTL(duration time.Duration) MemoryOption {
	return func(c *MemoryConfig) {
		c.DefaultTTL = duration
	}
}

// MemoryDriver implements the Driver interface using in-memory storage
type MemoryDriver[Value any] struct {
	storage map[Key]Hit[Value]
	mu      sync.RWMutex
	config  MemoryConfig
}

// NewMemoryDriver creates a new memory driver instance
func NewMemoryDriver[Value any](options ...MemoryOption) *MemoryDriver[Value] {
	d := &MemoryDriver[Value]{
		storage: make(map[Key]Hit[Value]),
		config: MemoryConfig{
			DefaultTTL: time.Minute,
		},
	}

	for _, option := range options {
		option(&d.config)
	}

	return d
}

// NewMemoryCache creates a new cache instance with a memory driver
// This is a convenience function that combines NewMemoryDriver and NewCache
func NewMemoryCache[Value any](options ...MemoryOption) *Cache[Value] {
	driver := NewMemoryDriver[Value](options...)

	return NewCache[Value](driver)
}

// Get retrieves a value from memory storage
func (d *MemoryDriver[Value]) Get(_ context.Context, key Key) (Value, bool, error) { //nolint:ireturn
	d.mu.RLock()
	hit, found := d.storage[key]
	d.mu.RUnlock()

	var zeroValue Value

	if !found {
		return zeroValue, false, nil
	}

	// Check expiration
	if !hit.Expiry.IsZero() && time.Now().After(hit.Expiry) {
		d.mu.Lock()
		delete(d.storage, key)
		d.mu.Unlock()

		return zeroValue, false, nil
	}

	return hit.Value, true, nil
}

// Set stores a value in memory storage with the specified TTL
func (d *MemoryDriver[Value]) Set(_ context.Context, key Key, value Value, ttl TTL) error {
	var expiry time.Time

	switch {
	case ttl.useDefault:
		expiry = time.Now().Add(d.config.DefaultTTL)
	case ttl.duration == 0:
		// Zero duration and not using default means no expiration (Forever)
		expiry = time.Time{}
	default:
		expiry = time.Now().Add(ttl.duration)
	}

	d.mu.Lock()
	d.storage[key] = Hit[Value]{
		Value:  value,
		Expiry: expiry,
	}
	d.mu.Unlock()

	return nil
}

// Has checks if a key exists in memory storage
func (d *MemoryDriver[Value]) Has(ctx context.Context, key Key) (bool, error) {
	_, found, _ := d.Get(ctx, key)

	return found, nil
}

// Delete removes a key from memory storage
func (d *MemoryDriver[Value]) Delete(_ context.Context, key Key) error {
	d.mu.Lock()
	delete(d.storage, key)
	d.mu.Unlock()

	return nil
}