fastapi-fullstack 0.1.2__py3-none-any.whl

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/api/routes/v1/conversations.py

@@ -0,0 +1,490 @@
+{%- if cookiecutter.enable_conversation_persistence %}
+"""Conversation API routes for AI chat persistence.
+
+Provides CRUD operations for conversations and messages.
+
+The endpoints are:
+- GET /conversations - List user's conversations
+- POST /conversations - Create a new conversation
+- GET /conversations/{id} - Get a conversation with messages
+- PATCH /conversations/{id} - Update conversation title/archived status
+- DELETE /conversations/{id} - Delete a conversation
+- POST /conversations/{id}/messages - Add a message to conversation
+- GET /conversations/{id}/messages - List messages in conversation
+"""
+
+{%- if cookiecutter.use_postgresql %}
+from uuid import UUID
+{%- endif %}
+
+from fastapi import APIRouter, Query, status
+
+{%- if cookiecutter.use_mongodb %}
+from app.api.deps import ConversationSvc
+{%- else %}
+from app.api.deps import DBSession, ConversationSvc
+{%- endif %}
+{%- if cookiecutter.use_jwt %}
+from app.api.deps import CurrentUser
+{%- endif %}
+from app.schemas.conversation import (
+    ConversationCreate,
+    ConversationRead,
+    ConversationReadWithMessages,
+    ConversationUpdate,
+    MessageCreate,
+    MessageRead,
+    MessageReadSimple,
+)
+
+router = APIRouter()
+
+
+{%- if cookiecutter.use_postgresql %}
+
+
+@router.get("", response_model=list[ConversationRead])
+async def list_conversations(
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+    skip: int = Query(0, ge=0, description="Number of conversations to skip"),
+    limit: int = Query(50, ge=1, le=100, description="Maximum conversations to return"),
+    include_archived: bool = Query(False, description="Include archived conversations"),
+):
+    """List conversations for the current user.
+
+    Returns conversations ordered by most recently updated.
+    """
+    return await conversation_service.list_conversations(
+{%- if cookiecutter.use_jwt %}
+        user_id=current_user.id,
+{%- endif %}
+        skip=skip,
+        limit=limit,
+        include_archived=include_archived,
+    )
+
+
+@router.post("", response_model=ConversationRead, status_code=status.HTTP_201_CREATED)
+async def create_conversation(
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+    data: ConversationCreate | None = None,
+):
+    """Create a new conversation.
+
+    The title is optional and can be set later.
+    """
+    if data is None:
+        data = ConversationCreate()
+{%- if cookiecutter.use_jwt %}
+    data.user_id = current_user.id
+{%- endif %}
+    return await conversation_service.create_conversation(data)
+
+
+@router.get("/{conversation_id}", response_model=ConversationReadWithMessages)
+async def get_conversation(
+    conversation_id: UUID,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Get a conversation with all its messages.
+
+    Raises 404 if the conversation does not exist.
+    """
+    return await conversation_service.get_conversation(conversation_id, include_messages=True)
+
+
+@router.patch("/{conversation_id}", response_model=ConversationRead)
+async def update_conversation(
+    conversation_id: UUID,
+    data: ConversationUpdate,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Update a conversation's title or archived status.
+
+    Raises 404 if the conversation does not exist.
+    """
+    return await conversation_service.update_conversation(conversation_id, data)
+
+
+@router.delete("/{conversation_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_conversation(
+    conversation_id: UUID,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Delete a conversation and all its messages.
+
+    Raises 404 if the conversation does not exist.
+    """
+    await conversation_service.delete_conversation(conversation_id)
+
+
+@router.post(
+    "/{conversation_id}/archive",
+    response_model=ConversationRead,
+)
+async def archive_conversation(
+    conversation_id: UUID,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Archive a conversation.
+
+    Archived conversations are hidden from the default list view.
+    """
+    return await conversation_service.archive_conversation(conversation_id)
+
+
+@router.get("/{conversation_id}/messages", response_model=list[MessageReadSimple])
+async def list_messages(
+    conversation_id: UUID,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+    skip: int = Query(0, ge=0),
+    limit: int = Query(100, ge=1, le=500),
+):
+    """List messages in a conversation.
+
+    Returns messages ordered by creation time (oldest first).
+    """
+    return await conversation_service.list_messages(conversation_id, skip=skip, limit=limit)
+
+
+@router.post(
+    "/{conversation_id}/messages",
+    response_model=MessageRead,
+    status_code=status.HTTP_201_CREATED,
+)
+async def add_message(
+    conversation_id: UUID,
+    data: MessageCreate,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Add a message to a conversation.
+
+    Raises 404 if the conversation does not exist.
+    """
+    return await conversation_service.add_message(conversation_id, data)
+
+
+{%- elif cookiecutter.use_sqlite %}
+
+
+@router.get("", response_model=list[ConversationRead])
+def list_conversations(
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+    skip: int = Query(0, ge=0, description="Number of conversations to skip"),
+    limit: int = Query(50, ge=1, le=100, description="Maximum conversations to return"),
+    include_archived: bool = Query(False, description="Include archived conversations"),
+):
+    """List conversations for the current user.
+
+    Returns conversations ordered by most recently updated.
+    """
+    return conversation_service.list_conversations(
+{%- if cookiecutter.use_jwt %}
+        user_id=str(current_user.id),
+{%- endif %}
+        skip=skip,
+        limit=limit,
+        include_archived=include_archived,
+    )
+
+
+@router.post("", response_model=ConversationRead, status_code=status.HTTP_201_CREATED)
+def create_conversation(
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+    data: ConversationCreate | None = None,
+):
+    """Create a new conversation.
+
+    The title is optional and can be set later.
+    """
+    if data is None:
+        data = ConversationCreate()
+{%- if cookiecutter.use_jwt %}
+    data.user_id = str(current_user.id)
+{%- endif %}
+    return conversation_service.create_conversation(data)
+
+
+@router.get("/{conversation_id}", response_model=ConversationReadWithMessages)
+def get_conversation(
+    conversation_id: str,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Get a conversation with all its messages.
+
+    Raises 404 if the conversation does not exist.
+    """
+    return conversation_service.get_conversation(conversation_id, include_messages=True)
+
+
+@router.patch("/{conversation_id}", response_model=ConversationRead)
+def update_conversation(
+    conversation_id: str,
+    data: ConversationUpdate,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Update a conversation's title or archived status.
+
+    Raises 404 if the conversation does not exist.
+    """
+    return conversation_service.update_conversation(conversation_id, data)
+
+
+@router.delete("/{conversation_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_conversation(
+    conversation_id: str,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Delete a conversation and all its messages.
+
+    Raises 404 if the conversation does not exist.
+    """
+    conversation_service.delete_conversation(conversation_id)
+
+
+@router.post(
+    "/{conversation_id}/archive",
+    response_model=ConversationRead,
+)
+def archive_conversation(
+    conversation_id: str,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Archive a conversation.
+
+    Archived conversations are hidden from the default list view.
+    """
+    return conversation_service.archive_conversation(conversation_id)
+
+
+@router.get("/{conversation_id}/messages", response_model=list[MessageReadSimple])
+def list_messages(
+    conversation_id: str,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+    skip: int = Query(0, ge=0),
+    limit: int = Query(100, ge=1, le=500),
+):
+    """List messages in a conversation.
+
+    Returns messages ordered by creation time (oldest first).
+    """
+    return conversation_service.list_messages(conversation_id, skip=skip, limit=limit)
+
+
+@router.post(
+    "/{conversation_id}/messages",
+    response_model=MessageRead,
+    status_code=status.HTTP_201_CREATED,
+)
+def add_message(
+    conversation_id: str,
+    data: MessageCreate,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Add a message to a conversation.
+
+    Raises 404 if the conversation does not exist.
+    """
+    return conversation_service.add_message(conversation_id, data)
+
+
+{%- elif cookiecutter.use_mongodb %}
+
+
+@router.get("", response_model=list[ConversationRead])
+async def list_conversations(
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+    skip: int = Query(0, ge=0, description="Number of conversations to skip"),
+    limit: int = Query(50, ge=1, le=100, description="Maximum conversations to return"),
+    include_archived: bool = Query(False, description="Include archived conversations"),
+):
+    """List conversations for the current user.
+
+    Returns conversations ordered by most recently updated.
+    """
+    return await conversation_service.list_conversations(
+{%- if cookiecutter.use_jwt %}
+        user_id=str(current_user.id),
+{%- endif %}
+        skip=skip,
+        limit=limit,
+        include_archived=include_archived,
+    )
+
+
+@router.post("", response_model=ConversationRead, status_code=status.HTTP_201_CREATED)
+async def create_conversation(
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+    data: ConversationCreate | None = None,
+):
+    """Create a new conversation.
+
+    The title is optional and can be set later.
+    """
+    if data is None:
+        data = ConversationCreate()
+{%- if cookiecutter.use_jwt %}
+    data.user_id = str(current_user.id)
+{%- endif %}
+    return await conversation_service.create_conversation(data)
+
+
+@router.get("/{conversation_id}", response_model=ConversationReadWithMessages)
+async def get_conversation(
+    conversation_id: str,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Get a conversation with all its messages.
+
+    Raises 404 if the conversation does not exist.
+    """
+    return await conversation_service.get_conversation(conversation_id, include_messages=True)
+
+
+@router.patch("/{conversation_id}", response_model=ConversationRead)
+async def update_conversation(
+    conversation_id: str,
+    data: ConversationUpdate,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Update a conversation's title or archived status.
+
+    Raises 404 if the conversation does not exist.
+    """
+    return await conversation_service.update_conversation(conversation_id, data)
+
+
+@router.delete("/{conversation_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_conversation(
+    conversation_id: str,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Delete a conversation and all its messages.
+
+    Raises 404 if the conversation does not exist.
+    """
+    await conversation_service.delete_conversation(conversation_id)
+
+
+@router.post(
+    "/{conversation_id}/archive",
+    response_model=ConversationRead,
+)
+async def archive_conversation(
+    conversation_id: str,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Archive a conversation.
+
+    Archived conversations are hidden from the default list view.
+    """
+    return await conversation_service.archive_conversation(conversation_id)
+
+
+@router.get("/{conversation_id}/messages", response_model=list[MessageReadSimple])
+async def list_messages(
+    conversation_id: str,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+    skip: int = Query(0, ge=0),
+    limit: int = Query(100, ge=1, le=500),
+):
+    """List messages in a conversation.
+
+    Returns messages ordered by creation time (oldest first).
+    """
+    return await conversation_service.list_messages(conversation_id, skip=skip, limit=limit)
+
+
+@router.post(
+    "/{conversation_id}/messages",
+    response_model=MessageRead,
+    status_code=status.HTTP_201_CREATED,
+)
+async def add_message(
+    conversation_id: str,
+    data: MessageCreate,
+    conversation_service: ConversationSvc,
+{%- if cookiecutter.use_jwt %}
+    current_user: CurrentUser,
+{%- endif %}
+):
+    """Add a message to a conversation.
+
+    Raises 404 if the conversation does not exist.
+    """
+    return await conversation_service.add_message(conversation_id, data)
+
+
+{%- endif %}
+{%- else %}
+"""Conversation routes - not configured."""
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/backend/app/api/routes/v1/health.py

@@ -0,0 +1,227 @@
+"""Health check endpoints.
+
+Provides Kubernetes-compatible health check endpoints:
+- /health - Simple liveness check
+- /health/live - Detailed liveness probe
+- /health/ready - Readiness probe with dependency checks
+"""
+{%- if cookiecutter.use_database or cookiecutter.enable_redis %}
+# ruff: noqa: I001 - Imports structured for Jinja2 template conditionals
+{%- endif %}
+
+from datetime import UTC, datetime
+from typing import Any
+
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+{%- if cookiecutter.use_postgresql or cookiecutter.use_sqlite %}
+from sqlalchemy import text
+{%- endif %}
+
+from app.core.config import settings
+{%- if cookiecutter.use_database or cookiecutter.enable_redis %}
+from app.api.deps import {% if cookiecutter.use_database %}DBSession{% endif %}{% if cookiecutter.use_database and cookiecutter.enable_redis %}, {% endif %}{% if cookiecutter.enable_redis %}Redis{% endif %}
+
+{%- endif %}
+
+router = APIRouter()
+
+
+def _build_health_response(
+    status: str,
+    checks: dict[str, Any] | None = None,
+    details: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Build a structured health response."""
+    response: dict[str, Any] = {
+        "status": status,
+        "timestamp": datetime.now(UTC).isoformat(),
+        "service": settings.PROJECT_NAME,
+    }
+    if checks is not None:
+        response["checks"] = checks
+    if details is not None:
+        response["details"] = details
+    return response
+
+
+@router.get("/health")
+async def health_check() -> dict[str, str]:
+    """Simple liveness probe - check if application is running.
+
+    This is a lightweight check that should always succeed if the
+    application is running. Use this for basic connectivity tests.
+
+    Returns:
+        {"status": "healthy"}
+    """
+    return {"status": "healthy"}
+
+
+@router.get("/health/live")
+async def liveness_probe() -> dict[str, Any]:
+    """Detailed liveness probe for Kubernetes.
+
+    This endpoint is designed for Kubernetes liveness probes.
+    It checks if the application process is alive and responding.
+    Failure indicates the container should be restarted.
+
+    Returns:
+        Structured response with timestamp and service info.
+    """
+    return _build_health_response(
+        status="alive",
+        details={
+            "version": getattr(settings, "VERSION", "1.0.0"),
+            "environment": settings.ENVIRONMENT,
+        },
+    )
+
+
+@router.get("/health/ready", response_model=None)
+async def readiness_probe(
+{%- if cookiecutter.use_database %}
+    db: DBSession,
+{%- endif %}
+{%- if cookiecutter.enable_redis %}
+    redis: Redis,
+{%- endif %}
+) -> dict[str, Any] | JSONResponse:
+    """Readiness probe for Kubernetes.
+
+    This endpoint checks if all dependencies are ready to handle traffic.
+    It verifies database connections, Redis, and other critical services.
+    Failure indicates traffic should be temporarily diverted.
+
+    Checks performed:
+    {%- if cookiecutter.use_database %}
+    - Database connectivity
+    {%- endif %}
+    {%- if cookiecutter.enable_redis %}
+    - Redis connectivity
+    {%- endif %}
+
+    Returns:
+        Structured response with individual check results.
+        Returns 503 if any critical check fails.
+    """
+    checks: dict[str, dict[str, Any]] = {}
+
+{%- if cookiecutter.use_postgresql %}
+    # Database check
+    try:
+        start = datetime.now(UTC)
+        await db.execute(text("SELECT 1"))
+        latency_ms = (datetime.now(UTC) - start).total_seconds() * 1000
+        checks["database"] = {
+            "status": "healthy",
+            "latency_ms": round(latency_ms, 2),
+            "type": "postgresql",
+        }
+    except Exception as e:
+        checks["database"] = {
+            "status": "unhealthy",
+            "error": str(e),
+            "type": "postgresql",
+        }
+{%- endif %}
+
+{%- if cookiecutter.use_mongodb %}
+    # Database check
+    try:
+        start = datetime.now(UTC)
+        await db.command("ping")
+        latency_ms = (datetime.now(UTC) - start).total_seconds() * 1000
+        checks["database"] = {
+            "status": "healthy",
+            "latency_ms": round(latency_ms, 2),
+            "type": "mongodb",
+        }
+    except Exception as e:
+        checks["database"] = {
+            "status": "unhealthy",
+            "error": str(e),
+            "type": "mongodb",
+        }
+{%- endif %}
+
+{%- if cookiecutter.use_sqlite %}
+    # Database check
+    try:
+        start = datetime.now(UTC)
+        db.execute(text("SELECT 1"))
+        latency_ms = (datetime.now(UTC) - start).total_seconds() * 1000
+        checks["database"] = {
+            "status": "healthy",
+            "latency_ms": round(latency_ms, 2),
+            "type": "sqlite",
+        }
+    except Exception as e:
+        checks["database"] = {
+            "status": "unhealthy",
+            "error": str(e),
+            "type": "sqlite",
+        }
+{%- endif %}
+
+{%- if cookiecutter.enable_redis %}
+    # Redis check
+    try:
+        start = datetime.now(UTC)
+        is_healthy = await redis.ping()
+        latency_ms = (datetime.now(UTC) - start).total_seconds() * 1000
+        if is_healthy:
+            checks["redis"] = {
+                "status": "healthy",
+                "latency_ms": round(latency_ms, 2),
+            }
+        else:
+            checks["redis"] = {
+                "status": "unhealthy",
+                "error": "Ping failed",
+            }
+    except Exception as e:
+        checks["redis"] = {
+            "status": "unhealthy",
+            "error": str(e),
+        }
+{%- endif %}
+
+    # Determine overall health
+    all_healthy = all(
+        check.get("status") == "healthy" for check in checks.values()
+    ) if checks else True
+
+    response_data = _build_health_response(
+        status="ready" if all_healthy else "not_ready",
+        checks=checks,
+    )
+
+    if not all_healthy:
+        return JSONResponse(status_code=503, content=response_data)
+
+    return response_data
+
+
+# Backward compatibility - keep /ready endpoint
+@router.get("/ready", response_model=None)
+async def readiness_check(
+{%- if cookiecutter.use_database %}
+    db: DBSession,
+{%- endif %}
+{%- if cookiecutter.enable_redis %}
+    redis: Redis,
+{%- endif %}
+) -> dict[str, Any] | JSONResponse:
+    """Readiness check (alias for /health/ready).
+
+    Deprecated: Use /health/ready instead.
+    """
+    return await readiness_probe(
+{%- if cookiecutter.use_database %}
+        db=db,
+{%- endif %}
+{%- if cookiecutter.enable_redis %}
+        redis=redis,
+{%- endif %}
+    )