vega-framework 0.1.35__py3-none-any.whl → 0.2.1__py3-none-any.whl

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/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/cli/templates/web/app.py.j2

@@ -1,5 +1,5 @@
-"""FastAPI application factory for {{ project_name }}"""
-from fastapi import FastAPI
+"""Vega Web application factory for {{ project_name }}"""
+from vega.web import VegaApp
 
 from .routes import get_api_router
 
@@ -8,8 +8,8 @@ APP_TITLE = "{{ project_name.replace('-', ' ').replace('_', ' ').title() }}"
 APP_VERSION = "0.1.0"
 
 
-def create_app() -> FastAPI:
-    """Create and configure FastAPI application"""
-    app = FastAPI(title=APP_TITLE, version=APP_VERSION)
+def create_app() -> VegaApp:
+    """Create and configure Vega Web application"""
+    app = VegaApp(title=APP_TITLE, version=APP_VERSION)
     app.include_router(get_api_router())
     return app

vega/cli/templates/web/health_route.py.j2

@@ -1,7 +1,7 @@
 """Health check endpoints"""
-from fastapi import APIRouter
+from vega.web import Router
 
-router = APIRouter()
+router = Router()
 
 
 @router.get("/status", summary="Health status", response_model=dict)

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/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/cli/templates/web/router.py.j2

@@ -1,5 +1,5 @@
 """{{ resource_name }} management endpoints"""
-from fastapi import APIRouter, HTTPException, status
+from vega.web import Router, HTTPException, status
 from typing import List
 
 # TODO: Import your Pydantic models here
@@ -8,7 +8,7 @@ from typing import List
 # TODO: Import your interactors/use cases here
 # from {{ project_name }}.domain.interactors.{{ resource_file }} import Create{{ resource_name }}, Get{{ resource_name }}, List{{ resource_name }}
 
-router = APIRouter()
+router = Router()
 
 # TODO: Remove this in-memory storage and use proper repositories/interactors
 {{ resource_file }}_db: dict[str, dict] = {}

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/cli/templates/web/routes_init_autodiscovery.py.j2

@@ -4,9 +4,9 @@ from vega.discovery import discover_routers
 
 def get_api_router():
     """
-    Auto-discover and register FastAPI routers in this directory.
+    Auto-discover and register Vega Web routers in this directory.
 
     Returns:
-        APIRouter: Main API router with all discovered routers included
+        Router: Main API router with all discovered routers included
     """
     return discover_routers(__package__)

vega/cli/templates/web/users_route.py.j2

@@ -1,10 +1,10 @@
 """User management endpoints"""
-from fastapi import APIRouter, HTTPException, status
+from vega.web import Router, HTTPException, status
 from typing import List
 
 from ..models.user_models import CreateUserRequest, UserResponse
 
-router = APIRouter()
+router = Router()
 
 # In-memory storage for demonstration (replace with repository in production)
 users_db: dict[str, UserResponse] = {}

vega/discovery/routes.py

@@ -1,4 +1,4 @@
-"""FastAPI router auto-discovery utilities"""
+"""Vega Web router auto-discovery utilities"""
 import importlib
 import inspect
 import logging
@@ -6,9 +6,9 @@ from pathlib import Path
 from typing import Optional
 
 try:
-    from fastapi import APIRouter
+    from vega.web import Router
 except ImportError:
-    APIRouter = None
+    Router = None
 
 logger = logging.getLogger(__name__)
 
@@ -19,12 +19,12 @@ def discover_routers(
     api_prefix: str = "/api",
     auto_tags: bool = True,
     auto_prefix: bool = True
-) -> "APIRouter":
+) -> "Router":
     """
-    Auto-discover and register FastAPI routers from a package.
+    Auto-discover and register Vega Web routers from a package.
 
     This function scans a package directory for Python modules containing
-    APIRouter instances named 'router' and automatically registers them
+    Router instances named 'router' and automatically registers them
     with the main router.
 
     Args:
@@ -35,7 +35,7 @@ def discover_routers(
         auto_prefix: Automatically generate prefix from module name (default: True)
 
     Returns:
-        APIRouter: Main router with all discovered routers included
+        Router: Main router with all discovered routers included
 
     Example:
         # In your project's presentation/web/routes/__init__.py
@@ -51,15 +51,15 @@ def discover_routers(
         )
 
     Note:
-        Each route module should export an APIRouter instance named 'router'.
+        Each route module should export a Router instance named 'router'.
         The module filename will be used for tags and prefix generation if enabled.
     """
-    if APIRouter is None:
+    if Router is None:
         raise ImportError(
-            "FastAPI is not installed. Install it with: pip install fastapi"
+            "Vega Web is not installed. This should not happen if you're using vega-framework."
         )
 
-    main_router = APIRouter(prefix=api_prefix)
+    main_router = Router(prefix=api_prefix)
 
     # Resolve the routes package path
     try:
@@ -90,10 +90,10 @@ def discover_routers(
             try:
                 module = importlib.import_module(module_name)
 
-                # Find APIRouter instance named 'router'
+                # Find Router instance named 'router'
                 router = getattr(module, 'router', None)
 
-                if isinstance(router, APIRouter):
+                if isinstance(router, Router):
                     # Generate tags and prefix from module name
                     if auto_tags:
                         tag = file.stem.replace("_", " ").title()

vega/web/__init__.py

@@ -0,0 +1,100 @@
+"""
+Vega Web Framework
+
+A lightweight web framework built on Starlette, providing a FastAPI-like
+developer experience while being deeply integrated with Vega's architecture.
+
+Example:
+    from vega.web import Router, VegaApp, HTTPException, status
+
+    router = Router()
+
+    @router.get("/users/{user_id}")
+    async def get_user(user_id: str):
+        if user_id == "invalid":
+            raise HTTPException(status_code=404, detail="User not found")
+        return {"id": user_id, "name": "John"}
+
+    app = VegaApp(title="My API", version="1.0.0")
+    app.include_router(router, prefix="/api")
+
+    # Run with: uvicorn main:app --reload
+"""
+
+__version__ = "0.1.0"
+
+# Core application
+from .application import VegaApp
+
+# Routing
+from .router import Router
+
+# Request/Response
+from .request import Request
+from .response import (
+    Response,
+    JSONResponse,
+    HTMLResponse,
+    PlainTextResponse,
+    RedirectResponse,
+    StreamingResponse,
+    FileResponse,
+)
+
+# Exceptions
+from .exceptions import (
+    HTTPException,
+    ValidationError,
+    NotFoundError,
+    UnauthorizedError,
+    ForbiddenError,
+    BadRequestError,
+    status,
+)
+
+# Middleware (optional, can be imported explicitly)
+from .middleware import (
+    VegaMiddleware,
+    CORSMiddleware,
+    RequestLoggingMiddleware,
+)
+
+# Route middleware
+from .route_middleware import (
+    RouteMiddleware,
+    MiddlewarePhase,
+    middleware,
+)
+
+__all__ = [
+    # Version
+    "__version__",
+    # Core
+    "VegaApp",
+    "Router",
+    # Request/Response
+    "Request",
+    "Response",
+    "JSONResponse",
+    "HTMLResponse",
+    "PlainTextResponse",
+    "RedirectResponse",
+    "StreamingResponse",
+    "FileResponse",
+    # Exceptions
+    "HTTPException",
+    "ValidationError",
+    "NotFoundError",
+    "UnauthorizedError",
+    "ForbiddenError",
+    "BadRequestError",
+    "status",
+    # Middleware
+    "VegaMiddleware",
+    "CORSMiddleware",
+    "RequestLoggingMiddleware",
+    # Route Middleware
+    "RouteMiddleware",
+    "MiddlewarePhase",
+    "middleware",
+]

vega/web/application.py

@@ -0,0 +1,234 @@
+"""Main application class for Vega Web Framework"""
+
+from typing import Any, Callable, Dict, List, Optional, Sequence
+
+from starlette.applications import Starlette
+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 .router import Router
+from .exceptions import HTTPException
+from .response import JSONResponse
+
+
+class VegaApp:
+    """
+    Main application class for Vega Web Framework.
+
+    This is the core ASGI application that handles all HTTP requests.
+    It's built on Starlette but provides a FastAPI-like API for familiarity.
+
+    Args:
+        title: Application title
+        description: Application description
+        version: Application version
+        debug: Enable debug mode
+        middleware: List of middleware to apply
+        on_startup: Functions to run on startup
+        on_shutdown: Functions to run on shutdown
+
+    Example:
+        app = VegaApp(
+            title="My API",
+            version="1.0.0",
+            debug=True
+        )
+
+        @app.get("/")
+        async def root():
+            return {"message": "Hello World"}
+
+        # Or with routers
+        router = Router(prefix="/api")
+        @router.get("/users")
+        async def get_users():
+            return {"users": []}
+
+        app.include_router(router)
+    """
+
+    def __init__(
+        self,
+        *,
+        title: str = "Vega API",
+        description: str = "",
+        version: str = "0.1.0",
+        debug: bool = False,
+        middleware: Optional[Sequence[Middleware]] = None,
+        on_startup: Optional[Sequence[Callable]] = None,
+        on_shutdown: Optional[Sequence[Callable]] = None,
+    ):
+        self.title = title
+        self.description = description
+        self.version = version
+        self.debug = debug
+
+        # Internal router for top-level routes
+        self._router = Router()
+
+        # Middleware stack
+        self._middleware = list(middleware) if middleware else []
+
+        # Lifecycle handlers
+        self._on_startup = list(on_startup) if on_startup else []
+        self._on_shutdown = list(on_shutdown) if on_shutdown else []
+
+        # Starlette app (created lazily)
+        self._starlette_app: Optional[Starlette] = None
+
+    def add_middleware(
+        self,
+        middleware_class: type,
+        **options: Any,
+    ) -> None:
+        """
+        Add middleware to the application.
+
+        Args:
+            middleware_class: Middleware class
+            **options: Middleware configuration options
+
+        Example:
+            from starlette.middleware.cors import CORSMiddleware
+
+            app.add_middleware(
+                CORSMiddleware,
+                allow_origins=["*"],
+                allow_methods=["*"],
+            )
+        """
+        self._middleware.append(Middleware(middleware_class, **options))
+        # Invalidate cached Starlette app
+        self._starlette_app = None
+
+    def on_event(self, event_type: str) -> Callable:
+        """
+        Register lifecycle event handler.
+
+        Args:
+            event_type: Either "startup" or "shutdown"
+
+        Example:
+            @app.on_event("startup")
+            async def startup():
+                print("Starting up!")
+
+            @app.on_event("shutdown")
+            async def shutdown():
+                print("Shutting down!")
+        """
+
+        def decorator(func: Callable) -> Callable:
+            if event_type == "startup":
+                self._on_startup.append(func)
+            elif event_type == "shutdown":
+                self._on_shutdown.append(func)
+            else:
+                raise ValueError(f"Invalid event type: {event_type}")
+            # Invalidate cached Starlette app
+            self._starlette_app = None
+            return func
+
+        return decorator
+
+    def include_router(
+        self,
+        router: Router,
+        prefix: str = "",
+        tags: Optional[List[str]] = None,
+    ) -> None:
+        """
+        Include a router in the application.
+
+        Args:
+            router: Router to include
+            prefix: URL prefix for all routes
+            tags: Tags to add to all routes
+
+        Example:
+            users_router = Router()
+            @users_router.get("/{user_id}")
+            async def get_user(user_id: str):
+                return {"id": user_id}
+
+            app.include_router(users_router, prefix="/users", tags=["users"])
+        """
+        self._router.include_router(router, prefix=prefix, tags=tags)
+        # Invalidate cached Starlette app
+        self._starlette_app = None
+
+    def get(self, path: str, **kwargs: Any) -> Callable:
+        """
+        Decorator for GET requests.
+
+        Example:
+            @app.get("/items/{item_id}")
+            async def get_item(item_id: str):
+                return {"id": item_id}
+        """
+        return self._router.get(path, **kwargs)
+
+    def post(self, path: str, **kwargs: Any) -> Callable:
+        """Decorator for POST requests."""
+        return self._router.post(path, **kwargs)
+
+    def put(self, path: str, **kwargs: Any) -> Callable:
+        """Decorator for PUT requests."""
+        return self._router.put(path, **kwargs)
+
+    def patch(self, path: str, **kwargs: Any) -> Callable:
+        """Decorator for PATCH requests."""
+        return self._router.patch(path, **kwargs)
+
+    def delete(self, path: str, **kwargs: Any) -> Callable:
+        """Decorator for DELETE requests."""
+        return self._router.delete(path, **kwargs)
+
+    def route(self, path: str, methods: List[str], **kwargs: Any) -> Callable:
+        """
+        Decorator for custom methods.
+
+        Example:
+            @app.route("/items", methods=["GET", "POST"])
+            async def items():
+                return {"items": []}
+        """
+        return self._router.route(path, methods, **kwargs)
+
+    def _build_starlette_app(self) -> Starlette:
+        """Build the Starlette application from routes and middleware."""
+        # Convert Vega routes to Starlette routes
+        starlette_routes = [
+            route.to_starlette_route() for route in self._router.get_routes()
+        ]
+
+        # Create Starlette app
+        app = Starlette(
+            debug=self.debug,
+            routes=starlette_routes,
+            middleware=self._middleware,
+            on_startup=self._on_startup,
+            on_shutdown=self._on_shutdown,
+        )
+
+        return app
+
+    def _get_app(self) -> Starlette:
+        """Get or create the Starlette app."""
+        if self._starlette_app is None:
+            self._starlette_app = self._build_starlette_app()
+        return self._starlette_app
+
+    async def __call__(self, scope: dict, receive: Callable, send: Callable) -> None:
+        """
+        ASGI application callable.
+
+        This makes VegaApp a valid ASGI application.
+        """
+        app = self._get_app()
+        await app(scope, receive, send)
+
+
+__all__ = ["VegaApp"]