Comprehensive comparison for Backend technology in applications

from fastapi import FastAPI, HTTPException, Depends, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from pydantic import BaseModel, Field, validator
from typing import Optional, List
from datetime import datetime
import uuid

app = FastAPI(title="Product Management API")
security = HTTPBearer()

# Mock database
products_db = {}
users_db = {"valid_token_123": {"user_id": "user_1", "role": "admin"}}

# Pydantic models for request/response validation
class ProductBase(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    description: Optional[str] = Field(None, max_length=500)
    price: float = Field(..., gt=0, description="Price must be greater than 0")
    stock: int = Field(..., ge=0, description="Stock cannot be negative")
    category: str = Field(..., min_length=1)

    @validator('price')
    def validate_price(cls, v):
        if v > 1000000:
            raise ValueError('Price exceeds maximum allowed value')
        return round(v, 2)

class ProductCreate(ProductBase):
    pass

class ProductUpdate(BaseModel):
    name: Optional[str] = Field(None, min_length=1, max_length=100)
    description: Optional[str] = Field(None, max_length=500)
    price: Optional[float] = Field(None, gt=0)
    stock: Optional[int] = Field(None, ge=0)
    category: Optional[str] = None

class ProductResponse(ProductBase):
    id: str
    created_at: datetime
    updated_at: datetime

    class Config:
        json_encoders = {datetime: lambda v: v.isoformat()}

# Dependency for authentication
async def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
    token = credentials.credentials
    user = users_db.get(token)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid authentication credentials",
            headers={"WWW-Authenticate": "Bearer"},
        )
    return user

# Create product endpoint
@app.post("/api/v1/products", response_model=ProductResponse, status_code=status.HTTP_201_CREATED)
async def create_product(product: ProductCreate, user: dict = Depends(verify_token)):
    """Create a new product with validation and authentication."""
    if user.get("role") != "admin":
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Only admins can create products"
        )
    
    product_id = str(uuid.uuid4())
    now = datetime.utcnow()
    
    product_data = {
        "id": product_id,
        **product.dict(),
        "created_at": now,
        "updated_at": now
    }
    
    products_db[product_id] = product_data
    return ProductResponse(**product_data)

# Get product by ID
@app.get("/api/v1/products/{product_id}", response_model=ProductResponse)
async def get_product(product_id: str):
    """Retrieve a product by ID with error handling."""
    product = products_db.get(product_id)
    if not product:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"Product with id {product_id} not found"
        )
    return ProductResponse(**product)

# Update product
@app.patch("/api/v1/products/{product_id}", response_model=ProductResponse)
async def update_product(
    product_id: str,
    product_update: ProductUpdate,
    user: dict = Depends(verify_token)
):
    """Partially update a product with validation."""
    if user.get("role") != "admin":
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Only admins can update products"
        )
    
    existing_product = products_db.get(product_id)
    if not existing_product:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"Product with id {product_id} not found"
        )
    
    update_data = product_update.dict(exclude_unset=True)
    if not update_data:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="No valid fields provided for update"
        )
    
    existing_product.update(update_data)
    existing_product["updated_at"] = datetime.utcnow()
    products_db[product_id] = existing_product
    
    return ProductResponse(**existing_product)

# List products with filtering
@app.get("/api/v1/products", response_model=List[ProductResponse])
async def list_products(
    category: Optional[str] = None,
    min_price: Optional[float] = None,
    max_price: Optional[float] = None,
    limit: int = Field(default=10, ge=1, le=100)
):
    """List products with optional filtering and pagination."""
    filtered_products = list(products_db.values())
    
    if category:
        filtered_products = [p for p in filtered_products if p["category"] == category]
    if min_price is not None:
        filtered_products = [p for p in filtered_products if p["price"] >= min_price]
    if max_price is not None:
        filtered_products = [p for p in filtered_products if p["price"] <= max_price]
    
    return [ProductResponse(**p) for p in filtered_products[:limit]]

# Delete product
@app.delete("/api/v1/products/{product_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_product(product_id: str, user: dict = Depends(verify_token)):
    """Delete a product by ID with authorization check."""
    if user.get("role") != "admin":
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Only admins can delete products"
        )
    
    if product_id not in products_db:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"Product with id {product_id} not found"
        )
    
    del products_db[product_id]
    return None