.github/workflows/lint.yml

@@ -21,7 +21,7 @@ jobs:
         with:
           go-version: stable
 
-      - uses: bufbuild/buf-setup-action@v1.45.0
+      - uses: bufbuild/buf-setup-action@v1.48.0
       - run: buf generate
 
       - name: golangci-lint

.github/workflows/test.yml

@@ -12,7 +12,7 @@ jobs:
     name: "go test"
     strategy:
       matrix:
-        go-version: [ 1.21.x, 1.22.x, 1.23.x ]
+        go-version: [ 1.22.x, 1.23.x ]
         platform: [ ubuntu-latest ]
         mysql-version: ['mysql:latest', 'mysql:5.7']
     runs-on: ${{ matrix.platform }}
@@ -51,7 +51,7 @@ jobs:
       - run: go version
 
       - name: Run Buf
-        uses: bufbuild/buf-setup-action@v1.45.0
+        uses: bufbuild/buf-setup-action@v1.48.0
       - run: |
           buf --version
           buf generate
@@ -60,6 +60,6 @@ jobs:
         run: go test ./... -v -covermode=atomic -race -coverprofile=coverage.txt
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}

README.md

@@ -1,6 +1,6 @@
 # Go Kratos Components
 
-![Supported Go Versions](https://img.shields.io/badge/Go-%3E%3D1.21-blue)
+![Supported Go Versions](https://img.shields.io/badge/Go-%3E%3D1.22.10-blue)
 [![Package Version](https://badgen.net/github/release/go-kratos-ecosystem/components/stable)](https://github.com/go-kratos-ecosystem/components/releases)
 [![GoDoc](https://pkg.go.dev/badge/github.com/go-kratos-ecosystem/v2)](https://pkg.go.dev/github.com/go-kratos-ecosystem/components/v2)
 [![codecov](https://codecov.io/gh/go-kratos-ecosystem/components/graph/badge.svg?token=QPTHZ5L9GT)](https://codecov.io/gh/go-kratos-ecosystem/components)

buf.gen.yaml

@@ -1,8 +1,8 @@
 version: v2
 plugins:
   - remote: buf.build/protocolbuffers/go
-    out: genproto
+    out: internal/genproto
     opt: paths=source_relative
   - remote: buf.build/grpc/go
-    out: genproto
+    out: internal/
     opt: paths=source_relative

buf.yaml

@@ -1,6 +1,6 @@
 version: v2
 modules:
-  - path: proto
+  - path: internal/proto
 deps:
   - buf.build/bufbuild/protovalidate
 lint:

cache/redis/store.go

@@ -2,6 +2,8 @@ package redis
 
 import (
 	"context"
+	"errors"
+	"strings"
 	"time"
 
 	"github.com/redis/go-redis/v9"
@@ -10,7 +12,7 @@ import (
 	"github.com/go-kratos-ecosystem/components/v2/codec"
 	"github.com/go-kratos-ecosystem/components/v2/codec/json"
 	"github.com/go-kratos-ecosystem/components/v2/locker"
-	redisLocker "github.com/go-kratos-ecosystem/components/v2/locker/redis"
+	redislocker "github.com/go-kratos-ecosystem/components/v2/locker/redis"
 )
 
 type Store struct {
@@ -29,7 +31,11 @@ type Option func(*options)
 func Prefix(prefix string) Option {
 	return func(o *options) {
 		if prefix != "" {
-			o.prefix = prefix + ":"
+			if !strings.HasSuffix(prefix, ":") {
+				o.prefix = prefix + ":"
+			} else {
+				o.prefix = prefix
+			}
 		}
 	}
 }
@@ -72,6 +78,9 @@ func (s *Store) Has(ctx context.Context, key string) (bool, error) {
 func (s *Store) Get(ctx context.Context, key string, dest any) error {
 	r := s.redis.Get(ctx, s.opts.prefix+key)
 	if r.Err() != nil {
+		if errors.Is(r.Err(), redis.Nil) {
+			return cache.ErrNotFound
+		}
 		return r.Err()
 	}
 
@@ -161,8 +170,8 @@ func (s *Store) Add(ctx context.Context, key string, value any, ttl time.Duratio
 }
 
 func (s *Store) Lock(key string, ttl time.Duration) locker.Locker {
-	return redisLocker.NewLocker(s.redis,
-		redisLocker.WithName(s.opts.prefix+key),
-		redisLocker.WithTTL(ttl),
+	return redislocker.NewLocker(s.redis,
+		redislocker.WithName(s.opts.prefix+key),
+		redislocker.WithTTL(ttl),
 	)
 }

cache/redis/store_test.go

@@ -11,19 +11,34 @@ import (
 	"github.com/redis/go-redis/v9"
 	"github.com/stretchr/testify/assert"
 
+	"github.com/go-kratos-ecosystem/components/v2/cache"
 	"github.com/go-kratos-ecosystem/components/v2/codec/json"
 	"github.com/go-kratos-ecosystem/components/v2/locker"
 )
 
-func createRedis() redis.UniversalClient {
-	return redis.NewClient(&redis.Options{
+var ctx = context.Background()
+
+func createRedis(t *testing.T) redis.UniversalClient {
+	client := redis.NewClient(&redis.Options{
 		Addr: ":6379",
 	})
+	t.Cleanup(func() {
+		client.FlushAll(ctx)
+	})
+	return client
+}
+
+func TestRedis_Prefix(t *testing.T) {
+	opt := &options{}
+	Prefix("cache:test")(opt)
+	assert.Equal(t, "cache:test:", opt.prefix)
+
+	Prefix("cache:test:")(opt)
+	assert.Equal(t, "cache:test:", opt.prefix)
 }
 
 func TestRedis_Base(t *testing.T) {
-	store := New(createRedis(), Prefix("cache:redis"), Codec(json.Codec))
-	ctx := context.Background()
+	store := New(createRedis(t), Prefix("cache:redis"), Codec(json.Codec))
 
 	ok1, err := store.Put(ctx, "test", "test", time.Second)
 	assert.Nil(t, err)
@@ -45,8 +60,7 @@ func TestRedis_Base(t *testing.T) {
 }
 
 func TestRedis_IncrAndDecr(t *testing.T) {
-	store := New(createRedis(), Prefix("cache:redis"))
-	ctx := context.Background()
+	store := New(createRedis(t), Prefix("cache:redis"))
 
 	_, err := store.Forget(ctx, "test:inc")
 	assert.Nil(t, err)
@@ -62,12 +76,25 @@ func TestRedis_IncrAndDecr(t *testing.T) {
 	v3, err := store.Decrement(ctx, "test:inc", 1)
 	assert.Nil(t, err)
 	assert.Equal(t, 10, v3)
+
+	// put another type
+	ok1, err := store.Put(ctx, "test:inc:type", "test", time.Second*3)
+	assert.Nil(t, err)
+	assert.True(t, ok1)
+
+	v4, err := store.Increment(ctx, "test:inc:type", 1)
+	t.Log(err)
+	assert.Error(t, err)
+	assert.Zero(t, v4)
+
+	v5, err := store.Decrement(ctx, "test:inc:type", 1)
+	assert.Error(t, err)
+	assert.Zero(t, v5)
 }
 
 func TestRedis_Forever(t *testing.T) {
-	client := createRedis()
-	store := New(createRedis(), Prefix("cache:redis"))
-	ctx := context.Background()
+	client := createRedis(t)
+	store := New(createRedis(t), Prefix("cache:redis"))
 
 	ok1, err := store.Forever(ctx, "test:forever", "test")
 	assert.Nil(t, err)
@@ -80,8 +107,7 @@ func TestRedis_Forever(t *testing.T) {
 }
 
 func TestRedis_Flush(t *testing.T) {
-	store := New(createRedis(), Prefix("cache:redis"))
-	ctx := context.Background()
+	store := New(createRedis(t), Prefix("cache:redis"))
 
 	ok1, err := store.Put(ctx, "test:flush", "test", time.Second)
 	assert.Nil(t, err)
@@ -92,13 +118,12 @@ func TestRedis_Flush(t *testing.T) {
 	assert.True(t, ok2)
 
 	ok3, err := store.Has(ctx, "test:flush")
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.False(t, ok3)
 }
 
 func TestRedis_Add(t *testing.T) {
-	store := New(createRedis(), Prefix("cache:redis"))
-	ctx := context.Background()
+	store := New(createRedis(t), Prefix("cache:redis"))
 
 	ok1, err := store.Add(ctx, "test:add", "test", time.Second)
 	assert.Nil(t, err)
@@ -115,7 +140,7 @@ func TestRedis_Add(t *testing.T) {
 }
 
 func TestRedis_Lock(t *testing.T) {
-	r := New(createRedis())
+	r := New(createRedis(t))
 	var wg sync.WaitGroup
 	var s int64
 
@@ -136,3 +161,18 @@ func TestRedis_Lock(t *testing.T) {
 	wg.Wait()
 	assert.True(t, s > 0)
 }
+
+func TestRedis_ErrNotFound(t *testing.T) {
+	store := New(createRedis(t), Prefix("cache:redis:notfound"))
+
+	// Has
+	ok1, err := store.Has(ctx, "test:notfound:has")
+	assert.Nil(t, err)
+	assert.False(t, ok1)
+
+	// Get
+	var v string
+	err = store.Get(ctx, "test:notfound:get", &v)
+	assert.True(t, errors.Is(err, cache.ErrNotFound))
+	assert.Empty(t, v)
+}

cache/repository.go

@@ -3,8 +3,6 @@ package cache
 import (
 	"context"
 	"time"
-
-	"github.com/go-kratos-ecosystem/components/v2/helpers"
 )
 
 type Repository interface {
@@ -14,7 +12,6 @@ type Repository interface {
 	Missing(ctx context.Context, key string) (bool, error)
 	Delete(ctx context.Context, key string) (bool, error)
 	Set(ctx context.Context, key string, value any, ttl time.Duration) (bool, error)
-	Remember(ctx context.Context, key string, dest any, value func() any, ttl time.Duration) error
 }
 
 type repository struct {
@@ -63,24 +60,3 @@ func (r *repository) Delete(ctx context.Context, key string) (bool, error) {
 func (r *repository) Set(ctx context.Context, key string, value any, ttl time.Duration) (bool, error) {
 	return r.Put(ctx, key, value, ttl)
 }
-
-func (r *repository) Remember(
-	ctx context.Context,
-	key string, dest any,
-	value func() any,
-	ttl time.Duration,
-) error {
-	if missing, err := r.Missing(ctx, key); err != nil {
-		return err
-	} else if missing {
-		v := value()
-
-		if _, err := r.Set(ctx, key, v, ttl); err != nil {
-			return err
-		}
-
-		return helpers.Scan(v, dest)
-	}
-
-	return r.Get(ctx, key, dest)
-}

cache/repository_test.go

@@ -79,9 +79,4 @@ func TestRepository(t *testing.T) {
 	set, err := repo.Set(ctx, "test", "test", 0)
 	assert.Nil(t, err)
 	assert.True(t, set)
-
-	// Remember
-	assert.Nil(t, repo.Remember(ctx, "test", nil, func() any {
-		return "test"
-	}, 0))
 }

cache/snapshot.go

@@ -0,0 +1,53 @@
+package cache
+
+import "sync"
+
+type Snapshot[K comparable, V any] struct {
+	mu   sync.RWMutex
+	data map[K]V
+}
+
+func (s *Snapshot[K, V]) Lookup(key K, fn func() V) V {
+	s.mu.RLock()
+	v, ok := s.data[key]
+	s.mu.RUnlock()
+	if !ok {
+		s.mu.Lock()
+		defer s.mu.Unlock()
+		if s.data == nil {
+			s.data = make(map[K]V)
+		}
+
+		if v, ok = s.data[key]; !ok {
+			v = fn()
+			s.data[key] = v
+		}
+	}
+	return v
+}
+
+type SnapshotWithErr[K comparable, V any] Snapshot[K, valueWithError[V]]
+
+type valueWithError[V any] struct {
+	value V
+	err   error
+}
+
+func (c *SnapshotWithErr[K, V]) Lookup(key K, fn func() (V, error)) (V, error) {
+	c.mu.RLock()
+	v, ok := c.data[key]
+	c.mu.RUnlock()
+	if !ok {
+		c.mu.Lock()
+		defer c.mu.Unlock()
+		if c.data == nil {
+			c.data = make(map[K]valueWithError[V])
+		}
+
+		if v, ok = c.data[key]; !ok {
+			v.value, v.err = fn()
+			c.data[key] = v
+		}
+	}
+	return v.value, v.err
+}