feat: add Redis client and database session utilities

VuQuoc18 · VuQuoc18 · commit 5c45b810831f · 2025-11-20T19:33:40.000+07:00
diff --git a/backend/app/core/config.py b/backend/app/core/config.py
@@ -25,8 +25,8 @@ def parse_cors(v: Any) -> list[str] | str:
 
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
-        # Use top level .env file (one level above ./backend/)
-        env_file="../.env",
+        # Use top level .env file (one level above ./backend/), fallback to .env.dev
+        env_file=["../.env", "../.env.dev"],
         env_ignore_empty=True,
         extra="ignore",
     )
@@ -49,7 +49,13 @@ def all_cors_origins(self) -> list[str]:
         ]
 
     PROJECT_NAME: str
-    SENTRY_DSN: HttpUrl | None = None
+    # SENTRY_DSN: HttpUrl | None = None
+
+    # Redis Configuration
+    REDIS_URL: str = "redis://localhost:6379"
+    REDIS_PASSWORD: str | None = None
+    REDIS_DB: int = 0
+
     POSTGRES_SERVER: str
     POSTGRES_PORT: int = 5432
     POSTGRES_USER: str
@@ -94,6 +100,32 @@ def emails_enabled(self) -> bool:
     FIRST_SUPERUSER: EmailStr
     FIRST_SUPERUSER_PASSWORD: str
 
+    # AWS S3 Configuration
+    AWS_ACCESS_KEY_ID: str = "changethis"
+    AWS_SECRET_ACCESS_KEY: str = "changethis"
+    AWS_REGION: str = "us-east-1"
+    AWS_S3_BUCKET: str = "changethis"
+    AWS_S3_BUCKET_URL: HttpUrl | None = None
+
+    # CloudFront Configuration
+    AWS_CLOUDFRONT_DOMAIN: str | None = None
+    AWS_CLOUDFRONT_KEY_PAIR_ID: str | None = None
+    AWS_CLOUDFRONT_PRIVATE_KEY_PATH: str | None = None
+
+    # File Upload Configuration
+    MAX_FILE_SIZE: int = 50 * 1024 * 1024  # 50MB
+    ALLOWED_IMAGE_TYPES: list[str] = ["image/jpeg", "image/png", "image/webp", "image/gif"]
+    ALLOWED_IMAGE_EXTENSIONS: list[str] = ["jpg", "jpeg", "png", "webp", "gif"]
+
+    # Image Processing Configuration
+    IMAGE_VARIANT_LARGE_SIZE: int = 1200
+    IMAGE_VARIANT_MEDIUM_SIZE: int = 800
+    IMAGE_VARIANT_THUMB_SIZE: int = 300
+    IMAGE_QUALITY_LARGE: int = 85
+    IMAGE_QUALITY_MEDIUM: int = 85
+    IMAGE_QUALITY_THUMB: int = 75
+    IMAGE_MAX_DIMENSIONS: tuple[int, int] = (10000, 10000)  # Prevent DOS attacks
+
     def _check_default_secret(self, var_name: str, value: str | None) -> None:
         if value == "changethis":
             message = (
@@ -113,6 +145,12 @@ def _enforce_non_default_secrets(self) -> Self:
             "FIRST_SUPERUSER_PASSWORD", self.FIRST_SUPERUSER_PASSWORD
         )
 
+        # Only check AWS secrets in production
+        if self.ENVIRONMENT != "local":
+            self._check_default_secret("AWS_ACCESS_KEY_ID", self.AWS_ACCESS_KEY_ID)
+            self._check_default_secret("AWS_SECRET_ACCESS_KEY", self.AWS_SECRET_ACCESS_KEY)
+            self._check_default_secret("AWS_S3_BUCKET", self.AWS_S3_BUCKET)
+
         return self
 
 
diff --git a/backend/app/core/db.py b/backend/app/core/db.py
@@ -1,4 +1,5 @@
 from sqlmodel import Session, create_engine, select
+from contextlib import contextmanager
 
 from app import crud
 from app.core.config import settings
@@ -7,6 +8,39 @@
 engine = create_engine(str(settings.SQLALCHEMY_DATABASE_URI))
 
 
+def get_db_session():
+    """
+    Get a database session.
+
+    Returns:
+        Session: Database session object
+    """
+    return Session(engine)
+
+
+@contextmanager
+def get_db_context():
+    """
+    Context manager for database sessions.
+
+    Usage:
+        with get_db_context() as db:
+            # Database operations here
+
+    Yields:
+        Session: Database session object
+    """
+    session = Session(engine)
+    try:
+        yield session
+        session.commit()
+    except Exception:
+        session.rollback()
+        raise
+    finally:
+        session.close()
+
+
 # make sure all SQLModel models are imported (app.models) before initializing DB
 # otherwise, SQLModel might fail to initialize relationships properly
 # for more details: https://github.com/fastapi/full-stack-fastapi-template/issues/28
diff --git a/backend/app/core/redis.py b/backend/app/core/redis.py
@@ -0,0 +1,122 @@
+import redis
+from typing import Any, Optional
+import json
+import pickle
+from functools import wraps
+
+from app.core.config import settings
+
+
+class RedisClient:
+    def __init__(self):
+        self._client: Optional[redis.Redis] = None
+
+    @property
+    def client(self) -> redis.Redis:
+        if self._client is None:
+            self._client = redis.from_url(
+                settings.REDIS_URL,
+                password=settings.REDIS_PASSWORD,
+                db=settings.REDIS_DB,
+                decode_responses=False,  # Keep binary data for pickle
+                socket_connect_timeout=5,
+                socket_timeout=5,
+                retry_on_timeout=True,
+            )
+        return self._client
+
+    def ping(self) -> bool:
+        """Check Redis connection"""
+        try:
+            return bool(self.client.ping())
+        except redis.ConnectionError:
+            return False
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get value from Redis"""
+        try:
+            value = self.client.get(key)
+            if value is None:
+                return default
+            # Try to deserialize
+            try:
+                return pickle.loads(value)
+            except (pickle.PickleError, TypeError):
+                # Fallback to JSON or string
+                try:
+                    return json.loads(value.decode('utf-8'))
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    return value.decode('utf-8')
+        except redis.ConnectionError:
+            return default
+
+    def set(
+        self,
+        key: str,
+        value: Any,
+        expire: Optional[int] = None,
+        serialize: bool = True
+    ) -> bool:
+        """Set value in Redis"""
+        try:
+            if serialize:
+                serialized = pickle.dumps(value)
+            else:
+                serialized = str(value).encode('utf-8')
+
+            return bool(self.client.set(key, serialized, ex=expire))
+        except redis.ConnectionError:
+            return False
+
+    def delete(self, key: str) -> bool:
+        """Delete key from Redis"""
+        try:
+            return bool(self.client.delete(key))
+        except redis.ConnectionError:
+            return False
+
+    def exists(self, key: str) -> bool:
+        """Check if key exists"""
+        try:
+            return bool(self.client.exists(key))
+        except redis.ConnectionError:
+            return False
+
+    def flushdb(self) -> bool:
+        """Flush current database"""
+        try:
+            return bool(self.client.flushdb())
+        except redis.ConnectionError:
+            return False
+
+    def close(self):
+        """Close Redis connection"""
+        if self._client:
+            self._client.close()
+            self._client = None
+
+
+# Global Redis client instance
+redis_client = RedisClient()
+
+
+def cache_result(expire: int = 3600, key_prefix: str = ""):
+    """Decorator to cache function results"""
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Generate cache key
+            cache_key = f"{key_prefix}:{func.__name__}:{hash(str(args) + str(sorted(kwargs.items())))}"
+
+            # Try to get from cache
+            cached_result = redis_client.get(cache_key)
+            if cached_result is not None:
+                return cached_result
+
+            # Execute function and cache result
+            result = func(*args, **kwargs)
+            redis_client.set(cache_key, result, expire=expire)
+            return result
+
+        return wrapper
+    return decorator
