fix: change relationships between models and add some models optimize style

Author: RustamovAkrom

src/db/crud/base.py docs/models.mdsrc/db/crud/base.py renamed to docs/models.md

@@ -12,7 +12,6 @@
     RegistrationScheme,
     TokenScheme,
 )
-from schemas.user import UserCreateScheme
 from services.auth_service import AuthService
 from services.password_service import PasswordService, get_password_service
 
@@ -25,11 +24,11 @@ async def get_auth_service(
     return AuthService(session)
 
 
-@router.post("/register", response_model=UserCreateScheme)
+@router.post("/register", response_model=RegisterOutScheme)
 async def register_user(
     data: RegistrationScheme,
     auth_service: AuthService = Depends(get_auth_service),
-) -> RegisterOutScheme:
+):
     """
     User registration endpoint
     """
@@ -40,7 +39,7 @@ async def register_user(
 async def login_user(
     data: LoginScheme,
     auth_service: AuthService = Depends(get_auth_service),
-) -> LoginOutScheme:
+):
     """
     User login endpoint
     """

src/api/v1/auth.py

@@ -1,6 +1,5 @@
-from typing import List
-
 from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.exc import IntegrityError
 
 from db.crud.category import CategoryCRUD
 from db.dependencies.auth import require_admin
@@ -10,10 +9,10 @@
     CategoryUpdateScheme,
 )
 
-router = APIRouter()
+router = APIRouter(prefix="/categories", tags=["Categories"])
 
 
-@router.get("/", response_model=List[CategoryOutScheme])
+@router.get("/", response_model=CategoryOutScheme)
 async def get_categories(categoryies_crud: CategoryCRUD = Depends(CategoryCRUD)):
     return await categoryies_crud.get_all()
 
@@ -37,7 +36,15 @@ async def get_category(
 async def create_category(
     data: CategoryCreateScheme, categoryies_crud: CategoryCRUD = Depends(CategoryCRUD)
 ):
-    return await categoryies_crud.create(data)
+    try:
+        return await categoryies_crud.create(data)
+    except HTTPException:
+        raise
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Slug or name already exists",
+        )
 
 
 @router.put(

src/api/v1/category.py

@@ -1,25 +1,51 @@
-from fastapi import FastAPI, status
+from typing import Any
+
+from fastapi import FastAPI
 from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+
+class ErrorResponse(BaseModel):
+    code: str
+    detail: str
+    values: dict[str, Any] = {}
 
 
 class APIException(Exception):
+    """
+    Base application exception use in services.
+    message/detail and numeric status_code stored here.
+    code - machine-readable error code (eg. 'user_exists').
+    """
+
     def __init__(
         self,
-        message: str,
+        detail: str | None = None,
         *,
-        status_code: int = status.HTTP_400_BAD_REQUEST,
-        details: dict | None = None,
+        status_code: int = 500,
+        code: str | None = None,
+        values: dict[str, Any] | None = None,
     ):
-        self.message = message
+        self.detail = detail or "Internal server error"
         self.status_code = status_code
-        self.details = details or {}
-
-    def to_dict(self):
-        return {"message": self.message, "details": self.details}
+        self.code = code or "error"
+        self.values = values or {}
+        super().__init__(self.detail)
 
 
-def register_error_handler(app: FastAPI):
+def register_error_handler(app: FastAPI) -> None:
 
     @app.exception_handler(APIException)
     async def api_exception_handler(_, exc: APIException):
-        return JSONResponse(status_code=exc.status_code, content=exc.to_dict())
+        if isinstance(exc, APIException):
+            payload = {"code": exc.code, "detail": exc.detail, "values": exc.values}
+            return JSONResponse(status_code=exc.status_code, content=payload)
+
+        # Fallback: unexpected exception -> 500 but not leak internals
+        return JSONResponse(
+            status_code=500,
+            content={
+                "code": "internal_server_error",
+                "detail": "Internal server error",
+            },
+        )

src/core/exceptions.py

@@ -2,7 +2,6 @@
 from datetime import datetime, timedelta, timezone
 from typing import Any, Dict, Optional, Union
 
-from fastapi import HTTPException
 from jose import ExpiredSignatureError, JWTError, jwt
 from passlib.context import CryptContext
 
@@ -30,77 +29,66 @@ def _jti() -> str:
     return str(uuid.uuid4())
 
 
-# Token factories
-def create_access_token(
+def _to_ts(dt: datetime) -> int:
+    return int(dt.timestamp())
+
+
+def create_token(
     subject: Union[str, int, Dict[str, Any]],
+    token_type: str = "access",
     extra: Optional[Dict[str, Any]] = None,
-    expires_delta: timedelta | None = None,
-) -> str:
-    """
-    Create access token (JWT) with proper iat and exp timestamps.
-    """
-
+    expires_delta: Optional[timedelta] = None,
+):
     if isinstance(subject, dict):
-        payload: Dict[str, Any] = subject.copy()
+        payload = subject.copy()
     else:
-        payload: Dict[str, Any] = {"sub": str(subject)}  # type: ignore
+        payload = {"sub": str(subject)}
 
-    payload.setdefault("type", "access")
+    payload.setdefault("type", token_type)
     payload.setdefault("jti", _jti())
-
-    now_ts = int(_now().timestamp())
-    payload["iat"] = now_ts
+    payload.setdefault("iat", _to_ts(_now()))
 
     if extra:
         payload.update(extra)
 
-    exp_ts = int(
-        (
-            _now()
-            + (
-                expires_delta
-                or timedelta(minutes=settings.PASSWORD_RESET_TOKEN_EXPIRE_MINUTES)
+    if expires_delta:
+        exp = _now() + expires_delta
+    else:
+        if token_type == "access":
+            exp = _now() + timedelta(
+                minutes=settings.JWT_ACCESS_TOKEN_EXPIRE_MINUTES or 15
             )
-        ).timestamp()
-    )
-    payload["exp"] = exp_ts
+        else:
+            exp = _now() + timedelta(days=settings.JWT_REFRESH_TOKEN_EXPIRES_DAYS or 30)
 
+    payload["exp"] = _to_ts(exp)
     return jwt.encode(payload, settings.SECRET_KEY, algorithm=settings.JWT_ALGORITHM)
 
 
-def create_refresh_token(
+# Token factories
+def create_access_token(
     subject: Union[str, int, Dict[str, Any]],
     extra: Optional[Dict[str, Any]] = None,
-    expires_delta: timedelta | None = None,
+    expires_delta: Optional[timedelta] | None = None,
 ) -> str:
     """
-    Create refresh token (JWT) with proper iat and exp timestamps.
+    Create access token (JWT) with proper iat and exp timestamps.
     """
+    return create_token(subject, "access", extra, expires_delta)
 
-    if isinstance(subject, dict):
-        payload: Dict[str, Any] = subject.copy()
-    else:
-        payload: Dict[str, Any] = {"sub": str(subject)}  # type: ignore
-
-    payload.setdefault("type", "refresh")
-    payload.setdefault("jti", _jti())
-    payload["iat"] = int(_now().timestamp())
-
-    if extra:
-        payload.update(extra)
-
-    exp_ts = int(
-        (
-            _now()
-            + (expires_delta or timedelta(days=settings.JWT_REFRESH_TOKEN_EXPIRES_DAYS))
-        ).timestamp()
-    )
-    payload["exp"] = exp_ts
 
-    return jwt.encode(payload, settings.SECRET_KEY, algorithm=settings.JWT_ALGORITHM)
+def create_refresh_token(
+    subject: Union[str, int, Dict[str, Any]],
+    extra: Optional[Dict[str, Any]] = None,
+    expires_delta: Optional[timedelta] | None = None,
+) -> str:
+    """
+    Create refresh token (JWT) with proper iat and exp timestamps.
+    """
+    return create_token(subject, "refresh", extra, expires_delta)
 
 
-def decode_token(token: str) -> dict:
+def decode_token(token: str) -> Dict[str, Any]:
     """
     Decode JWT token. By default, disables exp verification for internal inspection.
     Use jose.decode(token, ..., options={"verify_exp": True}) when verifying token lifetime.
@@ -113,7 +101,7 @@ def decode_token(token: str) -> dict:
             options={"verify_exp": True},
         )
         return payload
-    except ExpiredSignatureError:
-        raise HTTPException(status_code=400, detail="Token has expired")
-    except JWTError:
-        raise HTTPException(status_code=400, detail="Invalid token")
+    except ExpiredSignatureError as e:
+        raise ExpiredSignatureError("token_expired") from e
+    except JWTError as e:
+        raise JWTError("invalid_token") from e

src/core/security.py

@@ -1,7 +1,8 @@
 from typing import Optional, Sequence
 
-from fastapi import Depends
+from fastapi import Depends, HTTPException
 from sqlalchemy import select
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from db.dependencies.sessions import get_db_session
@@ -24,24 +25,35 @@ async def get_by_id(self, category_id: int) -> Optional[Category]:
         return result.scalars().first()
 
     async def get_by_slug(self, slug: str) -> Optional[Category]:
-        stmt = select(Category).where(Category.slug == slug)
-        result = await self.session.execute(stmt)
+        result = await self.session.execute(
+            select(Category).where(Category.slug == slug)
+        )
         return result.scalars().first()
 
     async def create(self, data: CategoryCreateScheme) -> Category:
         new_category = Category(**data.dict())
         self.session.add(new_category)
-        await self.session.commit()
-        await self.session.refresh(new_category)
-        return new_category
+        try:
+            await self.session.commit()
+            await self.session.refresh(new_category)
+            return new_category
+        except IntegrityError:
+            await self.session.rollback()
+            raise HTTPException(status_code=400, detail="Category already exists")
 
     async def update(self, category: Category, data: CategoryUpdateScheme) -> Category:
         for field, value in data.dict(exclude_unset=True).items():
             setattr(category, field, value)
-
-        await self.session.commit()
-        await self.session.refresh(category)
-        return category
+        try:
+            self.session.add(category)
+            await self.session.commit()
+            await self.session.refresh(category)
+            return category
+        except IntegrityError:
+            await self.session.rollback()
+            raise HTTPException(
+                status_code=400, detail="Update would violate constraints"
+            )
 
     async def delete(self, category: Category) -> None:
         await self.session.delete(category)

src/db/crud/category.py

@@ -0,0 +1,37 @@
+# # src/db/crud/courier.py
+# from sqlalchemy import select
+# from sqlalchemy.ext.asyncio import AsyncSession
+
+# from db.models.courier_profile import CourierProfile
+# from schemas.courier import CourierCreateScheme, CourierUpdateLocationScheme
+
+
+# class CourierCRUD:
+#     def __init__(self, session: AsyncSession):
+#         self.session = session
+
+#     async def get_by_user_id(self, user_id: int):
+#         stmt = select(CourierProfile).where(CourierProfile.user_id == user_id)
+#         res = await self.session.execute(stmt)
+#         return res.scalars().first()
+
+#     async def create(self, user_id: int, data: CourierCreateScheme):
+#         courier = CourierProfile(
+#             user_id=user_id,
+#             transport_type=data.transport_type,
+#         )
+#         self.session.add(courier)
+#         await self.session.commit()
+#         await self.session.refresh(courier)
+#         return courier
+
+#     async def update_location(self, courier: CourierProfile, lat: float, lon: float):
+#         courier.latitude = lat
+#         courier.longitude = lon
+#         await self.session.commit()
+#         return courier
+
+#     async def set_availability(self, courier: CourierProfile, available: bool):
+#         courier.is_available = available
+#         await self.session.commit()
+#         return courier

src/db/crud/courier.py

@@ -27,7 +27,7 @@ async def get_current_user(
         payload = decode_token(token)
     except ValueError as exc:
         reason = str(exc)
-        if reason == "token_expired":
+        if "token_expired" in reason:
             raise HTTPException(
                 status_code=status.HTTP_401_UNAUTHORIZED, detail="Token expired"
             )
@@ -47,9 +47,8 @@ async def get_current_user(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="Token revoked"
         )
 
-    user_crud = UserCRUD(session)
-    user = await user_crud.get_by_id(int(payload.get("sub")))
-
+    user_id = int(payload.get("sub"))
+    user = await UserCRUD(session).get_by_id(user_id)
     if not user:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found"