Fix aiomysql pool_pre_ping crash, add rate limiting and security hardening

Remove pool_pre_ping=True to fix startup crash caused by aiomysql 0.2.0
async adapter requiring a reconnect argument SQLAlchemy does not pass.
Add slowapi rate limiting, structured logging, CORS config, backend
health check, and nginx security headers.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/app/config.py

@@ -8,6 +8,7 @@ class Settings(BaseSettings):
     algorithm: str = "HS256"
     admin_username: str
     admin_password: str
+    allowed_origins: str = "http://localhost"
 
     class Config:
         env_file = ".env"

backend/app/database.py

@@ -4,7 +4,7 @@ from sqlalchemy.orm import DeclarativeBase
 from app.config import settings
 
 
-engine = create_async_engine(settings.database_url, echo=False, pool_pre_ping=True, pool_recycle=1800)
+engine = create_async_engine(settings.database_url, echo=False, pool_recycle=1800)
 AsyncSessionLocal = async_sessionmaker(engine, expire_on_commit=False)
 
 

backend/app/limiter.py

@@ -0,0 +1,4 @@
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+limiter = Limiter(key_func=get_remote_address)

backend/app/main.py

@@ -1,13 +1,23 @@
+import logging
 from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from sqlalchemy import select
+from slowapi import _rate_limit_exceeded_handler
+from slowapi.errors import RateLimitExceeded
 
 from app.config import settings
 from app.database import init_db, AsyncSessionLocal
+from app.limiter import limiter
 from app.routers import auth, users, entries, public, admin
 
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(name)s %(message)s",
+)
+logger = logging.getLogger("bourbonacci")
+
 
 async def _seed_admin() -> None:
     from app.models.user import User
@@ -33,14 +43,19 @@ async def _seed_admin() -> None:
 async def lifespan(app: FastAPI):
     await init_db()
     await _seed_admin()
+    logger.info("Bourbonacci started")
     yield
+    logger.info("Bourbonacci shutting down")
 
 
 app = FastAPI(title="Bourbonacci", lifespan=lifespan)
 
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
+    allow_origins=[o.strip() for o in settings.allowed_origins.split(",")],
     allow_methods=["*"],
     allow_headers=["*"],
 )
@@ -50,3 +65,8 @@ app.include_router(users.router)
 app.include_router(entries.router)
 app.include_router(public.router)
 app.include_router(admin.router)
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}

backend/app/routers/auth.py

@@ -1,17 +1,22 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+import logging
+
+from fastapi import APIRouter, Depends, HTTPException, Request, status
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 
 from app.dependencies import get_db
+from app.limiter import limiter
 from app.models.user import User
 from app.schemas.user import UserCreate, Token, LoginRequest
 from app.utils.security import hash_password, verify_password, create_token
 
+logger = logging.getLogger("bourbonacci.auth")
 router = APIRouter(prefix="/api/auth", tags=["auth"])
 
 
 @router.post("/register", response_model=Token, status_code=status.HTTP_201_CREATED)
-async def register(body: UserCreate, db: AsyncSession = Depends(get_db)):
+@limiter.limit("5/minute")
+async def register(request: Request, body: UserCreate, db: AsyncSession = Depends(get_db)):
     result = await db.execute(select(User).where(User.email == body.email))
     if result.scalar_one_or_none():
         raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Email already registered")
@@ -25,15 +30,19 @@ async def register(body: UserCreate, db: AsyncSession = Depends(get_db)):
     await db.commit()
     await db.refresh(user)
 
+    logger.info("New user registered: %s", body.email)
     return Token(access_token=create_token(user.id))
 
 
 @router.post("/login", response_model=Token)
-async def login(body: LoginRequest, db: AsyncSession = Depends(get_db)):
+@limiter.limit("10/minute")
+async def login(request: Request, body: LoginRequest, db: AsyncSession = Depends(get_db)):
     result = await db.execute(select(User).where(User.email == body.email))
     user = result.scalar_one_or_none()
 
     if not user or not verify_password(body.password, user.password_hash):
+        logger.warning("Failed login for: %s", body.email)
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
 
+    logger.info("Login: %s (id=%s)", body.email, user.id)
     return Token(access_token=create_token(user.id))

backend/app/routers/public.py

@@ -1,24 +1,28 @@
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, Request
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
+from sqlalchemy.orm import selectinload
 
 from app.dependencies import get_db
+from app.limiter import limiter
 from app.models.user import User
-from app.models.entry import Entry, EntryType
+from app.models.entry import EntryType
 from app.schemas.entry import PublicUserStats
 
 router = APIRouter(prefix="/api/public", tags=["public"])
 
 
 @router.get("/stats", response_model=list[PublicUserStats])
-async def public_stats(db: AsyncSession = Depends(get_db)):
-    users_result = await db.execute(select(User))
+@limiter.limit("30/minute")
+async def public_stats(request: Request, db: AsyncSession = Depends(get_db)):
+    users_result = await db.execute(
+        select(User).options(selectinload(User.entries))
+    )
     users = users_result.scalars().all()
 
     stats: list[PublicUserStats] = []
     for user in users:
-        entries_result = await db.execute(select(Entry).where(Entry.user_id == user.id))
-        entries = entries_result.scalars().all()
+        entries = user.entries
 
         adds = [e for e in entries if e.entry_type == EntryType.add]
         removes = [e for e in entries if e.entry_type == EntryType.remove]