Jeroen SchweitzerandClaude Opus 4.5
381d43b60b
Build and Push / build (release) Successful in 1m28s
- Dashboard domain with Quick Links CRUD + reorder endpoints - Dashboard widgets management endpoints - Database migrations for quick_links and dashboard_widgets tables - Static file controller for Organizr widgets - Default local user when OIDC is disabled - Domain-based architecture refactor (src/domains/, src/shared/) - Test suite updated for new structure (285 tests passing) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
136 lines
4.1 KiB
Python
136 lines
4.1 KiB
Python
"""
|
|
Database Connection Module
|
|
|
|
Provides async PostgreSQL connectivity using SQLAlchemy 2.0 with asyncpg driver.
|
|
"""
|
|
from typing import AsyncGenerator, Optional
|
|
from sqlalchemy import text
|
|
from sqlalchemy.ext.asyncio import (
|
|
AsyncSession,
|
|
AsyncEngine,
|
|
create_async_engine,
|
|
async_sessionmaker,
|
|
)
|
|
from sqlalchemy.orm import DeclarativeBase
|
|
from sqlalchemy.pool import NullPool
|
|
|
|
from src.shared.config import get_settings
|
|
from src.shared.logging import get_logger
|
|
|
|
logger = get_logger(__name__)
|
|
settings = get_settings()
|
|
|
|
|
|
class Base(DeclarativeBase):
|
|
"""
|
|
SQLAlchemy declarative base for all models
|
|
|
|
All database models should inherit from this class.
|
|
"""
|
|
pass
|
|
|
|
|
|
class Database:
|
|
"""
|
|
Async database connection manager
|
|
|
|
Provides async engine and session factory for PostgreSQL connections.
|
|
"""
|
|
|
|
def __init__(self, database_url: Optional[str] = None):
|
|
"""Initialize database connection manager"""
|
|
url = database_url or settings.database_url
|
|
if url.startswith("postgresql://"):
|
|
url = url.replace("postgresql://", "postgresql+asyncpg://", 1)
|
|
|
|
self._url = url
|
|
self._engine: Optional[AsyncEngine] = None
|
|
self._session_factory: Optional[async_sessionmaker[AsyncSession]] = None
|
|
|
|
@property
|
|
def engine(self) -> AsyncEngine:
|
|
"""Get or create the async database engine"""
|
|
if self._engine is None:
|
|
self._engine = create_async_engine(
|
|
self._url,
|
|
echo=settings.debug,
|
|
poolclass=NullPool,
|
|
)
|
|
logger.info(f"Database engine created for {self._url.split('@')[-1]}")
|
|
return self._engine
|
|
|
|
@property
|
|
def session_factory(self) -> async_sessionmaker[AsyncSession]:
|
|
"""Get or create the async session factory"""
|
|
if self._session_factory is None:
|
|
self._session_factory = async_sessionmaker(
|
|
bind=self.engine,
|
|
class_=AsyncSession,
|
|
expire_on_commit=False,
|
|
autocommit=False,
|
|
autoflush=False,
|
|
)
|
|
return self._session_factory
|
|
|
|
async def create_tables(self) -> None:
|
|
"""Create all database tables (dev/testing only)"""
|
|
async with self.engine.begin() as conn:
|
|
await conn.run_sync(Base.metadata.create_all)
|
|
logger.info("Database tables created")
|
|
|
|
async def drop_tables(self) -> None:
|
|
"""Drop all database tables (WARNING: destroys data)"""
|
|
async with self.engine.begin() as conn:
|
|
await conn.run_sync(Base.metadata.drop_all)
|
|
logger.warning("Database tables dropped")
|
|
|
|
async def health_check(self) -> bool:
|
|
"""Check if database connection is healthy"""
|
|
try:
|
|
async with self.session_factory() as session:
|
|
await session.execute(text("SELECT 1"))
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"Database health check failed: {e}")
|
|
return False
|
|
|
|
async def close(self) -> None:
|
|
"""Close database connections"""
|
|
if self._engine is not None:
|
|
await self._engine.dispose()
|
|
self._engine = None
|
|
self._session_factory = None
|
|
logger.info("Database connections closed")
|
|
|
|
|
|
# Singleton instance
|
|
_database: Optional[Database] = None
|
|
|
|
|
|
def get_database() -> Database:
|
|
"""Get singleton database instance"""
|
|
global _database
|
|
if _database is None:
|
|
_database = Database()
|
|
return _database
|
|
|
|
|
|
async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
|
|
"""
|
|
FastAPI dependency for database sessions
|
|
|
|
Usage:
|
|
@router.get("/items")
|
|
async def get_items(session: AsyncSession = Depends(get_async_session)):
|
|
result = await session.execute(select(Item))
|
|
return result.scalars().all()
|
|
"""
|
|
database = get_database()
|
|
async with database.session_factory() as session:
|
|
try:
|
|
yield session
|
|
await session.commit()
|
|
except Exception:
|
|
await session.rollback()
|
|
raise
|