C

app/db/database.py

@@ -1,43 +1,118 @@
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
 from sqlalchemy.orm import sessionmaker
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.pool import QueuePool
+from fastapi import HTTPException
+import asyncio
+import logging
 from app.db.models import Base
 
-# Use SQLite with aiosqlite
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Use SQLite with aiosqlite and connection pooling
 DATABASE_URL = "sqlite+aiosqlite:///./sql_app.db"
 
-engine = create_async_engine(DATABASE_URL, echo=True)
-AsyncSessionLocal = sessionmaker(
-    engine, class_=AsyncSession, expire_on_commit=False
+# Configure the engine with connection pooling and timeouts
+engine = create_async_engine(
+    DATABASE_URL,
+    echo=True,
+    pool_size=20,  # Maximum number of connections in the pool
+    max_overflow=10,  # Maximum number of connections that can be created beyond pool_size
+    pool_timeout=30,  # Timeout for getting a connection from the pool
+    pool_recycle=1800,  # Recycle connections after 30 minutes
+    pool_pre_ping=True,  # Enable connection health checks
+    poolclass=QueuePool
 )
 
+# Configure session with retry logic
+AsyncSessionLocal = sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False
+)
 
-async def database_exists(conn) -> bool:
-    """Check if any tables exist in the database."""
-    result = await conn.run_sync(lambda sync_conn: sync_conn.dialect.has_table(sync_conn, "your_table_name"))
-    return result
-
-
-async def init_db():
-    async with engine.begin() as conn:
-        # Check if the database already has tables
-        if not await database_exists(conn):
-            print("Initializing database: Creating tables...")
-            await conn.run_sync(Base.metadata.create_all)
-        else:
-            print("Database already exists. Skipping initialization.")
-            
-            
+# Semaphore to limit concurrent database operations
+MAX_CONCURRENT_DB_OPS = 10
+db_semaphore = asyncio.Semaphore(MAX_CONCURRENT_DB_OPS)
 
 async def get_db() -> AsyncSession:
-    async with AsyncSessionLocal() as session:
+    async with db_semaphore:  # Limit concurrent database operations
+        session = AsyncSessionLocal()
         try:
             yield session
-            await session.commit()
-        except Exception:
+        except SQLAlchemyError as e:
+            logger.error(f"Database error: {str(e)}")
             await session.rollback()
-            raise
+            raise HTTPException(
+                status_code=503,
+                detail="Database service temporarily unavailable. Please try again."
+            )
+        except Exception as e:
+            logger.error(f"Unexpected error: {str(e)}")
+            await session.rollback()
+            raise HTTPException(
+                status_code=500,
+                detail="An unexpected error occurred. Please try again."
+            )
         finally:
             await session.close()
+
+# Rate limiting configuration
+from fastapi import Request
+import time
+from collections import defaultdict
+
+class RateLimiter:
+    def __init__(self, requests_per_minute=60):
+        self.requests_per_minute = requests_per_minute
+        self.requests = defaultdict(list)
+    
+    def is_allowed(self, client_ip: str) -> bool:
+        now = time.time()
+        minute_ago = now - 60
+        
+        # Clean old requests
+        self.requests[client_ip] = [req_time for req_time in self.requests[client_ip] 
+                                  if req_time > minute_ago]
+        
+        # Check if allowed
+        if len(self.requests[client_ip]) >= self.requests_per_minute:
+            return False
+        
+        # Add new request
+        self.requests[client_ip].append(now)
+        return True
+
+rate_limiter = RateLimiter(requests_per_minute=60)
+
+# Add this to your database initialization
+async def init_db():
+    try:
+        async with engine.begin() as conn:
+            # Check if the database already has tables
+            if not await database_exists(conn):
+                logger.info("Initializing database: Creating tables...")
+                await conn.run_sync(Base.metadata.create_all)
+                logger.info("Database initialization completed successfully")
+            else:
+                logger.info("Database already exists. Skipping initialization.")
+    except Exception as e:
+        logger.error(f"Error initializing database: {str(e)}")
+        raise
+
+async def database_exists(conn) -> bool:
+    """Check if any tables exist in the database."""
+    try:
+        result = await conn.run_sync(
+            lambda sync_conn: sync_conn.dialect.has_table(sync_conn, "invoices")
+        )
+        return result
+    except Exception as e:
+        logger.error(f"Error checking database existence: {str(e)}")
+        return False
             
             
+
 ###sdf

app/main.py

@@ -1,11 +1,19 @@
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, HTTPException
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from .routes import invoices
-from app.db.database import init_db
+from app.db.database import init_db, rate_limiter
 import os
 from fastapi.middleware.cors import CORSMiddleware
+from starlette.middleware.base import BaseHTTPMiddleware
 from dotenv import load_dotenv
+import logging
+from typing import Callable
+import time
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # Load environment variables
 load_dotenv()
@@ -13,6 +21,32 @@ load_dotenv()
 # Get the absolute path to the app directory
 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
+class RateLimitMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next: Callable):
+        # Get client IP
+        client_ip = request.client.host
+        
+        # Check rate limit
+        if not rate_limiter.is_allowed(client_ip):
+            logger.warning(f"Rate limit exceeded for IP: {client_ip}")
+            raise HTTPException(
+                status_code=429,
+                detail="Too many requests. Please try again later."
+            )
+        
+        # Process request
+        start_time = time.time()
+        response = await call_next(request)
+        process_time = time.time() - start_time
+        
+        # Log request details
+        logger.info(
+            f"Request: {request.method} {request.url.path} "
+            f"Client: {client_ip} "
+            f"Process time: {process_time:.2f}s"
+        )
+        
+        return response
 
 app = FastAPI(
     title="Invoice Generator",
@@ -20,13 +54,17 @@ app = FastAPI(
     version="1.0.0"
 )
 
-# Configure CORS
+# Add rate limiting middleware
+app.add_middleware(RateLimitMiddleware)
+
+# Configure CORS with more specific settings
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # In production, replace with your frontend domain
+    allow_origins=["*"],  # In production, replace with specific domains
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
+    max_age=3600,  # Cache preflight requests for 1 hour
 )
 
 # Mount static files with absolute path
@@ -40,7 +78,13 @@ app.include_router(invoices.router)
 
 @app.on_event("startup")
 async def startup_event():
+    logger.info("Starting application...")
     await init_db()
+    logger.info("Application started successfully")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    logger.info("Shutting down application...")
 
 # Root endpoint to serve the HTML page
 @app.get("/")
@@ -50,7 +94,7 @@ async def root(request: Request):
 # Health check endpoint
 @app.get("/health")
 async def health_check():
-    return {"status": "healthy"}
+    return {"status": "healthy", "timestamp": time.time()}
 
 @app.get("/history")
 async def history_page(request: Request):

app/routes/invoices.py

@@ -23,64 +23,64 @@ async def create_new_invoice(
     db: AsyncSession = Depends(get_db)
 ):
     try:
-        # Get current max ID
-        query = select(func.max(Invoice.id))
-        result = await db.execute(query)
-        current_max_id = result.scalar() or 0
-        next_id = current_max_id + 1
-        
-        # Extract client type from the invoice number
-        client_type = invoice.invoice_number.split('/')[1]
-        
-        # Create new invoice number
-        new_invoice_number = f"DCP/{client_type}/{next_id:04d}"
-        
-        # Create invoice with the new number
-        db_invoice = Invoice(
-            id=next_id,
-            invoice_number=new_invoice_number,
-            date=invoice.date,
-            project=invoice.project,
-            client_name=invoice.client_name,
-            client_phone=invoice.client_phone,
-            address=invoice.address,
-            total_ht=invoice.total_ht,
-            tax=invoice.tax,
-            total_ttc=invoice.total_ttc,
-            frame_number=invoice.frame_number,
-            commercial=invoice.commercial
-        )
-        
-        db.add(db_invoice)
-        await db.commit()
-        await db.refresh(db_invoice)
-        
-        # Create invoice items
-        for item_data in invoice.items:
-            db_item = InvoiceItem(
-                invoice_id=db_invoice.id,
-                description=item_data.description,
-                unit=item_data.unit,
-                quantity=item_data.quantity,
-                length=item_data.length,
-                unit_price=item_data.unit_price,
-                total_price=item_data.total_price
+        async with db.begin():
+            # Get current max ID
+            query = select(func.max(Invoice.id))
+            result = await db.execute(query)
+            current_max_id = result.scalar() or 0
+            next_id = current_max_id + 1
+            
+            # Extract client type from the invoice number
+            client_type = invoice.invoice_number.split('/')[1]
+            
+            # Create new invoice number
+            new_invoice_number = f"DCP/{client_type}/{next_id:04d}"
+            
+            # Create invoice with the new number
+            db_invoice = Invoice(
+                id=next_id,
+                invoice_number=new_invoice_number,
+                date=invoice.date,
+                project=invoice.project,
+                client_name=invoice.client_name,
+                client_phone=invoice.client_phone,
+                address=invoice.address,
+                ville=invoice.ville,
+                total_ht=invoice.total_ht,
+                tax=invoice.tax,
+                total_ttc=invoice.total_ttc,
+                frame_number=invoice.frame_number,
+                commercial=invoice.commercial
             )
-            db.add(db_item)
-
-        await db.commit()
-        await db.refresh(db_invoice)
-        
-        # Explicitly load the items relationship
-        result = await db.execute(
-            select(Invoice)
-            .options(selectinload(Invoice.items))
-            .filter(Invoice.id == db_invoice.id)
-        )
-        return result.scalar_one()
+            
+            # Create all invoice items
+            db_items = [
+                InvoiceItem(
+                    invoice_id=next_id,
+                    description=item_data.description,
+                    unit=item_data.unit,
+                    quantity=item_data.quantity,
+                    length=item_data.length,
+                    unit_price=item_data.unit_price,
+                    total_price=item_data.total_price
+                )
+                for item_data in invoice.items
+            ]
+            
+            # Add all objects to the session
+            db.add(db_invoice)
+            db.add_all(db_items)
+            await db.flush()
 
+            # Query the complete invoice with items
+            query = select(Invoice).options(selectinload(Invoice.items)).filter(Invoice.id == next_id)
+            result = await db.execute(query)
+            complete_invoice = result.scalar_one()
+            
+            return complete_invoice
+            
     except Exception as e:
-        await db.rollback()
+        logger.error(f"Error creating invoice: {str(e)}", exc_info=True)
         raise HTTPException(status_code=500, detail=str(e))
 
 @router.get("/{invoice_id}", response_model=InvoiceResponse)