vega-framework 0.2.0__tar.gz → 0.2.2__tar.gz

{vega_framework-0.2.0 → vega_framework-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vega-framework
-Version: 0.2.0
+Version: 0.2.2
 Summary: Enterprise-ready Python framework that enforces Clean Architecture for building maintainable and scalable applications.
 License: MIT
 License-File: LICENSE

{vega_framework-0.2.0 → vega_framework-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vega-framework"
-version = "0.2.0"
+version = "0.2.2"
 description = "Enterprise-ready Python framework that enforces Clean Architecture for building maintainable and scalable applications."
 authors = ["Roberto Ferro"]
 license = "MIT"

{vega_framework-0.2.0 → vega_framework-0.2.2}/vega/cli/commands/generate.py

@@ -394,13 +394,13 @@ def _register_router_in_init(project_root: Path, resource_file: str, resource_na
 
 
 def _generate_router(project_root: Path, project_name: str, name: str) -> None:
-    """Generate a FastAPI router for a resource"""
+    """Generate a Vega Web router for a resource"""
 
     # Check if web folder exists
     web_path = project_root / "presentation" / "web"
     if not web_path.exists():
         click.echo(click.style("ERROR: Web module not found", fg='red'))
-        click.echo("   Router generation requires FastAPI web module")
+        click.echo("   Router generation requires Vega Web module")
         click.echo("   Install it with: vega add web")
         return
 
@@ -440,13 +440,13 @@ def _generate_router(project_root: Path, project_name: str, name: str) -> None:
 
 
 def _generate_web_models(project_root: Path, project_name: str, name: str, is_request: bool, is_response: bool) -> None:
-    """Generate Pydantic request or response model for FastAPI"""
+    """Generate Pydantic request or response model for Vega Web"""
 
     # Check if web folder exists
     web_path = project_root / "presentation" / "web"
     if not web_path.exists():
         click.echo(click.style("ERROR: Web module not found", fg='red'))
-        click.echo("   Model generation requires FastAPI web module")
+        click.echo("   Model generation requires Vega Web module")
         click.echo("   Install it with: vega add web")
         return
 
@@ -531,13 +531,13 @@ def _generate_web_models(project_root: Path, project_name: str, name: str, is_re
 
 
 def _generate_middleware(project_root: Path, project_name: str, class_name: str, file_name: str) -> None:
-    """Generate a FastAPI middleware"""
+    """Generate a Vega Web middleware"""
 
     # Check if web folder exists
     web_path = project_root / "presentation" / "web"
     if not web_path.exists():
         click.echo(click.style("ERROR: Web module not found", fg='red'))
-        click.echo("   Middleware generation requires FastAPI web module")
+        click.echo("   Middleware generation requires Vega Web module")
         click.echo("   Install it with: vega add web")
         return
 
@@ -554,7 +554,7 @@ def _generate_middleware(project_root: Path, project_name: str, class_name: str,
     # Check if __init__.py exists
     init_file = middleware_path / "__init__.py"
     if not init_file.exists():
-        init_file.write_text('"""FastAPI Middlewares"""\n')
+        init_file.write_text('"""Vega Web Middlewares"""\n')
         click.echo(f"+ Created {click.style(str(init_file.relative_to(project_root)), fg='green')}")
 
     # Generate middleware file
@@ -589,8 +589,8 @@ def _register_middleware_in_app(project_root: Path, class_name: str, file_name:
         click.echo(click.style(f'''
 from .middleware.{file_name} import {class_name}Middleware
 
-def create_app() -> FastAPI:
-    app = FastAPI(...)
+def create_app() -> VegaApp:
+    app = VegaApp(...)
     app.add_middleware({class_name}Middleware)
     app.include_router(get_api_router())
     return app
@@ -619,9 +619,9 @@ def create_app() -> FastAPI:
             break
 
     if not import_added:
-        # Fallback: add after FastAPI import
+        # Fallback: add after VegaApp import
         for i, line in enumerate(lines):
-            if 'from fastapi import' in line:
+            if 'from vega.web import' in line:
                 lines.insert(i + 1, middleware_import)
                 lines.insert(i + 2, '')
                 break
@@ -629,8 +629,8 @@ def create_app() -> FastAPI:
     # Find create_app function and add middleware registration
     middleware_added = False
     for i, line in enumerate(lines):
-        if 'app = FastAPI(' in line:
-            # Find the end of FastAPI initialization
+        if 'app = VegaApp(' in line:
+            # Find the end of VegaApp initialization
             j = i + 1
             while j < len(lines) and not lines[j].strip().startswith('app.include_router'):
                 j += 1
@@ -649,8 +649,8 @@ def create_app() -> FastAPI:
         click.echo(click.style(f'''
 from .middleware.{file_name} import {class_name}Middleware
 
-def create_app() -> FastAPI:
-    app = FastAPI(...)
+def create_app() -> VegaApp:
+    app = VegaApp(...)
     app.add_middleware({class_name}Middleware)
     app.include_router(get_api_router())
     return app

{vega_framework-0.2.0 → vega_framework-0.2.2}/vega/cli/commands/web.py

@@ -1,4 +1,4 @@
-"""Web command - Manage FastAPI web server"""
+"""Web command - Manage Vega Web server"""
 import sys
 from pathlib import Path
 
@@ -7,7 +7,7 @@ import click
 
 @click.group()
 def web():
-    """Manage FastAPI web server
+    """Manage Vega Web server
 
     Commands to manage the web server for your Vega project.
     The web module must be added to the project first using 'vega add web'.
@@ -21,7 +21,7 @@ def web():
 @click.option('--reload', is_flag=True, help='Enable auto-reload')
 @click.option('--path', default='.', help='Path to Vega project (default: current directory)')
 def run(host: str, port: int, reload: bool, path: str):
-    """Start the FastAPI web server
+    """Start the Vega Web server
 
     Examples:
         vega web run
@@ -42,7 +42,7 @@ def run(host: str, port: int, reload: bool, path: str):
     web_main = project_path / "presentation" / "web" / "main.py"
     if not web_main.exists():
         click.echo(click.style("ERROR: Web module not found", fg='red'))
-        click.echo("\nThe FastAPI web module is not available in this project.")
+        click.echo("\nThe Vega Web module is not available in this project.")
         click.echo("Add it using:")
         click.echo(click.style("  vega add web", fg='cyan', bold=True))
         sys.exit(1)
@@ -56,8 +56,9 @@ def run(host: str, port: int, reload: bool, path: str):
         import uvicorn
     except ImportError:
         click.echo(click.style("ERROR: uvicorn not installed", fg='red'))
-        click.echo("\nInstall FastAPI dependencies:")
-        click.echo(click.style("  poetry add fastapi uvicorn[standard]", fg='cyan', bold=True))
+        click.echo("\nUvicorn is required but not installed.")
+        click.echo("It should be included with vega-framework, but you can also install it with:")
+        click.echo(click.style("  poetry add uvicorn[standard]", fg='cyan', bold=True))
         sys.exit(1)
 
     # Initialize DI container first
@@ -73,7 +74,7 @@ def run(host: str, port: int, reload: bool, path: str):
     try:
         from presentation.web.main import app
     except ImportError as e:
-        click.echo(click.style("ERROR: Failed to import FastAPI app", fg='red'))
+        click.echo(click.style("ERROR: Failed to import Vega Web app", fg='red'))
         click.echo(f"\nDetails: {e}")
         click.echo("\nMake sure:")
         click.echo("  1. You are in the project directory or use --path")

{vega_framework-0.2.0 → vega_framework-0.2.2}/vega/cli/templates/project/ARCHITECTURE.md.j2

@@ -38,7 +38,7 @@ The innermost layer containing pure business logic, completely independent of an
 **Rules:**
 
 - ✅ **NO** dependencies on any other layer
-- ✅ **NO** framework-specific code (no FastAPI, SQLAlchemy, etc.)
+- ✅ **NO** framework-specific code (no Vega Web, SQLAlchemy, etc.)
 - ✅ **NO** infrastructure details (no database, HTTP, file system)
 - ✅ Pure business logic only
 - ✅ Only defines **interfaces**, never concrete implementations
@@ -90,7 +90,7 @@ Handles user interaction and external communication, acting as the entry point t
 
 **Contains:**
 
-- **Web API** - FastAPI routes, controllers, request/response models (when web is enabled)
+- **Web API** - Vega Web routes, controllers, request/response models (when web is enabled)
 - **CLI** - Command-line interface commands and argument parsing
 - **GraphQL/gRPC** - Alternative API implementations (if needed)
 - **WebSockets** - Real-time communication handlers (if needed)
@@ -108,7 +108,7 @@ Handles user interaction and external communication, acting as the entry point t
 **Examples:**
 
 - **CLI**: Uses Click/Typer to define commands that invoke interactors or mediators
-- **Web API**: FastAPI endpoints that receive HTTP requests and call domain use cases
+- **Web API**: Vega Web endpoints that receive HTTP requests and call domain use cases
 - **Both**: Can coexist in the same application, sharing the same business logic
 
 ## Core Patterns
@@ -344,7 +344,7 @@ The generator will interactively prompt for:
 
 Commands are **automatically discovered** from `presentation/cli/commands/` - no manual registration required.
 
-**FastAPI Routers** - HTTP API endpoints (requires web support):
+**Vega Web Routers** - HTTP API endpoints (requires web support):
 ```bash
 vega generate router User
 vega generate router Product
@@ -353,7 +353,7 @@ vega generate router Order
 
 Routers are **automatically discovered** from `presentation/web/routes/` - no manual registration required.
 
-**FastAPI Middleware** - Request/response processing (requires web support):
+**Vega Web Middleware** - Request/response processing (requires web support):
 ```bash
 vega generate middleware Logging
 vega generate middleware Authentication
@@ -362,12 +362,12 @@ vega generate middleware RateLimiting
 
 ### Adding Features to Existing Projects
 
-**Add FastAPI Web Support**:
+**Add Vega Web Support**:
 ```bash
 vega add web
 ```
 
-Creates complete FastAPI scaffold:
+Creates complete Vega Web scaffold:
 - `presentation/web/` directory structure
 - Routes and middleware setup
 - Health check endpoints
@@ -482,9 +482,9 @@ vega doctor
 | `vega generate interactor <Name>` | Generate use case |
 | `vega generate mediator <Name>` | Generate workflow |
 | `vega generate command <Name>` | Generate CLI command |
-| `vega generate router <Name>` | Generate FastAPI router |
+| `vega generate router <Name>` | Generate Vega Web router |
 | `vega generate model <Name>` | Generate SQLAlchemy model |
-| `vega add web` | Add FastAPI support |
+| `vega add web` | Add Vega Web support |
 | `vega add sqlalchemy` | Add database support |
 | `vega migrate <command>` | Manage database migrations |
 | `vega doctor` | Validate project architecture |
@@ -519,9 +519,9 @@ vega generate router Product
 
 This creates `presentation/web/routes/product.py`:
 ```python
-from fastapi import APIRouter
+from vega.web import Router
 
-router = APIRouter()  # MUST be named 'router'
+router = Router()  # MUST be named 'router'
 
 @router.get("/")
 async def list_products():
@@ -682,7 +682,7 @@ Vega projects follow a standard 4-layer structure:
 │       └── sendgrid_email_service.py    # Sendgrid implementation
 │
 ├── presentation/                 # 🟠 PRESENTATION LAYER (Delivery Mechanisms)
-│   ├── web/                      # FastAPI web interface (if enabled)
+│   ├── web/                      # Vega Web interface (if enabled)
 │   │   ├── __init__.py
 │   │   ├── routes/
 │   │   │   └── user_routes.py
@@ -833,7 +833,7 @@ async def create_user(name: str, email: str):
 
 **Benefits:**
 - Execute async interactors directly in CLI commands
-- Same business logic works in both CLI and Web (FastAPI) contexts
+- Same business logic works in both CLI and Web (Vega Web) contexts
 - Clean async/await syntax
 - Automatic asyncio event loop management
 

{vega_framework-0.2.0 → vega_framework-0.2.2}/vega/cli/templates/project/README.md.j2

@@ -20,9 +20,9 @@ Vega Framework application with Clean Architecture.
 │   └── services/        # Service implementations
 │
 ├── presentation/        # Delivery mechanisms
-│   ├── web/            # FastAPI web interface (if added)
+│   ├── web/            # Vega Web interface (if added)
 │   │   ├── routes/     # HTTP endpoints
-│   │   ├── app.py      # FastAPI app factory
+│   │   ├── app.py      # Vega app factory
 │   │   └── main.py     # ASGI entrypoint
 │   └── cli/            # CLI commands
 │
@@ -45,7 +45,7 @@ cp .env.example .env
 python main.py hello
 python main.py greet --name John
 
-# If using FastAPI template, run the web server
+# If using web template, run the web server
 vega web run
 vega web run --reload  # With auto-reload
 # Visit http://localhost:8000/api/health/status
@@ -81,7 +81,7 @@ vega generate command ListUsers --impl sync
 
 ### Add Features
 
-Add FastAPI web support to your project:
+Add Vega Web support to your project:
 
 ```bash
 vega add web
@@ -140,7 +140,7 @@ async def create_user(name: str):
     click.echo(f"Created: {user.name}")
 ```
 
-This allows the same async business logic to work in both CLI and web contexts (FastAPI).
+This allows the same async business logic to work in both CLI and web contexts (Vega Web).
 
 ## Project Commands Quick Reference
 

{vega_framework-0.2.0 → vega_framework-0.2.2}/vega/cli/templates/web/main.py.j2

@@ -1,5 +1,4 @@
-"""FastAPI ASGI entrypoint for {{ project_name }}"""
-from fastapi import FastAPI
+"""Vega Web ASGI entrypoint for {{ project_name }}"""
 import config  # noqa: F401 - Import to initialize DI container
 
 # Auto-discover event subscribers so @subscribe handlers are ready
@@ -12,7 +11,7 @@ else:
 
 from .app import create_app
 
-app: FastAPI = create_app()
+app = create_app()
 
 
 if __name__ == "__main__":

{vega_framework-0.2.0 → vega_framework-0.2.2}/vega/cli/templates/web/middleware.py.j2

@@ -1,5 +1,5 @@
-"""{{ class_name }} middleware for FastAPI application"""
-from fastapi import Request, Response
+"""{{ class_name }} middleware for Vega Web application"""
+from vega.web import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.types import ASGIApp
 import time
@@ -14,7 +14,7 @@ class {{ class_name }}Middleware(BaseHTTPMiddleware):
     and responses before they're returned to clients.
 
     Usage:
-        Add to your FastAPI app in app.py:
+        Add to your Vega Web app in app.py:
         from .middleware.{{ file_name }} import {{ class_name }}Middleware
         app.add_middleware({{ class_name }}Middleware)
     """

{vega_framework-0.2.0 → vega_framework-0.2.2}/vega/cli/templates/web/routes_init.py.j2

@@ -1,5 +1,5 @@
 """API routers aggregation"""
-from fastapi import APIRouter
+from vega.web import Router
 
 from . import health, users
 
@@ -7,9 +7,9 @@ from . import health, users
 API_PREFIX = "/api"
 
 
-def get_api_router() -> APIRouter:
+def get_api_router() -> Router:
     """Return application API router"""
-    router = APIRouter(prefix=API_PREFIX)
+    router = Router(prefix=API_PREFIX)
     router.include_router(health.router, tags=["health"], prefix="/health")
     router.include_router(users.router, tags=["users"], prefix="/users")
     return router

{vega_framework-0.2.0 → vega_framework-0.2.2}/vega/web/__init__.py

@@ -66,6 +66,10 @@ from .route_middleware import (
     middleware,
 )
 
+# OpenAPI / Documentation
+from .openapi import get_openapi_schema
+from .docs import get_swagger_ui_html, get_redoc_html
+
 __all__ = [
     # Version
     "__version__",
@@ -97,4 +101,8 @@ __all__ = [
     "RouteMiddleware",
     "MiddlewarePhase",
     "middleware",
+    # OpenAPI / Docs
+    "get_openapi_schema",
+    "get_swagger_ui_html",
+    "get_redoc_html",
 ]

{vega_framework-0.2.0 → vega_framework-0.2.2}/vega/web/application.py

@@ -7,10 +7,13 @@ from starlette.middleware import Middleware
 from starlette.middleware.cors import CORSMiddleware
 from starlette.routing import Mount, Route as StarletteRoute
 from starlette.types import ASGIApp
+from starlette.responses import JSONResponse as StarletteJSONResponse
 
 from .router import Router
 from .exceptions import HTTPException
 from .response import JSONResponse
+from .openapi import get_openapi_schema
+from .docs import get_swagger_ui_html, get_redoc_html
 
 
 class VegaApp:
@@ -59,12 +62,20 @@ class VegaApp:
         middleware: Optional[Sequence[Middleware]] = None,
         on_startup: Optional[Sequence[Callable]] = None,
         on_shutdown: Optional[Sequence[Callable]] = None,
+        docs_url: Optional[str] = "/docs",
+        redoc_url: Optional[str] = "/redoc",
+        openapi_url: Optional[str] = "/openapi.json",
     ):
         self.title = title
         self.description = description
         self.version = version
         self.debug = debug
 
+        # Documentation URLs (None to disable)
+        self.docs_url = docs_url
+        self.redoc_url = redoc_url
+        self.openapi_url = openapi_url
+
         # Internal router for top-level routes
         self._router = Router()
 
@@ -78,6 +89,9 @@ class VegaApp:
         # Starlette app (created lazily)
         self._starlette_app: Optional[Starlette] = None
 
+        # OpenAPI schema (cached)
+        self._openapi_schema: Optional[Dict[str, Any]] = None
+
     def add_middleware(
         self,
         middleware_class: type,
@@ -197,6 +211,22 @@ class VegaApp:
         """
         return self._router.route(path, methods, **kwargs)
 
+    def openapi(self) -> Dict[str, Any]:
+        """
+        Generate and return the OpenAPI schema.
+
+        Returns:
+            OpenAPI schema dictionary
+        """
+        if self._openapi_schema is None:
+            self._openapi_schema = get_openapi_schema(
+                title=self.title,
+                version=self.version,
+                description=self.description,
+                routes=self._router.get_routes(),
+            )
+        return self._openapi_schema
+
     def _build_starlette_app(self) -> Starlette:
         """Build the Starlette application from routes and middleware."""
         # Convert Vega routes to Starlette routes
@@ -204,6 +234,39 @@ class VegaApp:
             route.to_starlette_route() for route in self._router.get_routes()
         ]
 
+        # Add OpenAPI endpoint
+        if self.openapi_url:
+            async def openapi_endpoint(request):
+                return StarletteJSONResponse(self.openapi())
+
+            starlette_routes.append(
+                StarletteRoute(self.openapi_url, endpoint=openapi_endpoint, methods=["GET"])
+            )
+
+        # Add Swagger UI endpoint
+        if self.docs_url:
+            async def swagger_ui_endpoint(request):
+                return get_swagger_ui_html(
+                    openapi_url=self.openapi_url or "/openapi.json",
+                    title=f"{self.title} - Swagger UI"
+                )
+
+            starlette_routes.append(
+                StarletteRoute(self.docs_url, endpoint=swagger_ui_endpoint, methods=["GET"])
+            )
+
+        # Add ReDoc endpoint
+        if self.redoc_url:
+            async def redoc_endpoint(request):
+                return get_redoc_html(
+                    openapi_url=self.openapi_url or "/openapi.json",
+                    title=f"{self.title} - ReDoc"
+                )
+
+            starlette_routes.append(
+                StarletteRoute(self.redoc_url, endpoint=redoc_endpoint, methods=["GET"])
+            )
+
         # Create Starlette app
         app = Starlette(
             debug=self.debug,

vega_framework-0.2.2/vega/web/docs.py

@@ -0,0 +1,104 @@
+"""Documentation endpoints for Vega Web Framework"""
+
+from typing import Callable
+from starlette.responses import HTMLResponse, JSONResponse
+
+
+def get_swagger_ui_html(
+    *,
+    openapi_url: str,
+    title: str,
+    swagger_js_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js",
+    swagger_css_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css",
+    swagger_favicon_url: str = "https://fastapi.tiangolo.com/img/favicon.png",
+) -> HTMLResponse:
+    """
+    Generate Swagger UI HTML page.
+
+    Args:
+        openapi_url: URL to OpenAPI schema JSON
+        title: Page title
+        swagger_js_url: URL to Swagger UI JavaScript
+        swagger_css_url: URL to Swagger UI CSS
+        swagger_favicon_url: URL to favicon
+
+    Returns:
+        HTML response with Swagger UI
+    """
+    html = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>{title}</title>
+        <meta charset="utf-8"/>
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <link rel="shortcut icon" href="{swagger_favicon_url}">
+        <link rel="stylesheet" type="text/css" href="{swagger_css_url}" />
+    </head>
+    <body>
+        <div id="swagger-ui"></div>
+        <script src="{swagger_js_url}"></script>
+        <script>
+            const ui = SwaggerUIBundle({{
+                url: '{openapi_url}',
+                dom_id: '#swagger-ui',
+                presets: [
+                    SwaggerUIBundle.presets.apis,
+                    SwaggerUIBundle.SwaggerUIStandalonePreset
+                ],
+                layout: "BaseLayout",
+                deepLinking: true,
+                showExtensions: true,
+                showCommonExtensions: true
+            }})
+        </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html)
+
+
+def get_redoc_html(
+    *,
+    openapi_url: str,
+    title: str,
+    redoc_js_url: str = "https://cdn.jsdelivr.net/npm/redoc@next/bundles/redoc.standalone.js",
+    redoc_favicon_url: str = "https://fastapi.tiangolo.com/img/favicon.png",
+) -> HTMLResponse:
+    """
+    Generate ReDoc HTML page.
+
+    Args:
+        openapi_url: URL to OpenAPI schema JSON
+        title: Page title
+        redoc_js_url: URL to ReDoc JavaScript
+        redoc_favicon_url: URL to favicon
+
+    Returns:
+        HTML response with ReDoc
+    """
+    html = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>{title}</title>
+        <meta charset="utf-8"/>
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <link rel="shortcut icon" href="{redoc_favicon_url}">
+        <style>
+            body {{
+                margin: 0;
+                padding: 0;
+            }}
+        </style>
+    </head>
+    <body>
+        <redoc spec-url="{openapi_url}"></redoc>
+        <script src="{redoc_js_url}"></script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html)
+
+
+__all__ = ["get_swagger_ui_html", "get_redoc_html"]

vega_framework-0.2.2/vega/web/openapi.py

@@ -0,0 +1,292 @@
+"""OpenAPI schema generation for Vega Web Framework"""
+
+from typing import Any, Dict, List, Optional, Type, get_type_hints
+from inspect import signature, Parameter
+import json
+
+try:
+    from pydantic import BaseModel
+    PYDANTIC_AVAILABLE = True
+except ImportError:
+    PYDANTIC_AVAILABLE = False
+    BaseModel = None  # type: ignore
+
+
+def get_openapi_schema(
+    *,
+    title: str,
+    version: str,
+    description: str = "",
+    routes: List[Any],
+    openapi_version: str = "3.0.2",
+) -> Dict[str, Any]:
+    """
+    Generate OpenAPI 3.0 schema from routes.
+
+    Args:
+        title: API title
+        version: API version
+        description: API description
+        routes: List of Route objects
+        openapi_version: OpenAPI specification version
+
+    Returns:
+        OpenAPI schema dictionary
+    """
+    schema: Dict[str, Any] = {
+        "openapi": openapi_version,
+        "info": {
+            "title": title,
+            "version": version,
+        },
+        "paths": {},
+    }
+
+    if description:
+        schema["info"]["description"] = description
+
+    # Components for reusable schemas
+    components: Dict[str, Any] = {
+        "schemas": {}
+    }
+
+    # Process each route
+    for route in routes:
+        path = route.path
+
+        # Convert path parameters from {param} to OpenAPI format
+        openapi_path = path
+
+        if openapi_path not in schema["paths"]:
+            schema["paths"][openapi_path] = {}
+
+        for method in route.methods:
+            method_lower = method.lower()
+
+            operation: Dict[str, Any] = {
+                "responses": {
+                    "200": {
+                        "description": "Successful Response"
+                    }
+                }
+            }
+
+            # Add summary and description
+            if route.summary:
+                operation["summary"] = route.summary
+
+            if route.description:
+                operation["description"] = route.description
+            elif route.endpoint.__doc__:
+                operation["description"] = route.endpoint.__doc__.strip()
+
+            # Add tags
+            if route.tags:
+                operation["tags"] = route.tags
+
+            # Add operation ID
+            operation["operationId"] = f"{method_lower}_{route.name or route.endpoint.__name__}"
+
+            # Analyze endpoint parameters
+            params = _get_parameters(route)
+            if params:
+                operation["parameters"] = params
+
+            # Analyze request body
+            request_body = _get_request_body(route)
+            if request_body:
+                operation["requestBody"] = request_body
+                # Add request body schemas to components
+                if PYDANTIC_AVAILABLE and "content" in request_body:
+                    for content_type, content_schema in request_body["content"].items():
+                        if "schema" in content_schema and "$ref" in content_schema["schema"]:
+                            model_name = content_schema["schema"]["$ref"].split("/")[-1]
+                            # Model will be added when processing response_model
+
+            # Analyze response model
+            if route.response_model:
+                response_schema = _get_response_schema(route.response_model, components)
+                if response_schema:
+                    operation["responses"]["200"] = {
+                        "description": "Successful Response",
+                        "content": {
+                            "application/json": {
+                                "schema": response_schema
+                            }
+                        }
+                    }
+
+            # Add status code if specified
+            if route.status_code and route.status_code != 200:
+                operation["responses"][str(route.status_code)] = operation["responses"].pop("200")
+
+            # Add error responses
+            operation["responses"]["422"] = {
+                "description": "Validation Error"
+            }
+
+            schema["paths"][openapi_path][method_lower] = operation
+
+    # Add components if we have any schemas
+    if components["schemas"]:
+        schema["components"] = components
+
+    return schema
+
+
+def _get_parameters(route: Any) -> List[Dict[str, Any]]:
+    """Extract path and query parameters from route."""
+    parameters = []
+
+    # Get function signature
+    sig = signature(route.endpoint)
+    type_hints = get_type_hints(route.endpoint)
+
+    # Find which parameters are Pydantic models (request body)
+    request_body_params = set()
+    if PYDANTIC_AVAILABLE:
+        for param_name, param in sig.parameters.items():
+            param_type = type_hints.get(param_name)
+            if param_type and isinstance(param_type, type) and issubclass(param_type, BaseModel):
+                request_body_params.add(param_name)
+
+    for param_name, param in sig.parameters.items():
+        # Skip special parameters
+        if param_name in ("request", "self", "cls"):
+            continue
+
+        # Skip parameters that are Pydantic models (they're in request body)
+        if param_name in request_body_params:
+            continue
+
+        # Check if it's a path parameter
+        if f"{{{param_name}}}" in route.path:
+            param_schema = {
+                "name": param_name,
+                "in": "path",
+                "required": True,
+                "schema": _get_type_schema(type_hints.get(param_name, str))
+            }
+            parameters.append(param_schema)
+        elif param.default == Parameter.empty:
+            # Required query parameter
+            param_schema = {
+                "name": param_name,
+                "in": "query",
+                "required": True,
+                "schema": _get_type_schema(type_hints.get(param_name, str))
+            }
+            parameters.append(param_schema)
+        else:
+            # Optional query parameter
+            param_schema = {
+                "name": param_name,
+                "in": "query",
+                "required": False,
+                "schema": _get_type_schema(type_hints.get(param_name, str))
+            }
+            if param.default is not None and param.default != Parameter.empty:
+                param_schema["schema"]["default"] = param.default
+            parameters.append(param_schema)
+
+    return parameters
+
+
+def _get_request_body(route: Any) -> Optional[Dict[str, Any]]:
+    """Extract request body schema from route."""
+    if not PYDANTIC_AVAILABLE:
+        return None
+
+    # Get function signature
+    sig = signature(route.endpoint)
+    type_hints = get_type_hints(route.endpoint)
+
+    for param_name, param in sig.parameters.items():
+        # Skip special parameters and path parameters
+        if param_name in ("request", "self", "cls"):
+            continue
+        if f"{{{param_name}}}" in route.path:
+            continue
+
+        param_type = type_hints.get(param_name)
+
+        # Check if it's a Pydantic model
+        if param_type and isinstance(param_type, type) and issubclass(param_type, BaseModel):
+            model_schema = param_type.model_json_schema()
+            model_name = param_type.__name__
+
+            return {
+                "required": True,
+                "content": {
+                    "application/json": {
+                        "schema": {
+                            "$ref": f"#/components/schemas/{model_name}"
+                        }
+                    }
+                }
+            }
+
+    return None
+
+
+def _get_response_schema(response_model: Type, components: Dict[str, Any]) -> Dict[str, Any]:
+    """Get response schema from response model."""
+    if not PYDANTIC_AVAILABLE:
+        return {}
+
+    # Handle Pydantic models
+    if isinstance(response_model, type) and issubclass(response_model, BaseModel):
+        model_name = response_model.__name__
+
+        # Add model schema to components
+        if model_name not in components["schemas"]:
+            components["schemas"][model_name] = response_model.model_json_schema()
+
+        return {
+            "$ref": f"#/components/schemas/{model_name}"
+        }
+
+    # Handle List types
+    if hasattr(response_model, "__origin__"):
+        if response_model.__origin__ is list:
+            item_type = response_model.__args__[0]
+            if isinstance(item_type, type) and issubclass(item_type, BaseModel):
+                model_name = item_type.__name__
+
+                # Add model schema to components
+                if model_name not in components["schemas"]:
+                    components["schemas"][model_name] = item_type.model_json_schema()
+
+                return {
+                    "type": "array",
+                    "items": {
+                        "$ref": f"#/components/schemas/{model_name}"
+                    }
+                }
+
+    # Handle dict
+    if response_model is dict:
+        return {"type": "object"}
+
+    return {}
+
+
+def _get_type_schema(param_type: Any) -> Dict[str, Any]:
+    """Convert Python type to OpenAPI schema."""
+    if param_type is str or param_type == "str":
+        return {"type": "string"}
+    elif param_type is int or param_type == "int":
+        return {"type": "integer"}
+    elif param_type is float or param_type == "float":
+        return {"type": "number"}
+    elif param_type is bool or param_type == "bool":
+        return {"type": "boolean"}
+    elif param_type is list or (hasattr(param_type, "__origin__") and param_type.__origin__ is list):
+        return {"type": "array", "items": {}}
+    elif param_type is dict:
+        return {"type": "object"}
+    else:
+        return {"type": "string"}
+
+
+__all__ = ["get_openapi_schema"]