refactor: migrate to DDD architecture with Dishka DI

Complete architectural refactoring from simple MVC to Clean Architecture/DDD pattern:

Domain Layer:

- Add entities (Post, BaseEntity) with business logic

- Add value objects (Title, Content, Slug) with validation

- Add repository interfaces (PostRepository)

- Add domain exceptions

Application Layer:

- Add use cases (CreatePost, GetPost, UpdatePost, DeletePost, ListPosts, PublishPost)

- Add DTOs for data transfer

- Add TransactionManager interface

Infrastructure Layer:

- Add SQLAlchemy models and async database connection

- Add SQLAlchemyPostRepository implementation

- Add Dishka DI container with providers

- Add error handlers and middleware

Presentation Layer:

- Add FastAPI routes with Dishka integration

- Add Pydantic schemas

- Add dependency injection using FromDishka[T]

Other Changes:

- Remove old flat structure (api/, common/, core/, modules/)

- Add hatchling build system for package scripts

- Add blog CLI command

- Update AGENTS.md with new architecture docs

- All 48 tests passing, mypy clean, ruff clean

tests/integration/conftest.py

@@ -1,20 +1,58 @@
-# Integration test fixtures
-# Provides: test database, external service connections
+"""Integration test fixtures."""
 
-from typing import Generator
+from typing import AsyncGenerator
 
 import pytest
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+
+from app.infrastructure.database.models import Base
+
+# Use in-memory SQLite for tests
+TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"
 
 
-@pytest.fixture
-def test_db_connection() -> Generator[str, None, None]:
-    """Create test database connection."""
-    # TODO: Implement when DB is added to project
-    yield "test_db"
+@pytest.fixture(scope="session")
+def engine() -> AsyncEngine:
+    """Create test engine."""
+    return create_async_engine(
+        TEST_DATABASE_URL,
+        echo=False,
+        future=True,
+    )
 
 
-@pytest.fixture
-def cleanup_db() -> Generator[None, None, None]:
-    """Cleanup database after test."""
+@pytest.fixture(scope="session")
+def session_factory(engine: AsyncEngine) -> async_sessionmaker[AsyncSession]:
+    """Create test session factory."""
+    return async_sessionmaker(
+        engine,
+        class_=AsyncSession,
+        expire_on_commit=False,
+        autoflush=False,
+        autocommit=False,
+    )
+
+
+@pytest.fixture(autouse=True)
+async def setup_db(engine: AsyncEngine) -> AsyncGenerator[None, None]:
+    """Setup database tables for each test."""
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
     yield
-    # TODO: Implement cleanup logic
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.drop_all)
+
+
+@pytest.fixture
+async def db_session(
+    session_factory: async_sessionmaker[AsyncSession],
+) -> AsyncGenerator[AsyncSession, None]:
+    """Create database session for testing."""
+    async with session_factory() as session:
+        yield session
+        await session.rollback()