demo.py

#!/usr/bin/env python3
"""
Demo script showing the FastAPI Scaffold CLI structure
This demonstrates what the tool does without needing to install dependencies
"""

import sys
from pathlib import Path

# Add src to path
sys.path.insert(0, str(Path(__file__).parent / "src"))

from fastapi_scaffold.config import ProjectConfig, PresetType, DatabaseType, ORMType, AuthType, get_preset_config
from fastapi_scaffold.generator import ProjectGenerator

def demo_config():
    """Show different configuration options"""
    
    print("=" * 80)
    print("FastAPI Scaffold - Configuration Demo")
    print("=" * 80)
    
    # Show minimal preset
    print("\n1️⃣  MINIMAL PRESET")
    print("-" * 40)
    minimal = get_preset_config(PresetType.MINIMAL, "my-minimal-api")
    print(f"Project: {minimal.project_name}")
    print(f"Database: {minimal.database.value}")
    print(f"Auth: {minimal.auth.value}")
    print(f"Docker: {minimal.include_docker}")
    
    # Show SaaS preset
    print("\n2️⃣  SAAS PRESET (Full-Featured)")
    print("-" * 40)
    saas = get_preset_config(PresetType.SAAS, "my-saas-app")
    print(f"Project: {saas.project_name}")
    print(f"Database: {saas.database.value}")
    print(f"ORM: {saas.orm.value}")
    print(f"Auth: {saas.auth.value}")
    print(f"Cache: {saas.cache.value}")
    print(f"Task Queue: {saas.task_queue.value}")
    print(f"Docker: {saas.include_docker}")
    print(f"CI/CD: {saas.ci_type.value}")
    print(f"Monitoring: {saas.include_monitoring}")
    print(f"User Management: {saas.include_user_management}")
    
    # Show custom config
    print("\n3️⃣  CUSTOM CONFIGURATION")
    print("-" * 40)
    custom = ProjectConfig(
        project_name="My Custom API",
        project_slug="my-custom-api",
        description="A custom FastAPI project",
        database=DatabaseType.POSTGRES,
        orm=ORMType.SQLALCHEMY_ASYNC,
        auth=AuthType.JWT,
        include_docker=True,
        include_tests=True,
        include_ci=True,
    )
    print(f"Project: {custom.project_name}")
    print(f"Slug: {custom.project_slug}")
    print(f"Python Package: {custom.python_package_name}")
    print(f"Database: {custom.database.value}")
    print(f"ORM: {custom.orm.value}")
    print(f"Auth: {custom.auth.value}")

def demo_structure():
    """Show what directory structure would be created"""
    
    print("\n" + "=" * 80)
    print("Generated Project Structure")
    print("=" * 80)
    
    structure = """
my-project/
├── app/
│   ├── __init__.py
│   ├── main.py                 # FastAPI application entry point
│   ├── api/
│   │   ├── __init__.py
│   │   └── v1/
│   │       ├── __init__.py
│   │       ├── api.py          # Router aggregation
│   │       └── endpoints/
│   │           ├── __init__.py
│   │           ├── health.py   # Health check endpoints
│   │           ├── auth.py     # Authentication (if enabled)
│   │           └── users.py    # User management (if enabled)
│   ├── core/
│   │   ├── __init__.py
│   │   ├── config.py          # Pydantic settings
│   │   ├── security.py        # JWT & password hashing (if auth)
│   │   └── deps.py            # FastAPI dependencies
│   ├── models/
│   │   ├── __init__.py
│   │   ├── domain/            # Pydantic models
│   │   └── database/          # SQLAlchemy models (if DB)
│   ├── schemas/               # Request/Response schemas
│   │   └── __init__.py
│   ├── services/              # Business logic layer
│   │   └── __init__.py
│   └── repositories/          # Database access (if DB)
│       └── __init__.py
├── tests/
│   ├── __init__.py
│   ├── conftest.py           # Pytest fixtures
│   ├── test_api.py           # API tests
│   ├── api/                  # API endpoint tests
│   └── services/             # Service tests
├── alembic/                  # Database migrations (if DB)
│   ├── env.py
│   ├── script.py.mako
│   └── versions/
├── scripts/                  # Utility scripts
├── docker/
│   └── (optional based on config)
├── .github/                  # CI/CD (if enabled)
│   └── workflows/
│       └── ci.yml
├── .env.example              # Environment variables template
├── .gitignore
├── Dockerfile                # Docker (if enabled)
├── docker-compose.yml        # Docker Compose (if enabled)
├── pyproject.toml            # Project dependencies
└── README.md                 # Generated documentation
"""
    
    print(structure)

def demo_files():
    """Show examples of generated files"""
    
    print("\n" + "=" * 80)
    print("Sample Generated Files")
    print("=" * 80)
    
    print("\n📄 app/main.py (FastAPI Application)")
    print("-" * 40)
    print('''"""
My Project - FastAPI Application
"""

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from app.api.v1.api import api_router

app = FastAPI(
    title="My Project",
    description="A FastAPI project",
    version="0.1.0",
)

# CORS middleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Include API router
app.include_router(api_router, prefix="/api/v1")

@app.get("/health")
async def health_check():
    return {"status": "healthy", "version": "0.1.0"}
''')
    
    print("\n📄 app/core/config.py (Configuration)")
    print("-" * 40)
    print('''"""
Application configuration
"""

from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    PROJECT_NAME: str = "My Project"
    VERSION: str = "0.1.0"
    DEBUG: bool = True
    DATABASE_URL: str = "postgresql+asyncpg://user:pass@localhost/db"
    SECRET_KEY: str = "your-secret-key"
    
    class Config:
        env_file = ".env"

settings = Settings()
''')
    
    print("\n📄 pyproject.toml (Dependencies)")
    print("-" * 40)
    print('''[project]
name = "my-project"
version = "0.1.0"
dependencies = [
    "fastapi>=0.109.0",
    "uvicorn[standard]>=0.27.0",
    "pydantic>=2.5.0",
    "sqlalchemy>=2.0.0",
    "asyncpg>=0.29.0",
    "alembic>=1.13.0",
    "python-jose[cryptography]>=3.3.0",
    "passlib[bcrypt]>=1.7.4",
]
''')
    
    print("\n📄 tests/test_api.py (Tests)")
    print("-" * 40)
    print('''"""
API endpoint tests
"""

def test_health_check(client):
    response = client.get("/health")
    assert response.status_code == 200
    assert response.json()["status"] == "healthy"
''')

def main():
    """Run all demos"""
    
    print("\n🚀 FastAPI Scaffold CLI - Demo\n")
    
    demo_config()
    demo_structure()
    demo_files()
    
    print("\n" + "=" * 80)
    print("✅ This is what the FastAPI Scaffold CLI will generate!")
    print("=" * 80)
    print("\n📦 To use the actual CLI:")
    print("   1. uv sync                    # Install dependencies")
    print("   2. uv run fastapi-scaffold create my-project")
    print("   3. cd my-project")
    print("   4. uv sync")
    print("   5. uv run uvicorn app.main:app --reload")
    print("\n🌟 Or use presets:")
    print("   fastapi-scaffold create my-api --preset saas")
    print("   fastapi-scaffold create my-api --preset minimal")
    print("\n")

if __name__ == "__main__":
    main()