feat(redis): add cluster-capable clients

backend/cmd/api/server.go

@@ -23,8 +23,8 @@ import (
 type serverConfig struct {
 	runtimeConfig      app.RuntimeConfig
 	jwtSigningKey      []byte
-	redisClient        *redis.Client
-	rateLimitRedis     *redis.Client
+	redisClient        redis.UniversalClient
+	rateLimitRedis     redis.UniversalClient
 	mockLogin          bool
 	ready              *atomic.Bool
 	sqlDB              *gorm.DB

backend/internal/app/health.go

@@ -11,7 +11,7 @@ import (
 	"gorm.io/gorm"
 )
 
-func RegisterHealthRoutes(e *echo.Echo, ready *atomic.Bool, sqlDB *gorm.DB, redisClient *redis.Client) {
+func RegisterHealthRoutes(e *echo.Echo, ready *atomic.Bool, sqlDB *gorm.DB, redisClient redis.UniversalClient) {
 	e.GET("/health", func(c echo.Context) error {
 		return c.JSON(http.StatusOK, map[string]string{"status": "healthy"})
 	})

backend/internal/app/health_server.go

@@ -17,7 +17,7 @@ const defaultHTTPPort = "8080"
 
 type HealthServerConfig struct {
 	Ready              *atomic.Bool
-	RedisClient        *redis.Client
+	RedisClient        redis.UniversalClient
 	ObservabilitySuite *observability.Suite
 	DBRouter           *db.Router
 	SQLDB              *gorm.DB

backend/internal/app/runtime.go

@@ -42,11 +42,11 @@ type Runtime struct {
 	Config                 RuntimeConfig
 	JWTSigningKey          []byte
 	MockLogin              bool
-	RedisClient            *redis.Client
-	RedisCoordination      *redis.Client
-	RedisCache             *redis.Client
-	RedisQueue             *redis.Client
-	RedisSessionContinuity *redis.Client
+	RedisClient            redis.UniversalClient
+	RedisCoordination      redis.UniversalClient
+	RedisCache             redis.UniversalClient
+	RedisQueue             redis.UniversalClient
+	RedisSessionContinuity redis.UniversalClient
 	ObservabilitySuite     *observability.Suite
 	DashboardService       *dashboardsvc.DashboardService
 	CollabDocumentService  *collabdoc.Service
@@ -214,14 +214,14 @@ func (r *Runtime) Close() error {
 	if r == nil {
 		return nil
 	}
-	clients := []*redis.Client{
+	clients := []redis.UniversalClient{
 		r.RedisClient,
 		r.RedisCoordination,
 		r.RedisCache,
 		r.RedisQueue,
 		r.RedisSessionContinuity,
 	}
-	seen := map[*redis.Client]struct{}{}
+	seen := map[redis.UniversalClient]struct{}{}
 	var firstErr error
 	for _, client := range clients {
 		if client == nil {

backend/internal/app/runtime_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/alicebob/miniredis/v2"
 	"github.com/glebarez/sqlite"
+	"github.com/redis/go-redis/v9"
 	"gorm.io/gorm"
 )
 
@@ -90,8 +91,12 @@ func TestNewRuntimeBuildsRedisRoleClientsWhenConfigured(t *testing.T) {
 	if runtime.RedisClient == nil || runtime.RedisCoordination == nil || runtime.RedisCache == nil || runtime.RedisQueue == nil || runtime.RedisSessionContinuity == nil {
 		t.Fatal("expected all redis role clients to be wired")
 	}
-	if runtime.RedisCoordination.Options().DialTimeout.String() != "500ms" {
-		t.Fatalf("expected coordination client baseline, got %s", runtime.RedisCoordination.Options().DialTimeout)
+	coordinationClient, ok := runtime.RedisCoordination.(*redis.Client)
+	if !ok {
+		t.Fatalf("expected coordination client to be a direct redis client, got %T", runtime.RedisCoordination)
+	}
+	if coordinationClient.Options().DialTimeout.String() != "500ms" {
+		t.Fatalf("expected coordination client baseline, got %s", coordinationClient.Options().DialTimeout)
 	}
 }
 

backend/internal/handlers/auth.go

@@ -26,13 +26,13 @@ import (
 
 type AuthHandler struct {
 	db                   *gorm.DB
-	redis                *redis.Client
+	redis                redis.UniversalClient
 	email                email.EmailService
 	jwtSigningKey        []byte
 	usernameLoginEnabled bool
 }
 
-func NewAuthHandler(db *gorm.DB, redis *redis.Client, email email.EmailService, jwtSigningKey []byte) *AuthHandler {
+func NewAuthHandler(db *gorm.DB, redis redis.UniversalClient, email email.EmailService, jwtSigningKey []byte) *AuthHandler {
 	return &AuthHandler{
 		db:            db,
 		redis:         redis,

backend/internal/middleware/rate_limit.go

@@ -32,7 +32,7 @@ var defaultRateLimitPolicyYAML []byte
 
 type RateLimitConfig struct {
 	Enabled     bool
-	RedisClient *redis.Client
+	RedisClient redis.UniversalClient
 	KeyPrefix   string
 	FailOpen    bool
 	guard       *redisdegrade.Guard
@@ -111,15 +111,15 @@ local ttl = redis.call("PTTL", KEYS[1])
 return { current, ttl }
 `
 
-func DefaultRateLimitConfig(client *redis.Client) RateLimitConfig {
+func DefaultRateLimitConfig(client redis.UniversalClient) RateLimitConfig {
 	policy, err := rateLimitPolicyFromYAML(defaultRateLimitPolicyYAML)
 	if err != nil {
 		panic(err)
 	}
 	return rateLimitConfigFromPolicy(client, policy)
 }
 
-func rateLimitConfigFromPolicy(client *redis.Client, policy rateLimitPolicy) RateLimitConfig {
+func rateLimitConfigFromPolicy(client redis.UniversalClient, policy rateLimitPolicy) RateLimitConfig {
 	return RateLimitConfig{
 		Enabled:     client != nil,
 		RedisClient: client,
@@ -149,7 +149,7 @@ func rateLimitConfigFromPolicy(client *redis.Client, policy rateLimitPolicy) Rat
 	}
 }
 
-func RateLimitConfigFromEnv(client *redis.Client) (RateLimitConfig, error) {
+func RateLimitConfigFromEnv(client redis.UniversalClient) (RateLimitConfig, error) {
 	policy, err := rateLimitPolicyFromYAML(defaultRateLimitPolicyYAML)
 	if err != nil {
 		return RateLimitConfig{}, err
@@ -342,7 +342,7 @@ func rateLimitCategory(method, route string) string {
 	}
 }
 
-func checkRateLimitBuckets(ctx context.Context, client *redis.Client, prefix string, guard *redisdegrade.Guard, buckets []rateLimitBucket) (rateLimitResult, error) {
+func checkRateLimitBuckets(ctx context.Context, client redis.UniversalClient, prefix string, guard *redisdegrade.Guard, buckets []rateLimitBucket) (rateLimitResult, error) {
 	var selected rateLimitResult
 	for _, bucket := range buckets {
 		current, ttl, err := incrementRateLimitBucket(ctx, client, guard, rateLimitRedisKey(prefix, bucket), bucket.Window)
@@ -370,7 +370,7 @@ func checkRateLimitBuckets(ctx context.Context, client *redis.Client, prefix str
 	return selected, nil
 }
 
-func incrementRateLimitBucket(ctx context.Context, client *redis.Client, guard *redisdegrade.Guard, key string, window time.Duration) (int64, time.Duration, error) {
+func incrementRateLimitBucket(ctx context.Context, client redis.UniversalClient, guard *redisdegrade.Guard, key string, window time.Duration) (int64, time.Duration, error) {
 	raw, err := redisdegrade.CallWork(guard, "rate_limit", func() (any, error) {
 		return client.Eval(ctx, redisRateLimitScript, []string{key}, window.Milliseconds()).Result()
 	})

backend/internal/pkg/streamgate/streamgate.go

@@ -75,7 +75,7 @@ func (l *Lease) Release(ctx context.Context) error {
 
 type Limiter struct {
 	config Config
-	redis  *redis.Client
+	redis  redis.UniversalClient
 	memory *memoryStore
 }
 
@@ -94,7 +94,7 @@ func (e *LimitError) Unwrap() error {
 	return ErrLimitExceeded
 }
 
-func New(redisClient *redis.Client, config Config) *Limiter {
+func New(redisClient redis.UniversalClient, config Config) *Limiter {
 	config = normalizeConfig(config)
 	if !config.Enabled {
 		return nil