feat: remove deprecated user API and related services; clean up imports and dependencies

app/api/deps.py

@@ -27,7 +27,6 @@ from app.services.organization_service import (
     OrganizationService,
 )
 from app.services.task_service import TaskService
-from app.services.user_service import UserService
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"{settings.api_v1_prefix}/auth/token")
 
@@ -66,10 +65,6 @@ def get_deal_service(repo: DealRepository = Depends(get_deal_repository)) -> Dea
     return DealService(repository=repo)
 
 
-def get_user_service(repo: UserRepository = Depends(get_user_repository)) -> UserService:
-    return UserService(user_repository=repo, password_hasher=password_hasher)
-
-
 def get_auth_service(
     repo: UserRepository = Depends(get_user_repository),
 ) -> AuthService:

app/api/routes.py

@@ -9,13 +9,11 @@ from app.api.v1 import (
 	deals,
 	organizations,
 	tasks,
-	users,
 )
 from app.core.config import settings
 
 api_router = APIRouter()
 api_router.include_router(auth.router, prefix=settings.api_v1_prefix)
-api_router.include_router(users.router, prefix=settings.api_v1_prefix)
 api_router.include_router(organizations.router, prefix=settings.api_v1_prefix)
 api_router.include_router(contacts.router, prefix=settings.api_v1_prefix)
 api_router.include_router(deals.router, prefix=settings.api_v1_prefix)

app/api/v1/__init__.py

@@ -7,7 +7,6 @@ from . import (
 	deals,
 	organizations,
 	tasks,
-	users,
 )
 
 __all__ = [
@@ -18,5 +17,4 @@ __all__ = [
 	"deals",
 	"organizations",
 	"tasks",
-	"users",
 ]

app/api/v1/users.py

@@ -1,37 +0,0 @@
-"""User API endpoints."""
-from __future__ import annotations
-
-from fastapi import APIRouter, Depends, HTTPException, status
-
-from app.api.deps import get_user_service
-from app.models.user import UserCreate, UserRead
-from app.services.user_service import UserAlreadyExistsError, UserNotFoundError, UserService
-
-router = APIRouter(prefix="/users", tags=["users"])
-
-
-@router.get("/", response_model=list[UserRead])
-async def list_users(service: UserService = Depends(get_user_service)) -> list[UserRead]:
-    users = await service.list_users()
-    return [UserRead.model_validate(user) for user in users]
-
-
-@router.post("/", response_model=UserRead, status_code=status.HTTP_201_CREATED)
-async def create_user(
-    user_in: UserCreate,
-    service: UserService = Depends(get_user_service),
-) -> UserRead:
-    try:
-        user = await service.create_user(user_in)
-    except UserAlreadyExistsError as exc:  # pragma: no cover - thin API layer
-        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(exc)) from exc
-    return UserRead.model_validate(user)
-
-
-@router.get("/{user_id}", response_model=UserRead)
-async def get_user(user_id: int, service: UserService = Depends(get_user_service)) -> UserRead:
-    try:
-        user = await service.get_user(user_id)
-    except UserNotFoundError as exc:  # pragma: no cover - thin API layer
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
-    return UserRead.model_validate(user)

app/services/__init__.py

@@ -22,5 +22,4 @@ from .task_service import (  # noqa: F401
     TaskService,
     TaskServiceError,
     TaskUpdateData,
-)
-from .user_service import UserService  # noqa: F401
+)

app/services/user_service.py

@@ -1,48 +0,0 @@
-"""User-related business logic."""
-from __future__ import annotations
-
-from collections.abc import Sequence
-
-from app.core.security import PasswordHasher
-from app.models.user import User, UserCreate
-from app.repositories.user_repo import UserRepository
-
-
-class UserServiceError(Exception):
-    """Base class for user service errors."""
-
-
-class UserAlreadyExistsError(UserServiceError):
-    """Raised when attempting to create a user with duplicate email."""
-
-
-class UserNotFoundError(UserServiceError):
-    """Raised when user record cannot be located."""
-
-
-class UserService:
-    """Encapsulates user-related workflows."""
-
-    def __init__(self, user_repository: UserRepository, password_hasher: PasswordHasher) -> None:
-        self._repository = user_repository
-        self._password_hasher = password_hasher
-
-    async def list_users(self) -> Sequence[User]:
-        return await self._repository.list()
-
-    async def get_user(self, user_id: int) -> User:
-        user = await self._repository.get_by_id(user_id)
-        if user is None:
-            raise UserNotFoundError(f"User {user_id} not found")
-        return user
-
-    async def create_user(self, data: UserCreate) -> User:
-        existing = await self._repository.get_by_email(data.email)
-        if existing is not None:
-            raise UserAlreadyExistsError(f"User {data.email} already exists")
-
-        hashed_password = self._password_hasher.hash(data.password)
-        user = await self._repository.create(data=data, hashed_password=hashed_password)
-        await self._repository.session.commit()
-        await self._repository.session.refresh(user)
-        return user