chore: update session and challenge repo -- using Redis for caching session and challenge verifying -- added api handler docs

internal/repository/cache/challenge_repo.go

@@ -0,0 +1,80 @@
+package cache
+
+import (
+	"backend/internal/domain"
+	"backend/pkg/cache"
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/redis/go-redis/v9"
+)
+
+type ChallengeRepository struct {
+	redis *cache.Redis
+}
+
+func NewChallengeRepository(redis *cache.Redis) domain.ChallengeRepo {
+	return &ChallengeRepository{
+		redis: redis,
+	}
+}
+
+func (r *ChallengeRepository) Create(ctx context.Context, pubKey string, challenge *domain.Challenge) error {
+	key := r.getChallengeKey(pubKey)
+
+	challengeData, err := json.Marshal(challenge)
+	if err != nil {
+		return fmt.Errorf("failed to marshal challenge: %w", err)
+	}
+
+	ttl := time.Until(challenge.ExpiresAt)
+	if ttl <= 0 {
+		return fmt.Errorf("challenge already expired")
+	}
+
+	if err := r.redis.Client().Set(ctx, key, challengeData, ttl).Err(); err != nil {
+		return fmt.Errorf("failed to store challenge in Redis: %w", err)
+	}
+
+	return nil
+}
+
+func (r *ChallengeRepository) GetByPubKey(ctx context.Context, pubKey string) (*domain.Challenge, error) {
+	key := r.getChallengeKey(pubKey)
+
+	result, err := r.redis.Client().Get(ctx, key).Result()
+	if err != nil {
+		if err == redis.Nil {
+			return nil, fmt.Errorf("challenge not found")
+		}
+		return nil, fmt.Errorf("failed to get challenge from Redis: %w", err)
+	}
+
+	var challenge domain.Challenge
+	if err := json.Unmarshal([]byte(result), &challenge); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal challenge: %w", err)
+	}
+
+	if challenge.IsExpired() {
+		r.Delete(ctx, pubKey)
+		return nil, fmt.Errorf("challenge expired")
+	}
+
+	return &challenge, nil
+}
+
+func (r *ChallengeRepository) Delete(ctx context.Context, pubKey string) error {
+	key := r.getChallengeKey(pubKey)
+
+	if err := r.redis.Client().Del(ctx, key).Err(); err != nil {
+		return fmt.Errorf("failed to delete challenge from Redis: %w", err)
+	}
+
+	return nil
+}
+
+func (r *ChallengeRepository) getChallengeKey(pubKey string) string {
+	return fmt.Sprintf("challenge:%s", pubKey)
+}

internal/repository/cache/session_repo.go

@@ -0,0 +1,135 @@
+package cache
+
+import (
+	"backend/internal/domain"
+	"backend/pkg/cache"
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/redis/go-redis/v9"
+)
+
+type SessionRepository struct {
+	redis *cache.Redis
+}
+
+func NewSessionRepository(redis *cache.Redis) domain.SessionRepo {
+	return &SessionRepository{
+		redis: redis,
+	}
+}
+
+func (r *SessionRepository) Create(ctx context.Context, session *domain.UserSession) error {
+	key := r.getSessionKey(session.ID)
+
+	sessionData, err := json.Marshal(session)
+	if err != nil {
+		return fmt.Errorf("failed to marshal session: %w", err)
+	}
+
+	ttl := time.Until(session.ExpiresAt)
+	if ttl <= 0 {
+		return fmt.Errorf("session already expired")
+	}
+
+	if err := r.redis.Client().Set(ctx, key, sessionData, ttl).Err(); err != nil {
+		return fmt.Errorf("failed to store session in Redis: %w", err)
+	}
+
+	userSessionsKey := r.getUserSessionsKey(session.UserID)
+	if err := r.redis.Client().SAdd(ctx, userSessionsKey, session.ID.String()).Err(); err != nil {
+		return fmt.Errorf("failed to add session to user sessions set: %w", err)
+	}
+
+	if err := r.redis.Client().Expire(ctx, userSessionsKey, ttl).Err(); err != nil {
+		return fmt.Errorf("failed to set TTL for user sessions set: %w", err)
+	}
+
+	return nil
+}
+
+func (r *SessionRepository) GetByID(ctx context.Context, id uuid.UUID) (*domain.UserSession, error) {
+	key := r.getSessionKey(id)
+
+	result, err := r.redis.Client().Get(ctx, key).Result()
+	if err != nil {
+		if err == redis.Nil {
+			return nil, fmt.Errorf("session not found")
+		}
+		return nil, fmt.Errorf("failed to get session from Redis: %w", err)
+	}
+
+	var session domain.UserSession
+	if err := json.Unmarshal([]byte(result), &session); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal session: %w", err)
+	}
+
+	if time.Now().After(session.ExpiresAt) {
+		r.Delete(ctx, id)
+		return nil, fmt.Errorf("session expired")
+	}
+
+	return &session, nil
+}
+
+func (r *SessionRepository) Delete(ctx context.Context, id uuid.UUID) error {
+	key := r.getSessionKey(id)
+
+	session, err := r.GetByID(ctx, id)
+	if err != nil {
+		return nil
+	}
+
+	if err := r.redis.Client().Del(ctx, key).Err(); err != nil {
+		return fmt.Errorf("failed to delete session from Redis: %w", err)
+	}
+
+	userSessionsKey := r.getUserSessionsKey(session.UserID)
+	if err := r.redis.Client().SRem(ctx, userSessionsKey, id.String()).Err(); err != nil {
+		return fmt.Errorf("failed to remove session from user sessions set: %w", err)
+	}
+
+	return nil
+}
+
+func (r *SessionRepository) GetUserSessions(ctx context.Context, userID uuid.UUID) ([]domain.UserSession, error) {
+	userSessionsKey := r.getUserSessionsKey(userID)
+
+	sessionIDs, err := r.redis.Client().SMembers(ctx, userSessionsKey).Result()
+	if err != nil {
+		if err == redis.Nil {
+			return []domain.UserSession{}, nil
+		}
+		return nil, fmt.Errorf("failed to get user sessions from Redis: %w", err)
+	}
+
+	var sessions []domain.UserSession
+	for _, sessionIDStr := range sessionIDs {
+		sessionID, err := uuid.Parse(sessionIDStr)
+		if err != nil {
+			r.redis.Client().SRem(ctx, userSessionsKey, sessionIDStr)
+			continue
+		}
+
+		session, err := r.GetByID(ctx, sessionID)
+		if err != nil {
+			r.redis.Client().SRem(ctx, userSessionsKey, sessionIDStr)
+			continue
+		}
+
+		sessions = append(sessions, *session)
+	}
+
+	return sessions, nil
+}
+
+func (r *SessionRepository) getSessionKey(sessionID uuid.UUID) string {
+	return fmt.Sprintf("session:%s", sessionID.String())
+}
+
+func (r *SessionRepository) getUserSessionsKey(userID uuid.UUID) string {
+	return fmt.Sprintf("user_sessions:%s", userID.String())
+}