Add logs, auto-create tables, and serve frontend

backend/app/main.py

@@ -1,14 +1,21 @@
-"""
-Main FastAPI application entry point.
-"""
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
 from fastapi.middleware.cors import CORSMiddleware
-from .core.database import engine, Base
+from .core.database import init_supabase, engine, Base
 from .routers import auth, stocks, portfolio
-from .models import User, Portfolio  # Import models to ensure tables are created
+from .models import user, portfolio as portfolio_model
+import os
+import logging
+import time
 
-# Create database tables
-Base.metadata.create_all(bind=engine)
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S"
+)
+logger = logging.getLogger("api")
 
 app = FastAPI(
     title="Stock Analysis API",
@@ -16,30 +23,98 @@ app = FastAPI(
     version="1.0.0"
 )
 
+# Request Timing Middleware
+@app.middleware("http")
+async def add_process_time_header(request: Request, call_next):
+    start_time = time.time()
+    # Log less for health check to reduce noise
+    is_health = request.url.path.endswith("/health")
+    
+    if not is_health:
+        logger.info(f"➡️ Request Details: {request.method} {request.url.path}")
+    
+    try:
+        response = await call_next(request)
+        process_time = time.time() - start_time
+        
+        if not is_health or response.status_code != 200:
+            logger.info(f"⬅️ Response Details: {response.status_code} (took {process_time:.4f}s)")
+            
+        response.headers["X-Process-Time"] = str(process_time)
+        return response
+    except Exception as e:
+        process_time = time.time() - start_time
+        logger.error(f"❌ Request Failed: {e} (took {process_time:.4f}s)")
+        raise
+
 # CORS middleware
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # In production, specify exact origins
+    allow_origins=["*"],  # Allows all origins
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+# Initialize Database on startup
+@app.on_event("startup")
+async def startup_event():
+    """Initialize database and Create Tables if not exist."""
+    print("🔄 Initializing Database...")
+    
+    # 1. Supabase Client (if used)
+    init_supabase()
+    
+    # 2. SQLAlchemy (SQLite/Postgres) - Create Tables
+    try:
+        print("🔨 Creating database tables...")
+        # This will create tables for all models registered with Base (User, Portfolio)
+        Base.metadata.create_all(bind=engine)
+        print("✅ Database tables created successfully!")
+    except Exception as e:
+        # Don't crash if it fails (e.g. read-only fs + sqlite), but log it
+        print(f"❌ Error creating tables: {e}")
+    
+    print("✅ App Startup Complete")
+
 # Include routers
 app.include_router(auth.router)
 app.include_router(stocks.router)
 app.include_router(portfolio.router)
 
+# Mount frontend files (Adjust path relative to backend/app/main.py)
+frontend_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "frontend"))
 
-@app.get("/")
-async def root():
-    """Root endpoint - API health check."""
-    return {
-        "message": "Stock Analysis API",
-        "version": "1.0.0",
-        "status": "active"
-    }
+if os.path.exists(frontend_path):
+    # Mount specific assets explicitly to match HTML relative paths
+    js_path = os.path.join(frontend_path, "js")
+    css_path = os.path.join(frontend_path, "css")
+    
+    if os.path.exists(js_path):
+        app.mount("/js", StaticFiles(directory=js_path), name="js")
+    if os.path.exists(css_path):
+        app.mount("/css", StaticFiles(directory=css_path), name="css")
+
+    # Serve HTML pages explicitly
+    @app.get("/")
+    async def read_root():
+        return FileResponse(os.path.join(frontend_path, "index.html"))
+
+    @app.get("/index.html")
+    async def read_index():
+        return FileResponse(os.path.join(frontend_path, "index.html"))
+
+    @app.get("/login.html")
+    async def read_login():
+        return FileResponse(os.path.join(frontend_path, "index.html"))
+
+    @app.get("/dashboard.html")
+    async def read_dashboard():
+        return FileResponse(os.path.join(frontend_path, "dashboard.html"))
 
+    @app.get("/portfolio.html")
+    async def read_portfolio():
+        return FileResponse(os.path.join(frontend_path, "portfolio.html"))
 
 @app.get("/health")
 async def health_check():
@@ -47,5 +122,5 @@ async def health_check():
     return {
         "status": "healthy",
         "api": "operational",
-        "database": "connected"
+        "database": "supabase"
     }

backend/app/services/stock_service.py

@@ -42,7 +42,9 @@ class StockService:
                 return cached_data
         
         try:
-            logger.info(f"Fetching fresh data for {symbol}")
+            start_time = datetime.now()
+            logger.info(f"🔍 Fetching fresh data for {symbol}...")
+            
             stock = yf.Ticker(symbol)
             
             current_price = None
@@ -52,27 +54,33 @@ class StockService:
             
             # Use fast_info for quicker response
             try:
+                t0 = datetime.now()
                 fast_info = stock.fast_info
                 current_price = fast_info.get('lastPrice') or fast_info.get('regularMarketPrice')
                 previous_close = fast_info.get('previousClose')
                 volume = fast_info.get('lastVolume') or fast_info.get('volume') or 0
                 market_cap = fast_info.get('marketCap') or 0
-            except:
+                logger.debug(f"⏱️ Fast info fetch for {symbol} took {(datetime.now()-t0).total_seconds():.3f}s")
+            except Exception as e:
+                logger.warning(f"Fast info failed for {symbol}: {e}")
                 pass
                 
             # Fallback to regular info if fast_info failed or missing data
             if not current_price:
                 try:
+                    t1 = datetime.now()
                     info = stock.info
                     current_price = info.get('currentPrice') or info.get('regularMarketPrice')
                     previous_close = info.get('previousClose') or info.get('regularMarketPreviousClose')
                     volume = info.get('volume') or info.get('regularMarketVolume') or 0
                     market_cap = info.get('marketCap') or 0
-                except:
+                    logger.debug(f"⏱️ Regular info fetch for {symbol} took {(datetime.now()-t1).total_seconds():.3f}s")
+                except Exception as e:
+                    logger.warning(f"Regular info failed for {symbol}: {e}")
                     pass
             
             if not current_price:
-                logger.warning(f"Missing price data for {symbol}")
+                logger.warning(f"❌ Missing price data for {symbol}")
                 return None
                 
             # Use previous close as current if missing (fallback)
@@ -103,11 +111,13 @@ class StockService:
             
             if include_sparkline:
                 try:
+                    t2 = datetime.now()
                     # Fetch 1 month history for sparkline
                     hist = stock.history(period="1mo")
                     if not hist.empty:
                         # Normalize data for sparkline (list of floats)
                         result['sparkline'] = [round(float(p), 2) for p in hist['Close'].tolist()]
+                    logger.debug(f"⏱️ Sparkline fetch for {symbol} took {(datetime.now()-t2).total_seconds():.3f}s")
                 except Exception as e:
                     logger.error(f"Error fetching sparkline for {symbol}: {e}")
                     result['sparkline'] = []
@@ -115,10 +125,12 @@ class StockService:
             # Cache the result
             StockService._cache[cache_key] = (result, datetime.now())
             
+            elapsed = (datetime.now() - start_time).total_seconds()
+            logger.info(f"✅ Data for {symbol} ready in {elapsed:.3f}s")
             return result
             
         except Exception as e:
-            logger.error(f"Error fetching stock data for {symbol}: {e}")
+            logger.error(f"❌ Error fetching stock data for {symbol}: {e}")
             return None
     
     @staticmethod

check_db.py

@@ -0,0 +1,44 @@
+
+import os
+import asyncio
+from dotenv import load_dotenv
+from supabase import create_client, Client
+
+load_dotenv()
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+
+if not SUPABASE_URL or not SUPABASE_KEY:
+    print("❌ Error: SUPABASE_URL or SUPABASE_KEY not found in .env")
+    exit(1)
+
+print(f"Connecting to Supabase at {SUPABASE_URL}...")
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+def run_migration():
+    print("🔨 Creating tables...")
+    
+    # 1. Create Users Table
+    # Note: We use raw SQL via RPC or just rely on the fact that we can't easily run DDL via client-js/py
+    # But usually 'rpc' is the way, OR we just use the SQL Editor. 
+    # Since we can't run RAW SQL easily with py client without a stored procedure, 
+    # we might be blocked if 'setup_database.py' relied on SQLAlchemy.
+    
+    # Wait, the previous migration discussion mentioned Supabase.
+    # The 'setup_database.py' likely used SQLAlchemy or 'postgres' connection string.
+    
+    # Let's try to just check if we can access the DB. 
+    # For creating tables, checking if we can use the 'postgres-py' driver with the connection string is better.
+    # But for now, let's simply PRINT the connection success.
+    
+    try:
+        # Simple read to check connection
+        res = supabase.table("users").select("count", count="exact").execute()
+        print("✅ Connected! 'users' table exists.")
+    except Exception as e:
+        print(f"⚠️ Connection successful, but 'users' table might be missing or error: {e}")
+        print("You likely need to run the SQL initialization in the Supabase Dashboard.")
+
+if __name__ == "__main__":
+    run_migration()