refactor(factory,resolver): wire Redis Cluster backend; split backend resolver to reduce complexity; format and fix lints

Author: hyp3rd

README.md

@@ -21,6 +21,7 @@ It ships with a default [historigram stats collector](./pkg/stats/stats.go) and
 - Supports multiple, custom backends. Default backends are:
     1. [In-memory](./pkg/backend/inmemory.go)
     2. [Redis](./pkg/backend/redis.go)
+    3. [Redis Cluster](./pkg/backend/redis_cluster.go)
 - Store items in the cache with a key and expiration duration
 - Retrieve items from the cache by their key
 - Delete items from the cache by their key

config.go

@@ -26,6 +26,8 @@ type Config[T backend.IBackendConstrain] struct {
 	InMemoryOptions []backend.Option[backend.InMemory]
 	// RedisOptions is a slice of options that can be used to configure the `Redis`.
 	RedisOptions []backend.Option[backend.Redis]
+	// RedisClusterOptions is a slice of options to configure the `RedisCluster` backend.
+	RedisClusterOptions []backend.Option[backend.RedisCluster]
 	// HyperCacheOptions is a slice of options that can be used to configure `HyperCache`.
 	HyperCacheOptions []Option[T]
 }
@@ -46,9 +48,10 @@ func NewConfig[T backend.IBackendConstrain](backendType string) *Config[T] {
 	}
 
 	return &Config[T]{
-		BackendType:     backendType,
-		InMemoryOptions: []backend.Option[backend.InMemory]{},
-		RedisOptions:    []backend.Option[backend.Redis]{},
+		BackendType:         backendType,
+		InMemoryOptions:     []backend.Option[backend.InMemory]{},
+		RedisOptions:        []backend.Option[backend.Redis]{},
+		RedisClusterOptions: []backend.Option[backend.RedisCluster]{},
 		HyperCacheOptions: []Option[T]{
 			WithExpirationInterval[T](constants.DefaultExpirationInterval),
 			WithEvictionAlgorithm[T]("lfu"),

factory.go

@@ -27,6 +27,14 @@ func (RedisBackendConstructor) Create(cfg *Config[backend.Redis]) (backend.IBack
 	return backend.NewRedis(cfg.RedisOptions...)
 }
 
+// RedisClusterBackendConstructor constructs Redis Cluster backends.
+type RedisClusterBackendConstructor struct{}
+
+// Create creates a new Redis Cluster backend.
+func (RedisClusterBackendConstructor) Create(cfg *Config[backend.RedisCluster]) (backend.IBackend[backend.RedisCluster], error) {
+	return backend.NewRedisCluster(cfg.RedisClusterOptions...)
+}
+
 // BackendManager is a factory for creating HyperCache backend instances.
 // It maintains a registry of backend constructors. We store them as any internally,
 // and cast to the typed constructor at use site based on T.
@@ -37,8 +45,9 @@ type BackendManager struct {
 // getDefaultBackends returns the default set of backend constructors.
 func getDefaultBackends() map[string]any {
 	return map[string]any{
-		constants.InMemoryBackend: InMemoryBackendConstructor{},
-		constants.RedisBackend:    RedisBackendConstructor{},
+		constants.InMemoryBackend:     InMemoryBackendConstructor{},
+		constants.RedisBackend:        RedisBackendConstructor{},
+		constants.RedisClusterBackend: RedisClusterBackendConstructor{},
 	}
 }
 

hypercache.go

@@ -158,51 +158,80 @@ func resolveBackend[T backend.IBackendConstrain](bm *BackendManager, config *Con
 
 	switch config.BackendType {
 	case constants.InMemoryBackend:
-		inMemoryConstructor, ok := constructor.(InMemoryBackendConstructor)
-		if !ok {
-			return nil, sentinel.ErrInvalidBackendType
-		}
+		return resolveInMemoryBackend[T](constructor, config)
+	case constants.RedisBackend:
+		return resolveRedisBackend[T](constructor, config)
+	case constants.RedisClusterBackend:
+		return resolveRedisClusterBackend[T](constructor, config)
+	default:
+		return nil, ewrap.Newf("unknown backend type: %s", config.BackendType)
+	}
+}
 
-		cfg, ok := any(config).(*Config[backend.InMemory])
-		if !ok {
-			return nil, sentinel.ErrInvalidBackendType
-		}
+// castBackend tries to cast a backend instance of any concrete type to backend.IBackend[T].
+func castBackend[T backend.IBackendConstrain](bi any) (backend.IBackend[T], error) {
+	if b, ok := bi.(backend.IBackend[T]); ok {
+		return b, nil
+	}
 
-		bi, err := inMemoryConstructor.Create(cfg)
-		if err != nil {
-			return nil, err
-		}
+	return nil, sentinel.ErrInvalidBackendType
+}
 
-		if b, ok := any(bi).(backend.IBackend[T]); ok {
-			return b, nil
-		}
+func resolveInMemoryBackend[T backend.IBackendConstrain](constructor any, cfgAny any) (backend.IBackend[T], error) {
+	inMemCtor, ok := constructor.(InMemoryBackendConstructor)
+	if !ok {
+		return nil, sentinel.ErrInvalidBackendType
+	}
 
+	cfg, ok := cfgAny.(*Config[backend.InMemory])
+	if !ok {
 		return nil, sentinel.ErrInvalidBackendType
+	}
 
-	case constants.RedisBackend:
-		redisConstructor, ok := constructor.(RedisBackendConstructor)
-		if !ok {
-			return nil, sentinel.ErrInvalidBackendType
-		}
+	bi, err := inMemCtor.Create(cfg)
+	if err != nil {
+		return nil, err
+	}
 
-		cfg, ok := any(config).(*Config[backend.Redis])
-		if !ok {
-			return nil, sentinel.ErrInvalidBackendType
-		}
+	return castBackend[T](bi)
+}
 
-		bi, err := redisConstructor.Create(cfg)
-		if err != nil {
-			return nil, err
-		}
+func resolveRedisBackend[T backend.IBackendConstrain](constructor any, cfgAny any) (backend.IBackend[T], error) {
+	redisCtor, ok := constructor.(RedisBackendConstructor)
+	if !ok {
+		return nil, sentinel.ErrInvalidBackendType
+	}
 
-		if b, ok := any(bi).(backend.IBackend[T]); ok {
-			return b, nil
-		}
+	cfg, ok := cfgAny.(*Config[backend.Redis])
+	if !ok {
+		return nil, sentinel.ErrInvalidBackendType
+	}
+
+	bi, err := redisCtor.Create(cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	return castBackend[T](bi)
+}
 
+func resolveRedisClusterBackend[T backend.IBackendConstrain](constructor any, cfgAny any) (backend.IBackend[T], error) {
+	clusterCtor, ok := constructor.(RedisClusterBackendConstructor)
+	if !ok {
 		return nil, sentinel.ErrInvalidBackendType
 	}
 
-	return nil, ewrap.Newf("unknown backend type: %s", config.BackendType)
+	cfg, ok := cfgAny.(*Config[backend.RedisCluster])
+	if !ok {
+		return nil, sentinel.ErrInvalidBackendType
+	}
+
+	bi, err := clusterCtor.Create(cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	return castBackend[T](bi)
 }
 
 // newHyperCacheBase builds the base HyperCache instance with default timings and internals.

internal/constants/config.go

@@ -27,4 +27,8 @@ const (
 	// Constant identifier for the Redis storage backend implementation
 	// that persists cache data in a Redis database server.
 	RedisBackend = "redis"
+	// RedisClusterBackend is the name of the Redis Cluster backend.
+	// Constant identifier for the Redis Cluster storage backend implementation
+	// that persists cache data across a Redis Cluster.
+	RedisClusterBackend = "redis-cluster"
 )