Refactor database handling and update configuration (#65)

- Updated README.md to reflect changes from SQL Database to generic Database terminology.
- Refactored app code to replace SQL database references with a more generic database implementation.
- Modified settings to remove SQL-specific configurations and streamline database settings.
- Adjusted dependencies to align with the new database session management.

Author: lucas-six

README.md

@@ -7,7 +7,7 @@ GitHub Actions, S3 compatible storage, AI APIs and more.
 ## Features
 
 - Virtual Environment support: `uv`
-- SQL Database support: `PostgreSQL`
+- Database support: `PostgreSQL`
 - Caching support: `Redis`
 - Task Queue support: `Celery`
 - Message Queue support: `RabbitMQ`
@@ -42,12 +42,11 @@ APP_ROOT_URL=/api
 APP_DESCRIPTION="FastAPI App description."
 DEBUG=true
 
-# SQL Database (PostgreSQL)
-SQL_DB_ENABLED=true
-SQL_DB_URL=postgresql+psycopg://postgres:postgres@localhost:5432/postgres
-SQL_DB_CONNECT_TIMEOUT=5.0
-SQL_DB_POOL_SIZE=10
-SQL_DB_POOL_TIMEOUT=5.0
+# Database (PostgreSQL)
+DB_URL=postgresql+psycopg://postgres:postgres@localhost:5432/postgres
+DB_CONNECT_TIMEOUT=5.0
+DB_POOL_SIZE=10
+DB_POOL_TIMEOUT=5.0
 
 # Cache (Redis)
 REDIS_URL=redis://:foobared@localhost:6379/0

app/app.py

@@ -17,7 +17,7 @@
 from sqlmodel.ext.asyncio.session import AsyncSession
 
 from app.db_models import TemplateDemo
-from app.dependencies import get_redis_session, get_sql_db_session
+from app.dependencies import get_db_session, get_redis_session
 from app.settings import get_settings
 from app.utils import pid_str
 from app.webhook import api as webhook_api
@@ -34,7 +34,7 @@
 
 
 class State(TypedDict):
-    sql_db_client: AsyncEngine | None
+    db_client: AsyncEngine
     redis_connection_pool: RedisConnectionPool
 
 
@@ -48,20 +48,18 @@ async def lifespan(_app: FastAPI) -> AsyncGenerator[dict[str, Any]]:
     client_name_str = f'{_app.title} [{_pid_str}]'.replace(' ', '-')
     logger.info(f'Starting {client_name_str}...')
 
-    sql_db_client = None
-    if settings.sql_db_enabled:
-        sql_db_client = create_async_engine(
-            settings.sql_db_url.encoded_string(),
-            pool_size=settings.sql_db_pool_size,
-            max_overflow=20,
-            pool_timeout=settings.sql_db_pool_timeout,
-            connect_args={
-                'application_name': client_name,
-                'connect_timeout': settings.sql_db_connect_timeout,
-            },
-            logging_name=_app.title,
-            echo=False,
-        )
+    db_client = create_async_engine(
+        settings.db_url.encoded_string(),
+        pool_size=settings.db_pool_size,
+        max_overflow=20,
+        pool_timeout=settings.db_pool_timeout,
+        connect_args={
+            'application_name': client_name,
+            'connect_timeout': settings.db_connect_timeout,
+        },
+        logging_name=_app.title,
+        echo=False,
+    )
 
     redis_connection_pool: RedisConnectionPool = RedisConnectionPool.from_url(
         url=settings.redis_url.encoded_string(),
@@ -74,14 +72,13 @@ async def lifespan(_app: FastAPI) -> AsyncGenerator[dict[str, Any]]:
     )
 
     yield {
-        'sql_db_client': sql_db_client,
+        'db_client': db_client,
         'redis_connection_pool': redis_connection_pool,
     }
 
     # Shutdown
-    if settings.sql_db_enabled and sql_db_client:
-        await sql_db_client.dispose()
-        logger.debug(f'SQL Database connection {client_name_str} disposing...')
+    await db_client.dispose()
+    logger.debug(f'Database connection {client_name_str} disposing...')
     await redis_connection_pool.disconnect()
     logger.debug(f'Redis connection pool {client_name_str} disconnected')
 
@@ -111,14 +108,14 @@ async def lifespan(_app: FastAPI) -> AsyncGenerator[dict[str, Any]]:
 @app.get(f'{settings.app_root_url}')
 async def root(
     request: Request,
-    sql_db_session: AsyncSession = Depends(get_sql_db_session),
+    db_session: AsyncSession = Depends(get_db_session),
     redis_session: Redis = Depends(get_redis_session),
 ) -> dict[str, str | bool | None]:
     logger.debug(f'Root endpoint [{await pid_str()}]...')
 
-    # SQL Database
-    message = await sql_db_session.exec(select(func.count(col(TemplateDemo.id))))
-    logger.debug(f'SQL Database message: {message.first()}')
+    # Database
+    message = await db_session.exec(select(func.count(col(TemplateDemo.id))))
+    logger.debug(f'Database message: {message.first()}')
 
     # Cache (Redis)
     cache_val = await redis_session.get(f'{settings.cache_prefix}')

app/dependencies.py

@@ -3,21 +3,18 @@
 from collections.abc import AsyncGenerator
 from typing import Any
 
-from fastapi import HTTPException, Request
+from fastapi import Request
 from redis.asyncio import ConnectionPool as RedisConnectionPool
 from redis.asyncio import Redis
 from sqlalchemy.ext.asyncio import AsyncEngine
 from sqlmodel.ext.asyncio.session import AsyncSession
 
 
-async def get_sql_db_session(request: Request) -> AsyncGenerator[AsyncSession, Any]:
-    """Get SQL Database session."""
-    sql_db_client: AsyncEngine | None = request.state.sql_db_client
-    if sql_db_client:
-        async with AsyncSession(sql_db_client) as session:
-            yield session
-    else:
-        raise HTTPException(status_code=500, detail='SQL Database connection not found')
+async def get_db_session(request: Request) -> AsyncGenerator[AsyncSession, Any]:
+    """Get Database session."""
+    db_client: AsyncEngine = request.state.db_client
+    async with AsyncSession(db_client) as session:
+        yield session
 
 
 async def get_redis_session(request: Request) -> AsyncGenerator[Redis, Any]:

app/settings.py

@@ -19,13 +19,12 @@ class Settings(BaseSettings):
     debug: bool = False
 
     # Database (PostgreSQL)
-    sql_db_enabled: bool = False
-    sql_db_url: PostgresDsn = PostgresDsn(
+    db_url: PostgresDsn = PostgresDsn(
         'postgresql+psycopg://postgres:postgres@localhost:5432/postgres'
     )
-    sql_db_connect_timeout: float = 5.0
-    sql_db_pool_size: int = 10
-    sql_db_pool_timeout: float = 5.0
+    db_connect_timeout: float = 5.0
+    db_pool_size: int = 10
+    db_pool_timeout: float = 5.0
 
     # Cache (Redis)
     redis_url: RedisDsn = RedisDsn('redis://:foobared@localhost:6379/0')

task/celery_worker.py

@@ -28,19 +28,22 @@
 resend.api_key = settings.resend_api_key.get_secret_value()
 
 client_name = f'{settings.app_name}-celery-{os.getpid()}'.replace(' ', '-')
-sql_db_engine = create_engine(
-    settings.sql_db_url.encoded_string(),
-    pool_size=settings.sql_db_pool_size,
+
+
+db_engine = create_engine(
+    settings.db_url.encoded_string(),
+    pool_size=settings.db_pool_size,
     max_overflow=20,
-    pool_timeout=settings.sql_db_pool_timeout,
+    pool_timeout=settings.db_pool_timeout,
     connect_args={
         'application_name': client_name,
-        'connect_timeout': settings.sql_db_connect_timeout,
+        'connect_timeout': settings.db_connect_timeout,
     },
     logging_name=client_name,
     echo=False,
 )
 
+
 redis_client = Redis.from_url(
     settings.redis_url.encoded_string(),
     encoding='utf-8',
@@ -136,7 +139,7 @@ def handle_resend_email_attachments_to_s3(
     ck_file_digest = f'{settings.cache_prefix}:file_digest_sha256'
     with (
         httpx.Client(timeout=download_timeout_config) as http_client,
-        SQLSession(sql_db_engine) as sql_session,
+        SQLSession(db_engine) as db_session,
     ):
         for attachment in attachment_list:
             attachment_id = attachment['id']
@@ -160,7 +163,7 @@ def handle_resend_email_attachments_to_s3(
                 Config=S3TransferConfig(multipart_threshold=settings.s3_multipart_threshold),
             )
 
-            sql_session.add(
+            db_session.add(
                 EmailAttachment(
                     webhook=EmailWebhookEnum.RESEND,
                     webhook_event_type=EmailWebhookEventTypeEnum.EMAIL_RECEIVED,
@@ -182,7 +185,7 @@ def handle_resend_email_attachments_to_s3(
 
             redis_client.hset(ck_file_digest, file_name, file_digest)
 
-        sql_session.commit()
+        db_session.commit()
 
     # Release the message lock
     redis_client.delete(ck_message_lock)
@@ -205,7 +208,7 @@ def handle_resend_email_received(
     ck_ai_files = f'{settings.cache_prefix}:ai:files'
     with (
         httpx.Client(timeout=download_timeout_config) as http_client,
-        SQLSession(sql_db_engine) as sql_session,
+        SQLSession(db_engine) as db_session,
     ):
         for attachment in attachment_list:
             attachment_id = attachment['id']
@@ -254,7 +257,7 @@ def handle_resend_email_received(
 
             ai_file_ids[file_name] = ai_file_id
 
-        sql_session.commit()
+        db_session.commit()
 
     # Release the message lock
     redis_client.delete(message_lock_ck)