# Поки що не копіюйте цей код, це приклад того, як робити НЕ треба!
@router.post("/tasks", response_model=TaskRead, status_code=201)
async def create_task(
    payload: TaskCreate,
    db: AsyncSession = Depends(get_async_session),
    current_user: User = Depends(get_current_user)
):
    # 1. Перевірка бізнес-правила: чи є користувач учасником проєкту
    project_member = await db.scalar(
        select(ProjectMember).where(
            ProjectMember.project_id == payload.project_id,
            ProjectMember.user_id == current_user.id
        )
    )
    if not project_member:
        raise HTTPException(status_code=403, detail="Ви не є учасником цього проєкту")

    # 2. Перевірка бізнес-правила: ліміт відкритих завдань у проєкті (не більше 50)
    active_tasks_count = await db.scalar(
        select(func.count(Task.id)).where(
            Task.project_id == payload.project_id,
            Task.status != TaskStatus.DONE
        )
    )
    if active_tasks_count >= 50:
        raise HTTPException(
            status_code=400,
            detail="Проєкт досяг ліміту активних завдань (макс. 50)"
        )

    # 3. Створення об'єкта та збереження в БД
    new_task = Task(**payload.model_dump())
    db.add(new_task)
    try:
        await db.commit()
        await db.refresh(new_task)
    except IntegrityError:
        await db.rollback()
        raise HTTPException(status_code=400, detail="Помилка цілісності даних")

    return new_task

from abc import ABC, abstractmethod
from typing import Generic, TypeVar, Sequence, Any

# Generic-тип для сутності (Entity)
T = TypeVar("T")

class AbstractRepository(ABC, Generic[T]):
    
    @abstractmethod
    async def add(self, entity: T) -> T:
        """Додати нову сутність до сховища."""
        raise NotImplementedError

    @abstractmethod
    async def get(self, id: Any) -> T | None:
        """Отримати сутність за її первинним ключем (ID)."""
        raise NotImplementedError

    @abstractmethod
    async def list(self, **filters) -> Sequence[T]:
        """Отримати список сутностей за вказаними фільтрами."""
        raise NotImplementedError

    @abstractmethod
    async def update(self, entity: T, **attrs) -> T:
        """Оновити атрибути існуючої сутності."""
        raise NotImplementedError

    @abstractmethod
    async def delete(self, id: Any) -> bool:
        """Видалити сутність за її первинним ключем."""
        raise NotImplementedError

from sqlalchemy import select, delete
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.exc import NoResultFound

class SQLAlchemyRepository(AbstractRepository[T]):
    
    def __init__(self, session: AsyncSession, model: type[T]):
        self.session = session
        self.model = model

    async def add(self, entity: T) -> T:
        self.session.add(entity)
        return entity

    async def get(self, id: Any) -> T | None:
        # get() у SQLAlchemy автоматично шукає об'єкт у Identity Map сесії, 
        # і якщо не знаходить — робить оптимізований запит за PK
        return await self.session.get(self.model, id)

    async def list(self, **filters) -> Sequence[T]:
        # filter_by() використовує kwargs для простої фільтрації за рівністю (наприклад, status="NEW")
        query = select(self.model).filter_by(**filters)
        result = await self.session.execute(query)
        return result.scalars().all()

    async def update(self, entity: T, **attrs) -> T:
        for key, value in attrs.items():
            if hasattr(entity, key):
                setattr(entity, key, value)
        return entity

    async def delete(self, id: Any) -> bool:
        query = delete(self.model).where(self.model.id == id)
        result = await self.session.execute(query)
        # Повертає True, якщо кількість видалених рядків більша за 0
        return result.rowcount > 0

// Еквівалент Generic Repository в C# (EF Core)
public interface IRepository<T> where T : class
{
    Task<T> AddAsync(T entity);
    Task<T?> GetByIdAsync(object id);
    Task<IEnumerable<T>> ListAsync(Expression<Func<T, bool>> filter);
    Task UpdateAsync(T entity);
    Task<bool> DeleteAsync(object id);
}

from abc import ABC, abstractmethod

class AbstractUnitOfWork(ABC):
    # Кожен UoW надає доступ до необхідних репозиторіїв
    users: AbstractRepository[User]
    projects: AbstractRepository[Project]
    tasks: AbstractRepository[Task]

    async def __aenter__(self) -> "AbstractUnitOfWork":
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        # Якщо блок `async with` завершився з помилкою (exc_type не None),
        # ми автоматично робимо rollback для безпеки
        if exc_type is not None:
            await self.rollback()
        else:
            # Якщо виключень не було, розробник має явно викликати commit(),
            # але про всяк випадок ми страхуємося rollback()
            await self.rollback()

    @abstractmethod
    async def commit(self):
        """Фіксація транзакції."""
        raise NotImplementedError

    @abstractmethod
    async def rollback(self):
        """Відкат транзакції."""
        raise NotImplementedError

from sqlalchemy.ext.asyncio import async_sessionmaker, AsyncSession

class SQLAlchemyUnitOfWork(AbstractUnitOfWork):
    
    def __init__(self, session_factory: async_sessionmaker[AsyncSession]):
        self.session_factory = session_factory

    async def __aenter__(self) -> "SQLAlchemyUnitOfWork":
        # Створюємо сесію бази даних при вході в блок `async with`
        self.session = self.session_factory()
        
        # Ініціалізуємо конкретні репозиторії, передаючи їм СПІЛЬНУ сесію
        self.users = SQLAlchemyRepository(self.session, User)
        self.projects = SQLAlchemyRepository(self.session, Project)
        self.tasks = SQLAlchemyRepository(self.session, Task)
        
        return await super().__aenter__()

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        try:
            # Викликаємо базовий __aexit__ для виконання rollback у разі помилки
            await super().__aexit__(exc_type, exc_val, exc_tb)
        finally:
            # Гарантовано закриваємо сесію та повертаємо підключення в pool
            await self.session.close()

    async def commit(self):
        await self.session.commit()

    async def rollback(self):
        # Відкат змін у базі даних
        # Якщо сесія вже закрита або коміт відбувся — rollback не зашкодить
        await self.session.rollback()

from typing import AsyncGenerator
from app.core.database import async_session_maker # імпорт фабрики сесій

async def get_uow() -> AsyncGenerator[AbstractUnitOfWork, None]:
    # Створюємо екземпляр UoW
    uow = SQLAlchemyUnitOfWork(async_session_maker)
    try:
        yield uow
    finally:
        # Додаткові очищення (за потреби), 
        # хоча UoW сам закриває сесію у __aexit__
        pass

class TaskService:
    
    def __init__(self, uow: AbstractUnitOfWork):
        self.uow = uow

    async def create_task(
        self, 
        project_id: int, 
        title: str, 
        description: str | None = None,
        assignee_id: int | None = None
    ) -> Task:
        # Починаємо одиницю роботи (транзакцію)
        async with self.uow:
            # 1. Перевірка бізнес-правила: чи існує проєкт
            project = await self.uow.projects.get(project_id)
            if not project:
                raise ProjectNotFoundError(f"Проєкт з ID {project_id} не знайдено")

            # 2. Перевірка бізнес-правила: ліміт активних завдань
            active_tasks = await self.uow.tasks.list(
                project_id=project_id, 
                status=TaskStatus.IN_PROGRESS # або інші незавершені статуси
            )
            if len(active_tasks) >= 50:
                raise ProjectLimitExceededException("Досягнуто ліміт активних завдань у проєкті")

            # 3. Створення сутності
            new_task = Task(
                project_id=project_id,
                title=title,
                description=description,
                assignee_id=assignee_id,
                status=TaskStatus.TODO
            )

            # 4. Додавання через репозиторій
            await self.uow.tasks.add(new_task)
            
            # 5. Фіксація транзакції
            await self.uow.commit()
            
            return new_task

# АНТИПАТЕРН! Не робіть так у сервісах!
from fastapi import HTTPException
raise HTTPException(status_code=404, detail="Project not found")

class DomainException(Exception):
    """Базовий клас для всіх помилок бізнес-логіки."""
    pass

class EntityNotFoundError(DomainException):
    """Помилка, коли сутність не знайдено в базі даних."""
    pass

class BusinessRuleViolationError(DomainException):
    """Помилка порушення бізнес-правил."""
    pass

# Специфічні помилки
class ProjectNotFoundError(EntityNotFoundError):
    pass

class ProjectLimitExceededException(BusinessRuleViolationError):
    pass

# app/main.py
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from app.core.exceptions import EntityNotFoundError, BusinessRuleViolationError

app = FastAPI()

@app.exception_handler(EntityNotFoundError)
async def entity_not_found_handler(request: Request, exc: EntityNotFoundError):
    return JSONResponse(
        status_code=404,
        content={"detail": str(exc)}
    )

@app.exception_handler(BusinessRuleViolationError)
async def business_rule_violation_handler(request: Request, exc: BusinessRuleViolationError):
    return JSONResponse(
        status_code=400,
        content={"detail": str(exc)}
    )

app/
├── api/                     # API Layer (Транспортний рівень)
│   ├── v1/                  # Версіонування API
│   │   ├── projects.py      # Маршрути для проєктів
│   │   ├── tasks.py         # Маршрути для завдань
│   │   └── users.py         # Маршрути для користувачів
│   ├── deps.py              # Спільні залежності FastAPI (get_uow, auth)
│   └── routers.py           # Об'єднання всіх роутерів v1
│
├── core/                    # Інфраструктурне ядро (Config, DB, Security)
│   ├── config.py            # Налаштування застосунку (Pydantic Settings)
│   ├── database.py          # Ініціалізація Engine, sessionmaker, get_db
│   └── exceptions.py        # Глобальні та доменні виключення
│
├── models/                  # Domain Layer: ORM-моделі (Entities)
│   ├── base.py              # Декларативна база (Base Class)
│   ├── user.py              # Модель User
│   ├── project.py           # Моделі Project та ProjectMember
│   └── task.py              # Моделі Task та Comment
│
├── schemas/                 # DTO Layer: Pydantic-схеми (Data Transfer Objects)
│   ├── user.py              # Схеми для валідації користувачів
│   ├── project.py           # Схеми для валідації проєктів
│   └── task.py              # Схеми для валідації завдань
│
├── repositories/            # Data Access Layer (Репозиторії)
│   ├── base.py              # Абстрактний та базовий SQLAlchemy репозиторії
│   ├── user.py              # Специфічний репозиторій для користувачів
│   ├── project.py           # Специфічний репозиторій для проєктів
│   └── task.py              # Специфічний репозиторій для завдань
│
├── services/                # Use Cases / Application Layer (Бізнес-сервіси)
│   ├── user.py              # Сервіс для управління користувачами
│   ├── project.py           # Сервіс для управління проєктами
│   └── task.py              # Сервіс для управління завданнями
│
└── main.py                  # Точка входу: ініціалізація FastAPI та запуск

import anyio
from abc import ABC, abstractmethod
from contextlib import asynccontextmanager
from typing import Generic, TypeVar, Sequence, Any, AsyncGenerator

from fastapi import FastAPI, Depends, Request, status
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field

from sqlalchemy import select, delete, String, Integer
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column

# ==============================================================================
# 1. ДОМЕННІ ВИКЛЮЧЕННЯ (DOMAIN EXCEPTIONS)
# ==============================================================================
class DomainException(Exception):
    """Базове виключення бізнес-логіки."""
    pass

class EntityNotFoundError(DomainException):
    """Виникає, коли об'єкт не знайдено."""
    pass

class OutOfStockError(DomainException):
    """Виникає, коли на складі немає потрібної кількості книг."""
    pass


# ==============================================================================
# 2. INFRASTRUCTURE: BAZA DANIKH (SQLALCHEMY MODELS)
# ==============================================================================
class Base(DeclarativeBase):
    pass

class BookModel(Base):
    __tablename__ = "books"

    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
    title: Mapped[str] = mapped_column(String(200), nullable=False)
    author: Mapped[str] = mapped_column(String(100), nullable=False)
    stock: Mapped[int] = mapped_column(Integer, default=0)
    price: Mapped[int] = mapped_column(Integer) # Ціна в копійках/центах


# ==============================================================================
# 3. DTO LAYER: PYDANTIC SCHEMAS
# ==============================================================================
class BookCreate(BaseModel):
    title: str = Field(..., min_length=1, max_length=200)
    author: str = Field(..., min_length=1, max_length=100)
    stock: int = Field(..., ge=0)
    price: int = Field(..., gt=0) # Ціна в копійках має бути більша за 0

class BookRead(BaseModel):
    id: int
    title: str
    author: str
    stock: int
    price: int

    class Config:
        from_attributes = True

class PurchaseRequest(BaseModel):
    quantity: int = Field(..., gt=0)


# ==============================================================================
# 4. DATA ACCESS LAYER: REPOSITORIES
# ==============================================================================
T = TypeVar("T")

class AbstractRepository(ABC, Generic[T]):
    @abstractmethod
    async def add(self, entity: T) -> T: raise NotImplementedError
    @abstractmethod
    async def get(self, id: Any) -> T | None: raise NotImplementedError
    @abstractmethod
    async def list(self, **filters) -> Sequence[T]: raise NotImplementedError
    @abstractmethod
    async def update(self, entity: T, **attrs) -> T: raise NotImplementedError

class SQLAlchemyRepository(AbstractRepository[T]):
    def __init__(self, session: AsyncSession, model: type[T]):
        self.session = session
        self.model = model

    async def add(self, entity: T) -> T:
        self.session.add(entity)
        return entity

    async def get(self, id: Any) -> T | None:
        return await self.session.get(self.model, id)

    async def list(self, **filters) -> Sequence[T]:
        query = select(self.model).filter_by(**filters)
        result = await self.session.execute(query)
        return result.scalars().all()

    async def update(self, entity: T, **attrs) -> T:
        for key, value in attrs.items():
            if hasattr(entity, key):
                setattr(entity, key, value)
        return entity


# ==============================================================================
# 5. DATA ACCESS LAYER: UNIT OF WORK (UOW)
# ==============================================================================
class AbstractUnitOfWork(ABC):
    books: AbstractRepository[BookModel]

    async def __aenter__(self) -> "AbstractUnitOfWork":
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        await self.rollback()

    @abstractmethod
    async def commit(self): raise NotImplementedError
    @abstractmethod
    async def rollback(self): raise NotImplementedError

class SQLAlchemyUnitOfWork(AbstractUnitOfWork):
    def __init__(self, session_factory: async_sessionmaker[AsyncSession]):
        self.session_factory = session_factory

    async def __aenter__(self) -> "SQLAlchemyUnitOfWork":
        self.session = self.session_factory()
        self.books = SQLAlchemyRepository(self.session, BookModel)
        return await super().__aenter__()

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        try:
            await super().__aexit__(exc_type, exc_val, exc_tb)
        finally:
            await self.session.close()

    async def commit(self):
        await self.session.commit()

    async def rollback(self):
        await self.session.rollback()


# ==============================================================================
# 6. APPLICATION LAYER: SERVICE (USE CASES)
# ==============================================================================
class BookStoreService:
    def __init__(self, uow: AbstractUnitOfWork):
        self.uow = uow

    async def add_book_to_store(self, book_data: BookCreate) -> BookModel:
        async with self.uow:
            new_book = BookModel(
                title=book_data.title,
                author=book_data.author,
                stock=book_data.stock,
                price=book_data.price
            )
            await self.uow.books.add(new_book)
            await self.uow.commit()
            return new_book

    async def get_all_books(self) -> Sequence[BookModel]:
        async with self.uow:
            return await self.uow.books.list()

    async def purchase_book(self, book_id: int, quantity: int) -> BookModel:
        async with self.uow:
            # 1. Завантажуємо книгу з БД
            book = await self.uow.books.get(book_id)
            if not book:
                raise EntityNotFoundError(f"Книгу з ID {book_id} не знайдено")

            # 2. Перевіряємо бізнес-правило наявності потрібної кількості на складі
            if book.stock < quantity:
                raise OutOfStockError(
                    f"Недостатньо книг на складі. Запитувано: {quantity}, в наявності: {book.stock}"
                )

            # 3. Виконуємо бізнес-операцію: зменшуємо залишок на складі
            new_stock = book.stock - quantity
            await self.uow.books.update(book, stock=new_stock)

            # 4. Завершуємо транзакцію
            await self.uow.commit()
            return book


# ==============================================================================
# 7. INFRASTRUCTURE: DATABASE SETUP & LIFESPAN
# ==============================================================================
# SQLite база даних в пам'яті
DATABASE_URL = "sqlite+aiosqlite:///:memory:"
engine = create_async_engine(DATABASE_URL, echo=True)
async_session_maker = async_sessionmaker(engine, expire_on_commit=False)

@asynccontextmanager
async def lifespan(app: FastAPI):
    # При старті застосунку автоматично створюємо таблиці в пам'яті
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
    yield
    # При вимкненні очищуємо з'єднання
    await engine.dispose()


# ==============================================================================
# 8. API LAYER: FASTAPI ROUTERS & EXCEPTION HANDLERS
# ==============================================================================
app = FastAPI(
    title="Clean Architecture Bookstore API", 
    version="1.0",
    lifespan=lifespan
)

# Залежність для отримання UoW
async def get_uow() -> AsyncGenerator[AbstractUnitOfWork, None]:
    uow = SQLAlchemyUnitOfWork(async_session_maker)
    try:
        yield uow
    finally:
        pass

# Залежність для отримання Сервісу
def get_book_service(uow: AbstractUnitOfWork = Depends(get_uow)) -> BookStoreService:
    return BookStoreService(uow)


# --- ОБРОБНИКИ ДОМЕННИХ ПОМИЛОК (Exception Handlers) ---
@app.exception_handler(EntityNotFoundError)
async def entity_not_found_handler(request: Request, exc: EntityNotFoundError):
    return JSONResponse(
        status_code=status.HTTP_404_NOT_FOUND,
        content={"error": "Not Found", "message": str(exc)}
    )

@app.exception_handler(OutOfStockError)
async def out_of_stock_handler(request: Request, exc: OutOfStockError):
    return JSONResponse(
        status_code=status.HTTP_400_BAD_REQUEST,
        content={"error": "Business Rule Violation", "message": str(exc)}
    )


# --- МАРШРУТИ API (API Endpoints) ---
@app.get("/books", response_model=list[BookRead])
async def get_books(service: BookStoreService = Depends(get_book_service)):
    """Отримати список усіх книг у крамниці."""
    return await service.get_all_books()

@app.post("/books", response_model=BookRead, status_code=status.HTTP_201_CREATED)
async def add_book(
    payload: BookCreate,
    service: BookStoreService = Depends(get_book_service)
):
    """Додати нову книгу до асортименту."""
    return await service.add_book_to_store(payload)

@app.post("/books/{book_id}/purchase", response_model=BookRead)
async def buy_book(
    book_id: int,
    payload: PurchaseRequest,
    service: BookStoreService = Depends(get_book_service)
):
    """Придбати книгу, зменшивши її залишок на складі."""
    return await service.purchase_book(book_id, payload.quantity)

# app/repositories/base.py
from abc import ABC, abstractmethod
from typing import Generic, TypeVar, Sequence, Any
from sqlalchemy import select, delete
from sqlalchemy.ext.asyncio import AsyncSession

T = TypeVar("T")

class AbstractRepository(ABC, Generic[T]):
    @abstractmethod
    async def add(self, entity: T) -> T: raise NotImplementedError
    
    @abstractmethod
    async def get(self, id: Any) -> T | None: raise NotImplementedError
    
    @abstractmethod
    async def list(self, **filters) -> Sequence[T]: raise NotImplementedError
    
    @abstractmethod
    async def update(self, entity: T, **attrs) -> T: raise NotImplementedError
    
    @abstractmethod
    async def delete(self, id: Any) -> bool: raise NotImplementedError

class SQLAlchemyRepository(AbstractRepository[T]):
    def __init__(self, session: AsyncSession, model: type[T]):
        self.session = session
        self.model = model

    async def add(self, entity: T) -> T:
        self.session.add(entity)
        return entity

    async def get(self, id: Any) -> T | None:
        return await self.session.get(self.model, id)

    async def list(self, **filters) -> Sequence[T]:
        query = select(self.model).filter_by(**filters)
        result = await self.session.execute(query)
        return result.scalars().all()

    async def update(self, entity: T, **attrs) -> T:
        for key, value in attrs.items():
            if hasattr(entity, key):
                setattr(entity, key, value)
        return entity

    async def delete(self, id: Any) -> bool:
        query = delete(self.model).where(self.model.id == id)
        result = await self.session.execute(query)
        return result.rowcount > 0

# app/core/exceptions.py
class DomainException(Exception):
    """Базова доменна помилка."""
    pass

class EntityNotFoundError(DomainException):
    """Виникає, коли сутність не знайдено."""
    pass

class BusinessRuleViolationError(DomainException):
    """Виникає при порушенні бізнес-правил."""
    pass

# Специфічні виключення TaskForge
class ProjectNotFoundError(EntityNotFoundError):
    def __init__(self, project_id: Any):
        super().__init__(f"Проєкт з ID {project_id} не знайдено.")

class TaskNotFoundError(EntityNotFoundError):
    def __init__(self, task_id: Any):
        super().__init__(f"Завдання з ID {task_id} не знайдено.")

class ProjectLimitExceededException(BusinessRuleViolationError):
    def __init__(self, limit: int = 50):
        super().__init__(f"Проєкт досяг ліміту активних завдань (макс. {limit}).")

class CannotDeleteProjectWithActiveTasks(BusinessRuleViolationError):
    def __init__(self):
        super().__init__("Неможливо видалити проєкт, який містить незавершені завдання.")

# app/repositories/project.py
from app.repositories.base import SQLAlchemyRepository
from app.models.project import Project

class ProjectRepository(SQLAlchemyRepository[Project]):
    def __init__(self, session):
        super().__init__(session, Project)
    
    # Тут можна описати специфічні SQL-запити для проєктів, наприклад:
    # async def get_projects_with_members_count(self) -> ...

# app/repositories/task.py
from app.repositories.base import SQLAlchemyRepository
from app.models.task import Task

class TaskRepository(SQLAlchemyRepository[Task]):
    def __init__(self, session):
        super().__init__(session, Task)
    
    # Специфічний метод для пошуку протермінованих завдань
    # async def get_overdue_tasks(self) -> Sequence[Task]: ...

# app/core/unit_of_work.py
from abc import ABC, abstractmethod
from sqlalchemy.ext.asyncio import async_sessionmaker, AsyncSession

from app.repositories.project import ProjectRepository
from app.repositories.task import TaskRepository

class AbstractUnitOfWork(ABC):
    projects: ProjectRepository
    tasks: TaskRepository

    async def __aenter__(self) -> "AbstractUnitOfWork":
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        await self.rollback()

    @abstractmethod
    async def commit(self): raise NotImplementedError

    @abstractmethod
    async def rollback(self): raise NotImplementedError


class SQLAlchemyUnitOfWork(AbstractUnitOfWork):
    def __init__(self, session_factory: async_sessionmaker[AsyncSession]):
        self.session_factory = session_factory

    async def __aenter__(self) -> "SQLAlchemyUnitOfWork":
        self.session = self.session_factory()
        # Створюємо репозиторії, передаючи їм одну й ту саму сесію
        self.projects = ProjectRepository(self.session)
        self.tasks = TaskRepository(self.session)
        return await super().__aenter__()

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        try:
            await super().__aexit__(exc_type, exc_val, exc_tb)
        finally:
            await self.session.close()

    async def commit(self):
        await self.session.commit()

    async def rollback(self):
        await self.session.rollback()

# app/services/project.py
from app.core.unit_of_work import AbstractUnitOfWork
from app.models.project import Project
from app.models.task import TaskStatus
from app.core.exceptions import ProjectNotFoundError, CannotDeleteProjectWithActiveTasks

class ProjectService:
    def __init__(self, uow: AbstractUnitOfWork):
        self.uow = uow

    async def create_project(self, name: str, description: str | None, owner_id: str) -> Project:
        async with self.uow:
            project = Project(name=name, description=description, owner_id=owner_id)
            await self.uow.projects.add(project)
            await self.uow.commit()
            return project

    async def delete_project(self, project_id: str) -> None:
        async with self.uow:
            project = await self.uow.projects.get(project_id)
            if not project:
                raise ProjectNotFoundError(project_id)

            # Перевірка бізнес-правила: чи є в проєкті активні завдання
            active_tasks = await self.uow.tasks.list(
                project_id=project_id, 
                status=TaskStatus.IN_PROGRESS
            )
            if len(active_tasks) > 0:
                raise CannotDeleteProjectWithActiveTasks()

            await self.uow.projects.delete(project_id)
            await self.uow.commit()

# app/services/task.py
from app.core.unit_of_work import AbstractUnitOfWork
from app.models.task import Task, TaskStatus
from app.core.exceptions import ProjectNotFoundError, ProjectLimitExceededException

class TaskService:
    def __init__(self, uow: AbstractUnitOfWork):
        self.uow = uow

    async def create_task(self, title: str, description: str | None, project_id: str) -> Task:
        async with self.uow:
            project = await self.uow.projects.get(project_id)
            if not project:
                raise ProjectNotFoundError(project_id)

            active_tasks = await self.uow.tasks.list(project_id=project_id, status=TaskStatus.IN_PROGRESS)
            if len(active_tasks) >= 50:
                raise ProjectLimitExceededException(limit=50)

            task = Task(title=title, description=description, project_id=project_id, status=TaskStatus.TODO)
            await self.uow.tasks.add(task)
            await self.uow.commit()
            return task

# app/api/deps.py
from typing import AsyncGenerator
from app.core.database import async_session_maker
from app.core.unit_of_work import AbstractUnitOfWork, SQLAlchemyUnitOfWork
from app.services.project import ProjectService
from app.services.task import TaskService
from fastapi import Depends

async def get_uow() -> AsyncGenerator[AbstractUnitOfWork, None]:
    uow = SQLAlchemyUnitOfWork(async_session_maker)
    try:
        yield uow
    finally:
        pass

def get_project_service(uow: AbstractUnitOfWork = Depends(get_uow)) -> ProjectService:
    return ProjectService(uow)

def get_task_service(uow: AbstractUnitOfWork = Depends(get_uow)) -> TaskService:
    return TaskService(uow)

# app/api/v1/projects.py
from fastapi import APIRouter, Depends, status
from app.schemas.project import ProjectCreate, ProjectRead
from app.services.project import ProjectService
from app.api.deps import get_project_service
from app.models.user import User
from app.api.deps import get_current_user # Залежність аутентифікації

router = APIRouter(prefix="/projects", tags=["projects"])

@router.post("/", response_model=ProjectRead, status_code=status.HTTP_201_CREATED)
async def create_project(
    payload: ProjectCreate,
    service: ProjectService = Depends(get_project_service),
    current_user: User = Depends(get_current_user)
):
    """Створити новий проєкт через сервісний шар."""
    return await service.create_project(
        name=payload.name,
        description=payload.description,
        owner_id=current_user.id
    )

@router.delete("/{project_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_project(
    project_id: str,
    service: ProjectService = Depends(get_project_service),
    current_user: User = Depends(get_current_user)
):
    """Видалити проєкт, перевіривши бізнес-правила."""
    await service.delete_project(project_id)

git commit -m "feat: implement repository pattern, service layer and clean architecture"