add go-cache RememberMany

cache.go

@@ -73,11 +73,11 @@ type Driver[V any] interface {
 	// Decrement the value of an item in the cache.
 	Decrement(key string, n V) (V, error)
 	// Remember Get an item from the cache, or execute the given Closure and store the result.
-	Remember(key string, ttl time.Duration, callback func() (V, error)) (V, error)
+	Remember(key string, ttl time.Duration, callback func() (V, error), force bool) (V, error)
 	// RememberForever Get an item from the cache, or execute the given Closure and store the result forever.
-	RememberForever(key string, callback func() (V, error)) (V, error)
+	RememberForever(key string, callback func() (V, error), force bool) (V, error)
 	// RememberMany Get many item from the cache, or execute the given Closure and store the result.
-	RememberMany(keys []string, ttl time.Duration, callback func(notHitKeys []string) (map[string]V, error)) (map[string]V, error)
+	RememberMany(keys []string, ttl time.Duration, callback func(notHitKeys []string) (map[string]V, error), force bool) (map[string]V, error)
 	// TTL Get cache ttl
 	TTL(key string) (time.Duration, error)
 	// WithCtx with context

cache_test.go

@@ -103,7 +103,7 @@ func testCache[V any](t *testing.T, driver Driver[V], key string, value V) {
 	t.Run("remember", func(t *testing.T) {
 		result, err := driver.Remember(key, duration, func() (V, error) {
 			return value, nil
-		})
+		}, false)
 		assert.NoError(t, err)
 		assert.Equal(t, value, result)
 		err = driver.Flush()
@@ -112,7 +112,7 @@ func testCache[V any](t *testing.T, driver Driver[V], key string, value V) {
 	t.Run("remember forever", func(t *testing.T) {
 		result, err := driver.RememberForever(key, func() (V, error) {
 			return value, nil
-		})
+		}, false)
 		assert.NoError(t, err)
 		assert.Equal(t, value, result)
 

go_cache.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	gocache "github.com/patrickmn/go-cache"
+	"github.com/samber/lo"
 	"github.com/spf13/cast"
 )
 
@@ -134,24 +135,58 @@ func (d *GoCacheDriver[V]) Decrement(key string, n V) (ret V, err error) {
 	return
 }
 
-func (d *GoCacheDriver[V]) Remember(key string, ttl time.Duration, callback func() (V, error)) (result V, err error) {
-	if result, err = d.Get(key); err == nil {
-		return
-	} else {
-		if result, err = callback(); err != nil {
+func (d *GoCacheDriver[V]) Remember(key string, ttl time.Duration, callback func() (V, error), force bool) (result V, err error) {
+	if !force {
+		if result, err = d.Get(key); err == nil {
 			return
 		}
-		err = d.Set(key, result, ttl)
+	}
+	if result, err = callback(); err != nil {
 		return
 	}
+	err = d.Set(key, result, ttl)
+	return
 }
 
-func (d *GoCacheDriver[V]) RememberForever(key string, callback func() (V, error)) (V, error) {
-	return d.Remember(key, gocache.NoExpiration, callback)
+func (d *GoCacheDriver[V]) RememberForever(key string, callback func() (V, error), force bool) (V, error) {
+	return d.Remember(key, gocache.NoExpiration, callback, force)
 }
 
-func (d *GoCacheDriver[V]) RememberMany(keys []string, ttl time.Duration, callback func(notHitKeys []string) (map[string]V, error)) (map[string]V, error) {
-	panic("not implemented")
+func (d *GoCacheDriver[V]) RememberMany(keys []string, ttl time.Duration, callback func(notHitKeys []string) (map[string]V, error), force bool) (map[string]V, error) {
+	var (
+		notHitKeys []string
+		err        error
+	)
+	many := make(map[string]V)
+	if !force {
+		many, err = d.Many(keys)
+		if err != nil {
+			return nil, err
+		}
+		notHitKeys = lo.Without(keys, lo.Keys(many)...)
+		if len(notHitKeys) == 0 {
+			return many, nil
+		}
+	} else {
+		notHitKeys = keys
+	}
+	notCacheItems, err := callback(notHitKeys)
+	if err != nil {
+		return nil, err
+	}
+	var needCacheItems []Many[V]
+	for s, v := range notCacheItems {
+		needCacheItems = append(needCacheItems, Many[V]{
+			Key:   s,
+			Value: v,
+			TTL:   ttl,
+		})
+	}
+	err = d.SetMany(needCacheItems)
+	if err != nil {
+		return nil, err
+	}
+	return lo.Assign(many, notCacheItems), nil
 }
 
 func (d *GoCacheDriver[V]) TTL(key string) (ttl time.Duration, err error) {

go_redis.go

@@ -159,30 +159,40 @@ func (d *RedisDriver[V]) Decrement(key string, n V) (ret V, err error) {
 	return
 }
 
-func (d *RedisDriver[V]) Remember(key string, ttl time.Duration, callback func() (V, error)) (result V, err error) {
-	if result, err = d.Get(key); err == nil {
-		return
-	} else {
-		if result, err = callback(); err != nil {
+func (d *RedisDriver[V]) Remember(key string, ttl time.Duration, callback func() (V, error), force bool) (result V, err error) {
+	if !force {
+		if result, err = d.Get(key); err == nil {
 			return
 		}
-		err = d.Set(key, result, ttl)
+	}
+	if result, err = callback(); err != nil {
 		return
 	}
+	err = d.Set(key, result, ttl)
+	return
 }
 
-func (d *RedisDriver[V]) RememberForever(key string, callback func() (V, error)) (V, error) {
-	return d.Remember(key, redis.KeepTTL, callback)
+func (d *RedisDriver[V]) RememberForever(key string, callback func() (V, error), force bool) (V, error) {
+	return d.Remember(key, redis.KeepTTL, callback, force)
 }
 
-func (d *RedisDriver[V]) RememberMany(keys []string, ttl time.Duration, callback func(notHitKeys []string) (map[string]V, error)) (map[string]V, error) {
-	many, err := d.Many(keys)
-	if err != nil {
-		return nil, err
-	}
-	notHitKeys := lo.Without(keys, lo.Keys(many)...)
-	if len(notHitKeys) == 0 {
-		return many, nil
+func (d *RedisDriver[V]) RememberMany(keys []string, ttl time.Duration, callback func(notHitKeys []string) (map[string]V, error), force bool) (map[string]V, error) {
+	var (
+		notHitKeys []string
+		err        error
+	)
+	many := make(map[string]V)
+	if !force {
+		many, err = d.Many(keys)
+		if err != nil {
+			return nil, err
+		}
+		notHitKeys = lo.Without(keys, lo.Keys(many)...)
+		if len(notHitKeys) == 0 {
+			return many, nil
+		}
+	} else {
+		notHitKeys = keys
 	}
 	notCacheItems, err := callback(notHitKeys)
 	if err != nil {