refactor: Update imports and reorganize module structure for better organization

Author: Bit-Maximum

app/core/security.py

@@ -9,6 +9,7 @@
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
 
+# Algorithm use for encoding & decoding of JWT tokens
 ALGORITHM = "HS256"
 
 

app/tkq.py app/core/tkq.pyapp/tkq.py renamed to app/core/tkq.py

@@ -1 +1 @@
-"""DAO classes."""
+"""Data Access Objects (DAO) classes."""

app/db/dao/__init__.py

@@ -1,10 +1,22 @@
 from collections.abc import AsyncGenerator
 from typing import Annotated
 
+import jwt
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jwt.exceptions import InvalidTokenError
+from pydantic import ValidationError
 from sqlalchemy.ext.asyncio import AsyncSession
 from starlette.requests import Request
 from taskiq import TaskiqDepends
 
+from app.core import security
+from app.core.config import settings
+from app.db.models.jwt_token import TokenPayload
+from app.db.models.users import User
+
+reusable_oauth2 = OAuth2PasswordBearer(tokenUrl=f"{settings.API_BASE_PATH}/login/access-token")
+
 
 async def get_db_session(
     request: Annotated[Request, TaskiqDepends()],
@@ -22,3 +34,61 @@ async def get_db_session(
     finally:
         await session.commit()
         await session.close()
+
+
+SessionDep = Annotated[AsyncSession, Depends(get_db_session)]
+TokenDep = Annotated[str, Depends(reusable_oauth2)]
+
+
+async def get_current_user(session: SessionDep, token: TokenDep) -> User:
+    """
+    Retrieve the currently authenticated user from the database based on the JWT token.
+
+    Args:
+        session: Database session dependency.
+        token: JWT bearer token dependency.
+
+    Returns:
+        The User object corresponding to the token subject.
+
+    Raises:
+        HTTPException: If the token is invalid, user does not exist, or is inactive.
+    """
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[security.ALGORITHM])
+        token_data = TokenPayload(**payload)
+    except (InvalidTokenError, ValidationError) as err:
+        # Raised if token is tampered, expired, or payload is malformed
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Could not validate credentials",
+        ) from err
+
+    user: User | None = await session.get(User, token_data.sub)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    if not user.is_active:
+        raise HTTPException(status_code=400, detail="Inactive user")
+
+    return user
+
+
+CurrentUser = Annotated[User, Depends(get_current_user)]
+
+
+async def get_current_active_superuser(current_user: CurrentUser) -> User:
+    """
+    Ensure that the current user has superuser privileges.
+
+    Args:
+        current_user: The currently authenticated user dependency.
+
+    Returns:
+        The current user if they are a superuser.
+
+    Raises:
+        HTTPException: If the user is not a superuser.
+    """
+    if not current_user.is_superuser:
+        raise HTTPException(status_code=403, detail="The user doesn't have enough privileges")
+    return current_user

app/db/dependencies.py

@@ -1,4 +1,4 @@
-"""app models."""
+"""Application models."""
 
 import pkgutil
 from pathlib import Path

app/db/models/__init__.py

@@ -24,11 +24,10 @@
 from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
 
 from app.core.config import settings
-from app.core.logger import configure_logging
+from app.core.tkq import broker
 from app.services.kafka.lifespan import init_kafka, shutdown_kafka
 from app.services.rabbit.lifespan import init_rabbit, shutdown_rabbit
 from app.services.redis.lifespan import init_redis, shutdown_redis
-from app.tkq import broker
 
 
 def _setup_db(app: FastAPI) -> None:  # pragma: no cover
@@ -44,6 +43,7 @@ def _setup_db(app: FastAPI) -> None:  # pragma: no cover
     engine = create_async_engine(str(settings.db_url), echo=settings.DB_ECHO)
     session_factory = async_sessionmaker(
         engine,
+        # See https://fastapi-users.github.io/fastapi-users/latest/configuration/databases/sqlalchemy/#asynchronous-driver
         expire_on_commit=False,
     )
     app.state.db_engine = engine
@@ -148,7 +148,6 @@ async def lifespan_setup(
     app.middleware_stack = None
     if not broker.is_worker_process:
         await broker.startup()
-    configure_logging()
     _setup_db(app)
     setup_opentelemetry(app)
     init_redis(app)

app/db/utils.py app/db/setup.pyapp/db/utils.py renamed to app/db/setup.py

@@ -23,7 +23,7 @@
 from app.db.dependencies import get_db_session
 from app.db.meta import meta
 from app.db.models import load_all_models
-from app.db.utils import create_database, drop_database
+from app.db.setup import create_database, drop_database
 from app.services.kafka.dependencies import get_kafka_producer
 from app.services.kafka.lifespan import init_kafka, shutdown_kafka
 from app.services.rabbit.dependencies import get_rmq_channel_pool