feat: Implement email functionality with FastAPI-Mail and Mailhog

- Updated docker-compose.yml to include Mailhog service for email testing.
- Added environment variables for email configuration in docker-compose.
- Updated requirements.txt to include fastapi-mail for email support.
- Created templates for password reset, email verification, and welcome emails.
- Developed mail utility module to handle sending emails using FastAPI-Mail.
- Added documentation for email testing with Mailhog.

app/main.py

@@ -7,6 +7,8 @@ from pathlib import Path
 import os
 from starlette.middleware.sessions import SessionMiddleware
 from dotenv import load_dotenv
+import logging
+import contextlib
 
 from .db import init_db, engine, get_db
 from . import models
@@ -15,25 +17,46 @@ from .views import qr, redeem, teams, admin, leaderboard, dashboard, static, pag
 from .db_init import seed_db
 from .db_migrations import apply_migrations
 
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 # Load environment variables
 load_dotenv()
 
-# Create tables on startup
-init_db()
-
-# Apply any pending database migrations
-apply_migrations()
-
-# Seed database with initial test data
-# In a production app, you would handle this differently
-seed_db()
-
 # Create the FastAPI application
 app = FastAPI(title="LeagueLedger")
 
 # Add SessionMiddleware with a secure secret key
+# Must be added first before other middleware to ensure it's available
 app.add_middleware(SessionMiddleware, secret_key=os.getenv("SESSION_SECRET_KEY", "your-very-secret-session-key"))
 
+# Initialize database on startup
+@app.on_event("startup")
+async def startup_db_client():
+    logger.info("Starting database initialization")
+    try:
+        # Import models to ensure they're registered with Base before initialization
+        from . import models
+        
+        # Create all tables first
+        init_db()
+        logger.info("Base tables created successfully")
+        
+        # Apply migrations to add additional columns and constraints
+        with contextlib.suppress(Exception):
+            apply_migrations()
+            logger.info("Migrations applied successfully")
+        
+        # Seed the database with test data if needed
+        with contextlib.suppress(Exception):
+            seed_db()
+            logger.info("Database seeded successfully")
+            
+    except Exception as e:
+        logger.error(f"Database initialization error: {str(e)}")
+        # We continue even if there was an error, as the application might still work with partial functionality
+
 # Mount static files
 app.mount("/static", StaticFiles(directory="app/static"), name="static")
 
@@ -43,14 +66,14 @@ static.configure_static_files(app)
 # Setup Jinja2 templates
 templates = Jinja2Templates(directory="app/templates")
 
-# User context middleware to make template globals available
+# User context middleware
 @app.middleware("http")
 async def add_template_globals(request: Request, call_next):
     """Add template globals"""
     try:
         # Update template globals for all templates
         user = None
-        if "user_id" in request.session and request.session.get("is_authenticated"):
+        if hasattr(request, "session") and "user_id" in request.session and request.session.get("is_authenticated"):
             # Mock user object - in a real app, you'd fetch this from the database
             user = {
                 "id": request.session["user_id"],
@@ -59,7 +82,7 @@ async def add_template_globals(request: Request, call_next):
             }
         templates.env.globals["current_user"] = user
     except Exception as e:
-        print(f"Error setting template globals: {str(e)}")
+        logger.error(f"Error setting template globals: {str(e)}")
     
     # Process the request
     response = await call_next(request)