Sergey Vanyushkin
184b95969c
Major changes: - Add Keycloak integration via token introspection endpoint - Implement RBAC system with roles: admin, user, guest - Add role-based permissions for post operations - Add pagination support (default limit: 10) to list endpoints - Add published_only filter with admin-only override for unpublished posts Security improvements: - Remove hardcoded default secrets (SECRET_KEY, KEYCLOAK_CLIENT_SECRET) - Update .env.example with proper security placeholders - Add comprehensive RBAC unit tests Infrastructure: - Add httpx dependency for HTTP client - Add KeycloakAuthClient with token caching (TTL: 60s) - Add role-based dependencies (RequireAdmin, RequireUser, etc.) - Update DI container with Keycloak provider Endpoints updated: - GET /posts: filter by published status (admin can see all) - Add pagination params (limit, offset) to list endpoints - Enforce RBAC on post operations Tests: - Add 16 auth infrastructure tests - Add 13 RBAC role tests - Update existing tests for new required settings Breaking changes: - SECRET_KEY and KEYCLOAK_CLIENT_SECRET now required (no defaults)
145 lines
4.2 KiB
Python
145 lines
4.2 KiB
Python
"""Dishka providers for dependency injection."""
|
|
|
|
from typing import AsyncGenerator
|
|
|
|
from dishka import Provider, Scope, provide
|
|
from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
|
|
|
|
from app.application import (
|
|
CreatePostUseCase,
|
|
DeletePostUseCase,
|
|
GetPostUseCase,
|
|
ListPostsUseCase,
|
|
PublishPostUseCase,
|
|
UpdatePostUseCase,
|
|
)
|
|
from app.application.interfaces import TransactionManager
|
|
from app.domain.repositories import PostRepository
|
|
from app.infrastructure.auth import KeycloakAuthClient
|
|
from app.infrastructure.config.settings import settings
|
|
from app.infrastructure.database.connection import AsyncSessionLocal, engine
|
|
from app.infrastructure.repositories.post import SQLAlchemyPostRepository
|
|
|
|
|
|
class DatabaseProvider(Provider):
|
|
"""Provider for database-related dependencies."""
|
|
|
|
@provide(scope=Scope.APP)
|
|
def get_engine(self) -> AsyncEngine:
|
|
"""Provide SQLAlchemy engine."""
|
|
return engine
|
|
|
|
@provide(scope=Scope.REQUEST)
|
|
async def get_session(self) -> AsyncGenerator[AsyncSession, None]:
|
|
"""Provide database session per request."""
|
|
async with AsyncSessionLocal() as session:
|
|
try:
|
|
yield session
|
|
finally:
|
|
await session.close()
|
|
|
|
|
|
class RepositoryProvider(Provider):
|
|
"""Provider for repository implementations."""
|
|
|
|
@provide(scope=Scope.REQUEST)
|
|
def get_post_repository(self, session: AsyncSession) -> PostRepository:
|
|
"""Provide PostRepository implementation."""
|
|
return SQLAlchemyPostRepository(session)
|
|
|
|
|
|
class TransactionManagerProvider(Provider):
|
|
"""Provider for transaction manager."""
|
|
|
|
@provide(scope=Scope.REQUEST)
|
|
def get_transaction_manager(self, session: AsyncSession) -> TransactionManager:
|
|
"""Provide TransactionManager implementation."""
|
|
from app.infrastructure.di.transaction_manager import SessionTransactionManager
|
|
|
|
return SessionTransactionManager(session)
|
|
|
|
|
|
class UseCaseProvider(Provider):
|
|
"""Provider for use cases."""
|
|
|
|
@provide(scope=Scope.REQUEST)
|
|
def get_create_post_use_case(
|
|
self,
|
|
post_repo: PostRepository,
|
|
tx_manager: TransactionManager,
|
|
) -> CreatePostUseCase:
|
|
"""Provide CreatePostUseCase."""
|
|
return CreatePostUseCase(
|
|
post_repo=post_repo,
|
|
tx_manager=tx_manager,
|
|
)
|
|
|
|
@provide(scope=Scope.REQUEST)
|
|
def get_get_post_use_case(
|
|
self,
|
|
post_repo: PostRepository,
|
|
tx_manager: TransactionManager,
|
|
) -> GetPostUseCase:
|
|
"""Provide GetPostUseCase."""
|
|
return GetPostUseCase(
|
|
post_repo=post_repo,
|
|
tx_manager=tx_manager,
|
|
)
|
|
|
|
@provide(scope=Scope.REQUEST)
|
|
def get_update_post_use_case(
|
|
self,
|
|
post_repo: PostRepository,
|
|
tx_manager: TransactionManager,
|
|
) -> UpdatePostUseCase:
|
|
"""Provide UpdatePostUseCase."""
|
|
return UpdatePostUseCase(
|
|
post_repo=post_repo,
|
|
tx_manager=tx_manager,
|
|
)
|
|
|
|
@provide(scope=Scope.REQUEST)
|
|
def get_delete_post_use_case(
|
|
self,
|
|
post_repo: PostRepository,
|
|
tx_manager: TransactionManager,
|
|
) -> DeletePostUseCase:
|
|
"""Provide DeletePostUseCase."""
|
|
return DeletePostUseCase(
|
|
post_repo=post_repo,
|
|
tx_manager=tx_manager,
|
|
)
|
|
|
|
@provide(scope=Scope.REQUEST)
|
|
def get_list_posts_use_case(
|
|
self,
|
|
post_repo: PostRepository,
|
|
tx_manager: TransactionManager,
|
|
) -> ListPostsUseCase:
|
|
"""Provide ListPostsUseCase."""
|
|
return ListPostsUseCase(
|
|
post_repo=post_repo,
|
|
tx_manager=tx_manager,
|
|
)
|
|
|
|
@provide(scope=Scope.REQUEST)
|
|
def get_publish_post_use_case(
|
|
self,
|
|
post_repo: PostRepository,
|
|
tx_manager: TransactionManager,
|
|
) -> PublishPostUseCase:
|
|
"""Provide PublishPostUseCase."""
|
|
return PublishPostUseCase(
|
|
post_repo=post_repo,
|
|
tx_manager=tx_manager,
|
|
)
|
|
|
|
|
|
class KeycloakProvider(Provider):
|
|
"""Provider for Keycloak authentication client."""
|
|
|
|
@provide(scope=Scope.APP)
|
|
def get_keycloak_client(self) -> KeycloakAuthClient:
|
|
"""Provide KeycloakAuthClient singleton."""
|
|
return KeycloakAuthClient(settings)
|