feat: use postgres

gateway/internal/session/redis.go

@@ -3,7 +3,6 @@ package session
 import (
 	"bytes"
 	"context"
-	"crypto/tls"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -32,68 +31,27 @@ type redisRecord struct {
 	RevokedAtMS     *int64 `json:"revoked_at_ms,omitempty"`
 }
 
-// NewRedisCache constructs a Redis-backed SessionCache from cfg. The returned
-// cache is read-only from the gateway perspective and does not write or mutate
-// Redis state.
-func NewRedisCache(cfg config.SessionCacheRedisConfig) (*RedisCache, error) {
-	if strings.TrimSpace(cfg.Addr) == "" {
-		return nil, errors.New("new redis session cache: redis addr must not be empty")
+// NewRedisCache constructs a Redis-backed SessionCache that uses client and
+// applies the namespace and timeout settings from cfg. The cache does not own
+// the client; the runtime supplies a shared *redis.Client.
+func NewRedisCache(client *redis.Client, cfg config.SessionCacheRedisConfig) (*RedisCache, error) {
+	if client == nil {
+		return nil, errors.New("new redis session cache: nil redis client")
 	}
-	if cfg.DB < 0 {
-		return nil, errors.New("new redis session cache: redis db must not be negative")
+	if strings.TrimSpace(cfg.KeyPrefix) == "" {
+		return nil, errors.New("new redis session cache: redis key prefix must not be empty")
 	}
 	if cfg.LookupTimeout <= 0 {
 		return nil, errors.New("new redis session cache: lookup timeout must be positive")
 	}
 
-	options := &redis.Options{
-		Addr:            cfg.Addr,
-		Username:        cfg.Username,
-		Password:        cfg.Password,
-		DB:              cfg.DB,
-		Protocol:        2,
-		DisableIdentity: true,
-	}
-	if cfg.TLSEnabled {
-		options.TLSConfig = &tls.Config{MinVersion: tls.VersionTLS12}
-	}
-
 	return &RedisCache{
-		client:        redis.NewClient(options),
+		client:        client,
 		keyPrefix:     cfg.KeyPrefix,
 		lookupTimeout: cfg.LookupTimeout,
 	}, nil
 }
 
-// Close releases the underlying Redis client resources.
-func (c *RedisCache) Close() error {
-	if c == nil || c.client == nil {
-		return nil
-	}
-
-	return c.client.Close()
-}
-
-// Ping verifies that the configured Redis backend is reachable within the
-// cache lookup timeout budget.
-func (c *RedisCache) Ping(ctx context.Context) error {
-	if c == nil || c.client == nil {
-		return errors.New("ping redis session cache: nil cache")
-	}
-	if ctx == nil {
-		return errors.New("ping redis session cache: nil context")
-	}
-
-	pingCtx, cancel := context.WithTimeout(ctx, c.lookupTimeout)
-	defer cancel()
-
-	if err := c.client.Ping(pingCtx).Err(); err != nil {
-		return fmt.Errorf("ping redis session cache: %w", err)
-	}
-
-	return nil
-}
-
 // Lookup resolves deviceSessionID from Redis, validates the cached JSON
 // payload strictly, and returns the decoded session record.
 func (c *RedisCache) Lookup(ctx context.Context, deviceSessionID string) (Record, error) {