persist reorg

Author: Thomas Stromberg

benchmarks/go.mod

@@ -20,3 +20,5 @@ require (
 )
 
 replace github.com/codeGROOVE-dev/sfcache => ../
+
+replace github.com/codeGROOVE-dev/sfcache/pkg/persist => ../pkg/persist

go.mod

@@ -1,3 +1,7 @@
 module github.com/codeGROOVE-dev/sfcache
 
 go 1.25.4
+
+require github.com/codeGROOVE-dev/sfcache/pkg/persist v0.0.0
+
+replace github.com/codeGROOVE-dev/sfcache/pkg/persist => ./pkg/persist

memory.go

@@ -65,12 +65,7 @@ func (c *MemoryCache[K, V]) SetIfAbsent(key K, value V, ttl ...time.Duration) (V
 	if len(ttl) > 0 {
 		t = ttl[0]
 	}
-	expiry := c.expiry(t)
-	var expiryNano int64
-	if !expiry.IsZero() {
-		expiryNano = expiry.UnixNano()
-	}
-	return c.memory.getOrSetMemory(key, value, expiryNano)
+	return c.memory.getOrSetMemory(key, value, timeToNano(c.expiry(t)))
 }
 
 // Set stores a value in the cache.
@@ -81,7 +76,7 @@ func (c *MemoryCache[K, V]) Set(key K, value V, ttl ...time.Duration) {
 	if len(ttl) > 0 {
 		t = ttl[0]
 	}
-	c.memory.setToMemory(key, value, c.expiryNano(t))
+	c.memory.setToMemory(key, value, timeToNano(c.expiry(t)))
 }
 
 // Delete removes a value from the cache.
@@ -106,17 +101,6 @@ func (*MemoryCache[K, V]) Close() {
 	// No-op for memory-only cache
 }
 
-// expiryNano returns the expiry time in nanoseconds (0 means no expiry).
-func (c *MemoryCache[K, V]) expiryNano(ttl time.Duration) int64 {
-	if ttl <= 0 {
-		ttl = c.defaultTTL
-	}
-	if ttl <= 0 {
-		return 0
-	}
-	return time.Now().Add(ttl).UnixNano()
-}
-
 // expiry returns the expiry time based on TTL and default TTL.
 func (c *MemoryCache[K, V]) expiry(ttl time.Duration) time.Time {
 	if ttl <= 0 {

persist/cloudrun/go.mod

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"log/slog"
 	"time"
+
+	"github.com/codeGROOVE-dev/sfcache/pkg/persist"
 )
 
 // PersistentCache is a cache backed by both memory and persistent storage.
@@ -15,7 +17,7 @@ type PersistentCache[K comparable, V any] struct {
 	//   cache.Store.Len(ctx)
 	//   cache.Store.Flush(ctx)
 	//   cache.Store.Cleanup(ctx, maxAge)
-	Store PersistenceLayer[K, V]
+	Store persist.Layer[K, V]
 
 	memory     *s3fifo[K, V]
 	defaultTTL time.Duration
@@ -41,7 +43,7 @@ type PersistentCache[K comparable, V any] struct {
 //	cache.Set(ctx, "user:123", user, time.Hour)   // explicit TTL
 //	user, ok, err := cache.Get(ctx, "user:123")
 //	storeCount, _ := cache.Store.Len(ctx)
-func Persistent[K comparable, V any](ctx context.Context, p PersistenceLayer[K, V], opts ...Option) (*PersistentCache[K, V], error) {
+func Persistent[K comparable, V any](ctx context.Context, p persist.Layer[K, V], opts ...Option) (*PersistentCache[K, V], error) {
 	cfg := defaultConfig()
 	for _, opt := range opts {
 		opt(cfg)

persist/datastore/go.mod

@@ -6,6 +6,8 @@ import (
 	"sync"
 	"testing"
 	"time"
+
+	"github.com/codeGROOVE-dev/sfcache/pkg/persist"
 )
 
 // mockStore is a simple in-memory store for testing.
@@ -29,6 +31,18 @@ func newMockStore[K comparable, V any]() *mockStore[K, V] {
 	}
 }
 
+func (m *mockStore[K, V]) setFailGet(v bool) {
+	m.mu.Lock()
+	m.failGet = v
+	m.mu.Unlock()
+}
+
+func (m *mockStore[K, V]) setFailSet(v bool) {
+	m.mu.Lock()
+	m.failSet = v
+	m.mu.Unlock()
+}
+
 func (m *mockStore[K, V]) ValidateKey(key K) error {
 	return nil
 }
@@ -87,8 +101,8 @@ func (m *mockStore[K, V]) Delete(ctx context.Context, key K) error {
 }
 
 //nolint:gocritic // Channel returns are clearer without named results
-func (m *mockStore[K, V]) LoadRecent(ctx context.Context, limit int) (<-chan Entry[K, V], <-chan error) {
-	entryCh := make(chan Entry[K, V], 10)
+func (m *mockStore[K, V]) LoadRecent(ctx context.Context, limit int) (<-chan persist.Entry[K, V], <-chan error) {
+	entryCh := make(chan persist.Entry[K, V], 10)
 	errCh := make(chan error, 1)
 
 	go func() {
@@ -115,7 +129,7 @@ func (m *mockStore[K, V]) LoadRecent(ctx context.Context, limit int) (<-chan Ent
 				key = sk
 			}
 
-			entryCh <- Entry[K, V]{
+			entryCh <- persist.Entry[K, V]{
 				Key:       key,
 				Value:     entry.value,
 				Expiry:    entry.expiry,
@@ -360,7 +374,7 @@ func TestPersistentCache_Errors(t *testing.T) {
 
 	// Set returns error when persistence fails (by design)
 	// Value is still in memory, but error is returned to caller
-	store.failSet = true
+	store.setFailSet(true)
 	if err := cache.Set(ctx, "key1", 42, 0); err == nil {
 		t.Error("Set should return error when persistence fails")
 	}
@@ -375,7 +389,7 @@ func TestPersistentCache_Errors(t *testing.T) {
 	}
 
 	// SetAsync logs persistence errors but doesn't return them
-	store.failSet = true
+	store.setFailSet(true)
 	if err := cache.SetAsync(ctx, "key3", 300, 0); err != nil {
 		t.Fatalf("SetAsync should not fail synchronously: %v", err)
 	}
@@ -393,8 +407,8 @@ func TestPersistentCache_Errors(t *testing.T) {
 	time.Sleep(50 * time.Millisecond)
 
 	// Get should work from memory even if persistence fails
-	store.failGet = true
-	store.failSet = false
+	store.setFailGet(true)
+	store.setFailSet(false)
 	if err := cache.Set(ctx, "key2", 100, 0); err != nil {
 		t.Fatalf("Set: %v", err)
 	}
@@ -418,7 +432,7 @@ func TestPersistentCache_Delete_Errors(t *testing.T) {
 	defer func() { _ = cache.Close() }() //nolint:errcheck // Test cleanup
 
 	// Store a value (with failSet = false)
-	store.failSet = false
+	store.setFailSet(false)
 	if err := cache.Set(ctx, "key1", 42, 0); err != nil {
 		t.Fatalf("Set: %v", err)
 	}
@@ -433,7 +447,7 @@ func TestPersistentCache_Delete_Errors(t *testing.T) {
 	}
 
 	// Now make persistence delete fail
-	store.failSet = true // failSet affects Delete too in mock
+	store.setFailSet(true) // failSet affects Delete too in mock
 	err = cache.Delete(ctx, "key1")
 	if err == nil {
 		t.Error("Delete should return error when persistence fails")
@@ -492,7 +506,7 @@ func TestPersistentCache_Get_PersistenceLoadError(t *testing.T) {
 	_ = store.Store(ctx, "key1", 42, time.Time{}) //nolint:errcheck // Test fixture
 
 	// Make persistence Load fail
-	store.failGet = true
+	store.setFailGet(true)
 
 	// Get should return error on persistence failure
 	_, found, err := cache.Get(ctx, "key1")