deduplication code

Author: Trojan-Dev-AFK

app/api/v1/endpoints/auth.py

@@ -51,9 +51,12 @@ async def logout(
 
 
 @router.get("/me", response_model=MeResponse)
-async def get_current_user_profile(current_user: User = Depends(get_current_user)):
+async def get_current_user_profile(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
     """Get the current user's profile."""
-    return auth_service.get_current_user_profile(current_user=current_user)
+    return await auth_service.get_current_user_profile(current_user=current_user, db=db)
 
 
 @router.get("/me/sessions", response_model=list[SessionResponse])

app/api/v1/endpoints/chat.py

@@ -4,6 +4,7 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.dependencies import require_company_user
+from app.api.v1.endpoints.common import build_list_service_kwargs
 from app.db.models import User
 from app.db.session import get_db
 from app.schemas.chat import ChatConversationResponse, ChatMessageResponse, ChatRequest, ChatResponse
@@ -54,12 +55,14 @@ async def list_conversations(
     current_user: User = Depends(require_company_user),
 ):
     """List persisted chat conversations for the current authenticated user."""
-    service_kwargs: dict = {"db": db, "current_user": current_user}
-    if limit is not None:
-        service_kwargs["limit"] = limit
-    if offset is not None:
-        service_kwargs["offset"] = offset
-    return await chat_service.list_conversations(**service_kwargs)
+    return await chat_service.list_conversations(
+        **build_list_service_kwargs(
+            db=db,
+            current_user=current_user,
+            limit=limit,
+            offset=offset,
+        )
+    )
 
 
 @router.get("/conversations/{conversation_id}/messages", response_model=list[ChatMessageResponse])
@@ -71,15 +74,12 @@ async def get_conversation_messages(
     current_user: User = Depends(require_company_user),
 ):
     """Get persisted messages for one conversation owned by the current user."""
-    service_kwargs: dict = {
-        "conversation_id": conversation_id,
-        "db": db,
-        "current_user": current_user,
-    }
-    if limit is not None:
-        service_kwargs["limit"] = limit
-    if offset is not None:
-        service_kwargs["offset"] = offset
     return await chat_service.get_conversation_messages(
-        **service_kwargs,
+        **build_list_service_kwargs(
+            db=db,
+            current_user=current_user,
+            limit=limit,
+            offset=offset,
+            conversation_id=conversation_id,
+        ),
     )

app/api/v1/endpoints/common.py

@@ -0,0 +1,28 @@
+"""Shared endpoint-layer helpers for building service kwargs."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from app.db.models import User
+
+
+def build_list_service_kwargs(
+    *,
+    db: Any,
+    current_user: User,
+    limit: int | None = None,
+    offset: int | None = None,
+    **extra: Any,
+) -> dict[str, Any]:
+    """Build service kwargs while preserving optional-parameter compatibility for tests/mocks."""
+    kwargs: dict[str, Any] = {
+        "db": db,
+        "current_user": current_user,
+        **extra,
+    }
+    if limit is not None:
+        kwargs["limit"] = limit
+    if offset is not None:
+        kwargs["offset"] = offset
+    return kwargs

app/api/v1/endpoints/companies.py

@@ -4,6 +4,7 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.dependencies import require_super_admin
+from app.api.v1.endpoints.common import build_list_service_kwargs
 from app.db.models import User
 from app.db.session import get_db
 from app.schemas.companies import CompanyCreate, CompanyResponse, CompanyUpdate
@@ -34,12 +35,14 @@ async def list_companies(
     current_user: User = Depends(require_super_admin),
 ):
     """Return all companies ordered by name (super admin only)."""
-    service_kwargs: dict = {"db": db, "current_user": current_user}
-    if limit is not None:
-        service_kwargs["limit"] = limit
-    if offset is not None:
-        service_kwargs["offset"] = offset
-    return await companies_service.list_companies(**service_kwargs)
+    return await companies_service.list_companies(
+        **build_list_service_kwargs(
+            db=db,
+            current_user=current_user,
+            limit=limit,
+            offset=offset,
+        )
+    )
 
 
 @router.get("/{company_id}", response_model=CompanyResponse)

app/api/v1/endpoints/documents.py

@@ -2,6 +2,7 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.dependencies import require_admin_or_super_admin
+from app.api.v1.endpoints.common import build_list_service_kwargs
 from app.db.models import User
 from app.db.session import get_db
 from app.schemas.documents import DocumentResponse, UploadResponse
@@ -60,16 +61,15 @@ async def list_documents(
     **admin**: always returns documents from their own company only.
     **super_admin**: returns documents for the specified ``company_id``; if omitted, returns all documents.
     """
-    service_kwargs: dict = {
-        "company_id": company_id,
-        "db": db,
-        "current_user": current_user,
-    }
-    if limit is not None:
-        service_kwargs["limit"] = limit
-    if offset is not None:
-        service_kwargs["offset"] = offset
-    return await documents_service.list_documents(**service_kwargs)
+    return await documents_service.list_documents(
+        **build_list_service_kwargs(
+            db=db,
+            current_user=current_user,
+            limit=limit,
+            offset=offset,
+            company_id=company_id,
+        )
+    )
 
 
 @router.get("/{document_id}", response_model=DocumentResponse, status_code=200)

app/api/v1/endpoints/users.py

@@ -17,6 +17,7 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.dependencies import require_admin_or_super_admin
+from app.api.v1.endpoints.common import build_list_service_kwargs
 from app.db.models import User
 from app.db.session import get_db
 from app.schemas.users import UserCreate, UserResponse, UserUpdate
@@ -71,16 +72,15 @@ async def list_users(
     **super_admin**: returns users for the specified ``company_id``; if omitted, returns all users
     across every company (excluding other ``super_admin`` accounts).
     """
-    service_kwargs: dict = {
-        "company_id": company_id,
-        "db": db,
-        "current_user": current_user,
-    }
-    if limit is not None:
-        service_kwargs["limit"] = limit
-    if offset is not None:
-        service_kwargs["offset"] = offset
-    return await users_service.list_users(**service_kwargs)
+    return await users_service.list_users(
+        **build_list_service_kwargs(
+            db=db,
+            current_user=current_user,
+            limit=limit,
+            offset=offset,
+            company_id=company_id,
+        )
+    )
 
 
 @router.get("/{user_id}", response_model=UserResponse)

app/services/auth_service.py

@@ -12,7 +12,7 @@
 from app.core.logger import get_logger
 from app.core.runtime_controls import rate_limit_exceeded, token_session_cache_delete
 from app.core.security import create_access_token, verify_password
-from app.db.models import TokenSession, User, UserRole
+from app.db.models import Company, TokenSession, User, UserRole
 from app.schemas.auth import LogoutResponse, MeResponse, TokenResponse
 
 logger = get_logger(__name__)
@@ -115,15 +115,20 @@ async def logout(*, token: str, current_user: User, db: AsyncSession) -> LogoutR
     return LogoutResponse(message="Successfully logged out")
 
 
-def get_current_user_profile(*, current_user: User) -> MeResponse:
+async def get_current_user_profile(*, current_user: User, db: AsyncSession) -> MeResponse:
     """Convert the authenticated ORM user into API profile response."""
     logger.info("Profile fetched", extra={"user_id": current_user.id, "username": current_user.username})
+    company_name = None
+    if current_user.company_id:
+        company_result = await db.execute(select(Company).filter(Company.id == current_user.company_id))
+        company = company_result.scalar_one_or_none()
+        company_name = company.name if company else None
     return MeResponse(
         id=current_user.id,
         username=current_user.username,
         role=current_user.role,
         company_id=current_user.company_id,
-        company_name=current_user.company.name if current_user.company else None,
+        company_name=company_name,
         created_at=current_user.created_at,
     )
 

app/services/chat_service.py

@@ -30,17 +30,10 @@
 )
 from app.db.models import ChatConversation, ChatMessage, User
 from app.schemas.chat import ChatConversationResponse, ChatMessageResponse
+from app.services.common import sanitize_pagination
 
 logger = get_logger(__name__)
 
-
-def _sanitize_pagination(*, limit: int | None, offset: int | None) -> tuple[int, int]:
-    safe_limit = settings.DEFAULT_LIST_LIMIT if limit is None else limit
-    safe_limit = max(1, min(safe_limit, settings.MAX_LIST_LIMIT))
-    safe_offset = 0 if offset is None else max(0, offset)
-    return safe_limit, safe_offset
-
-
 def _conversation_list_cache_key(*, user_id: str, company_id: str) -> str:
     return f"cache:chat:conversations:{company_id}:{user_id}"
 
@@ -270,7 +263,7 @@ async def list_conversations(
             detail="You do not have permission to perform this action.",
         )
 
-    safe_limit, safe_offset = _sanitize_pagination(limit=limit, offset=offset)
+    safe_limit, safe_offset = sanitize_pagination(limit=limit, offset=offset)
     cache_key = f"{_conversation_list_cache_key(user_id=current_user.id, company_id=current_user.company_id)}:{safe_limit}:{safe_offset}"
     cached = await cache_get_json(key=cache_key)
     if isinstance(cached, list):
@@ -314,7 +307,7 @@ async def get_conversation_messages(
     """Return persisted messages for one user-scoped conversation."""
     conversation = await _get_scoped_conversation(conversation_id=conversation_id, current_user=current_user, db=db)
 
-    safe_limit, safe_offset = _sanitize_pagination(limit=limit, offset=offset)
+    safe_limit, safe_offset = sanitize_pagination(limit=limit, offset=offset)
     cache_key = f"{_conversation_messages_cache_key(conversation_id=conversation.id)}:{safe_limit}:{safe_offset}"
     cached = await cache_get_json(key=cache_key)
     if isinstance(cached, list):

app/services/common.py

@@ -0,0 +1,54 @@
+"""Shared helpers for service-layer data access and pagination."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import HTTPException, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.config import settings
+from app.core.logger import get_logger
+from app.db.models import Company
+
+logger = get_logger(__name__)
+
+
+def sanitize_pagination(*, limit: int | None, offset: int | None) -> tuple[int, int]:
+    """Normalize list pagination parameters using configured defaults and limits."""
+    safe_limit = settings.DEFAULT_LIST_LIMIT if limit is None else limit
+    safe_limit = max(1, min(safe_limit, settings.MAX_LIST_LIMIT))
+    safe_offset = 0 if offset is None else max(0, offset)
+    return safe_limit, safe_offset
+
+
+async def get_by_id_or_404(
+    *,
+    db: AsyncSession,
+    model: type[Any],
+    entity_id: str,
+    detail: str,
+    log_message: str,
+    log_extra: dict[str, Any] | None = None,
+) -> Any:
+    """Fetch an entity by UUID and raise HTTP 404 when absent."""
+    result = await db.execute(select(model).filter(model.id == entity_id))
+    entity = result.scalar_one_or_none()
+    if entity is None:
+        logger.warning(log_message, extra=log_extra or {"entity_id": entity_id})
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=detail)
+    return entity
+
+
+async def get_company_or_400(*, db: AsyncSession, company_id: str, actor_id: str | None = None) -> Company:
+    """Fetch a company by UUID and raise HTTP 400 when absent."""
+    result = await db.execute(select(Company).filter(Company.id == company_id))
+    company = result.scalar_one_or_none()
+    if company is None:
+        logger.warning(
+            "Company not found",
+            extra={"company_id": company_id, "actor": actor_id},
+        )
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Company not found")
+    return company