vega-framework 0.1.34__py3-none-any.whl → 0.2.0__py3-none-any.whl

vega/cli/commands/add.py

@@ -3,7 +3,7 @@ from pathlib import Path
 
 import click
 
-from vega.cli.scaffolds import create_fastapi_scaffold, create_sqlalchemy_scaffold
+from vega.cli.scaffolds import create_vega_web_scaffold, create_sqlalchemy_scaffold
 
 
 @click.command()
@@ -13,7 +13,7 @@ def add(feature: str, path: str):
     """Add features to an existing Vega project
 
     Features:
-        web        - Add FastAPI web scaffold to the project
+        web        - Add Vega Web scaffold to the project
         sqlalchemy - Add SQLAlchemy database support (alias: db)
         db         - Alias for sqlalchemy
 
@@ -40,13 +40,13 @@ def add(feature: str, path: str):
 
 
 def add_web_feature(project_path: Path, project_name: str):
-    """Add FastAPI web scaffold to existing project"""
-    click.echo(f"\n[*] Adding FastAPI web scaffold to: {click.style(project_name, fg='green', bold=True)}\n")
+    """Add Vega Web scaffold to existing project"""
+    click.echo(f"\n[*] Adding Vega Web scaffold to: {click.style(project_name, fg='green', bold=True)}\n")
 
     # Check if presentation/web already exists
     web_dir = project_path / "presentation" / "web"
     if web_dir.exists() and (web_dir / "main.py").exists():
-        click.echo(click.style("WARNING: FastAPI scaffold already exists!", fg='yellow'))
+        click.echo(click.style("WARNING: Web scaffold already exists!", fg='yellow'))
         if not click.confirm("Do you want to overwrite existing files?"):
             click.echo("Aborted.")
             return
@@ -60,13 +60,12 @@ def add_web_feature(project_path: Path, project_name: str):
         presentation_dir.mkdir(parents=True, exist_ok=True)
         click.echo(f"  + Created presentation/")
 
-    # Create FastAPI scaffold
-    create_fastapi_scaffold(project_path, project_name, overwrite=overwrite)
+    # Create Vega Web scaffold
+    create_vega_web_scaffold(project_path, project_name, overwrite=overwrite)
 
-    click.echo(f"\n{click.style('SUCCESS: FastAPI web scaffold added!', fg='green', bold=True)}\n")
+    click.echo(f"\n{click.style('SUCCESS: Vega Web scaffold added!', fg='green', bold=True)}\n")
     click.echo("Next steps:")
-    click.echo("  1. Add FastAPI dependencies:")
-    click.echo("     poetry add fastapi uvicorn[standard]")
+    click.echo("  1. Dependencies are already included in vega-framework")
     click.echo("  2. Run the server:")
     click.echo("     vega web run --reload")
     click.echo("  3. Visit http://localhost:8000/api/health/status")

vega/cli/commands/init.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 import click
 
-from vega.cli.scaffolds import create_fastapi_scaffold
+from vega.cli.scaffolds import create_vega_web_scaffold
 from vega.cli.templates.loader import render_template
 import vega
 
@@ -104,14 +104,15 @@ def init_project(project_name: str, template: str, parent_path: str):
     click.echo(f"  + Created ARCHITECTURE.md")
 
     # Create main.py based on template
-    if template == "fastapi":
-        click.echo("\n[*] Adding FastAPI scaffold (presentation/web/)")
-        create_fastapi_scaffold(project_path, project_name)
+    # Support both "web" and "fastapi" (backward compat)
+    if template in ["web", "fastapi"]:
+        click.echo("\n[*] Adding Vega Web scaffold (presentation/web/)")
+        create_vega_web_scaffold(project_path, project_name)
 
-        # Create main.py for FastAPI project
+        # Create main.py for web project
         main_content = render_template("main.py.j2", project_name=project_name, template="fastapi")
         (project_path / "main.py").write_text(main_content)
-        click.echo(f"  + Created main.py (FastAPI entrypoint)")
+        click.echo(f"  + Created main.py (Vega Web entrypoint)")
     else:
         # Create standard main.py
         main_content = render_template("main.py.j2", project_name=project_name, template="standard")
@@ -126,9 +127,9 @@ def init_project(project_name: str, template: str, parent_path: str):
     click.echo(f"  poetry install")
     click.echo(f"  cp .env.example .env")
 
-    if template == "fastapi":
+    if template in ["web", "fastapi"]:
         click.echo(f"\nRun commands:")
-        click.echo(f"  vega web run                # Start FastAPI server (http://localhost:8000)")
+        click.echo(f"  vega web run                # Start Vega Web server (http://localhost:8000)")
         click.echo(f"  vega web run --reload       # Start with auto-reload")
         click.echo(f"  python main.py hello        # Run CLI command")
         click.echo(f"  python main.py --help       # Show all commands")

vega/cli/main.py

@@ -34,7 +34,7 @@ def cli():
 
 @cli.command()
 @click.argument('project_name')
-@click.option('--template', default='basic', help='Project template (basic, fastapi, ai-rag)')
+@click.option('--template', default='basic', help='Project template (basic, web, ai-rag)')
 @click.option('--path', default='.', help='Parent directory for project')
 def init(project_name, template, path):
     """
@@ -49,7 +49,7 @@ def init(project_name, template, path):
 
     Examples:
         vega init my-app
-        vega init my-api --template=fastapi
+        vega init my-api --template=web
         vega init my-ai --template=ai-rag --path=./projects
     """
     init_project(project_name, template, path)
@@ -88,8 +88,8 @@ def generate(component_type, name, path, impl, request, response):
         service     - Service interface (domain layer)
         interactor  - Use case (business logic)
         mediator    - Workflow (orchestrates use cases)
-        router      - FastAPI router (requires web module)
-        middleware  - FastAPI middleware (requires web module)
+        router      - Vega Web router (requires web module)
+        middleware  - Vega Web middleware (requires web module)
         webmodel    - Pydantic request/response models (requires web module)
         model       - SQLAlchemy model (requires sqlalchemy module)
         command     - CLI command (async by default)

vega/cli/scaffolds/__init__.py

@@ -1,9 +1,13 @@
 """Scaffolding helpers for Vega CLI."""
 
-from .fastapi import create_fastapi_scaffold
+from .vega_web import create_vega_web_scaffold
 from .sqlalchemy import create_sqlalchemy_scaffold
 
+# Backward compatibility alias
+create_fastapi_scaffold = create_vega_web_scaffold
+
 __all__ = [
-    "create_fastapi_scaffold",
+    "create_vega_web_scaffold",
+    "create_fastapi_scaffold",  # Deprecated: use create_vega_web_scaffold
     "create_sqlalchemy_scaffold",
 ]

vega/cli/scaffolds/vega_web.py

@@ -0,0 +1,109 @@
+"""Vega Web scaffolding for new projects"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable, Iterable
+
+import click
+
+from vega.cli.templates import (
+    render_vega_app,
+    render_vega_health_route,
+    render_vega_main,
+    render_vega_routes_init_autodiscovery,
+    render_vega_user_route,
+    render_pydantic_models_init,
+    render_pydantic_user_models,
+    render_web_package_init,
+)
+
+
+def create_vega_web_scaffold(
+    project_root: Path,
+    project_name: str,
+    *,
+    overwrite: bool = False,
+    echo: Callable[[str], None] | None = None,
+) -> list[Path]:
+    """
+    Create Vega Web scaffolding under the project presentation/web/ directory.
+
+    This creates a complete web application structure using Vega's built-in
+    web framework (built on Starlette).
+
+    Args:
+        project_root: Root directory of the project
+        project_name: Name of the project
+        overwrite: Whether to overwrite existing files
+        echo: Function to print messages (defaults to click.echo)
+
+    Returns:
+        List of created file paths
+    """
+    if echo is None:
+        echo = click.echo
+
+    created: list[Path] = []
+    web_dir = project_root / "presentation" / "web"
+    routes_dir = web_dir / "routes"
+    models_dir = web_dir / "models"
+
+    files: Iterable[tuple[Path, str]] = (
+        (web_dir / "__init__.py", render_web_package_init()),
+        (web_dir / "app.py", render_vega_app(project_name)),
+        (web_dir / "main.py", render_vega_main(project_name)),
+        (routes_dir / "__init__.py", render_vega_routes_init_autodiscovery()),
+        (routes_dir / "health.py", render_vega_health_route()),
+        (routes_dir / "users.py", render_vega_user_route()),
+        (models_dir / "__init__.py", render_pydantic_models_init()),
+        (models_dir / "user_models.py", render_pydantic_user_models()),
+    )
+
+    web_dir.mkdir(parents=True, exist_ok=True)
+    routes_dir.mkdir(parents=True, exist_ok=True)
+    models_dir.mkdir(parents=True, exist_ok=True)
+
+    for path, content in files:
+        rel_path = path.relative_to(project_root)
+        if path.exists() and not overwrite:
+            echo(
+                click.style(
+                    f"WARNING: {rel_path} already exists. Skipping.",
+                    fg="yellow",
+                )
+            )
+            continue
+
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding="utf-8")
+        created.append(rel_path)
+        echo(f"+ Created {click.style(str(rel_path), fg='green')}")
+
+    echo("\n[TIP] Vega Web scaffold ready:")
+    echo("   1. poetry install  # sync dependencies (or poetry update)")
+    echo("   2. poetry run vega web run --reload")
+    echo("   3. Or: poetry run uvicorn presentation.web.main:app --reload")
+
+    return created
+
+
+def _ensure_dependency_line(lines: list[str], name: str, spec: str) -> bool:
+    """Insert dependency assignment into [tool.poetry.dependencies] if missing."""
+    header = "[tool.poetry.dependencies]"
+    try:
+        start = next(i for i, line in enumerate(lines) if line.strip() == header)
+    except StopIteration:
+        return False
+
+    end = start + 1
+    while end < len(lines) and not lines[end].startswith("["):
+        end += 1
+
+    block = lines[start + 1:end]
+    if any(line.strip().startswith(f"{name} =") for line in block):
+        return False
+
+    insertion = f"{name} = \"{spec}\"\n"
+    lines.insert(end, insertion)
+    return True

vega/cli/templates/__init__.py

@@ -7,18 +7,32 @@ from .components import (
     render_repository_interface,
     render_service_interface,
     render_web_package_init,
+    # New Vega Web functions
+    render_vega_app,
+    render_vega_routes_init,
+    render_vega_health_route,
+    render_vega_user_route,
+    render_vega_dependencies,
+    render_vega_main,
+    render_vega_project_main,
+    render_vega_router,
+    render_vega_middleware,
+    render_vega_routes_init_autodiscovery,
+    # Backward compatibility (deprecated)
     render_fastapi_app,
     render_fastapi_routes_init,
     render_fastapi_health_route,
     render_fastapi_user_route,
     render_fastapi_dependencies,
     render_fastapi_main,
-    render_standard_main,
     render_fastapi_project_main,
-    render_pydantic_models_init,
-    render_pydantic_user_models,
     render_fastapi_router,
     render_fastapi_middleware,
+    render_fastapi_routes_init_autodiscovery,
+    # Common
+    render_standard_main,
+    render_pydantic_models_init,
+    render_pydantic_user_models,
     render_database_manager,
     render_alembic_ini,
     render_alembic_env,
@@ -27,7 +41,6 @@ from .components import (
     render_cli_command,
     render_cli_command_simple,
     render_cli_commands_init,
-    render_fastapi_routes_init_autodiscovery,
     render_event,
     render_event_handler,
     render_events_init,
@@ -43,18 +56,32 @@ __all__ = [
     "render_infrastructure_repository",
     "render_infrastructure_service",
     "render_web_package_init",
+    # Vega Web
+    "render_vega_app",
+    "render_vega_routes_init",
+    "render_vega_health_route",
+    "render_vega_user_route",
+    "render_vega_dependencies",
+    "render_vega_main",
+    "render_vega_project_main",
+    "render_vega_router",
+    "render_vega_middleware",
+    "render_vega_routes_init_autodiscovery",
+    # Backward compat (deprecated)
     "render_fastapi_app",
     "render_fastapi_routes_init",
     "render_fastapi_health_route",
     "render_fastapi_user_route",
     "render_fastapi_dependencies",
     "render_fastapi_main",
-    "render_standard_main",
     "render_fastapi_project_main",
-    "render_pydantic_models_init",
-    "render_pydantic_user_models",
     "render_fastapi_router",
     "render_fastapi_middleware",
+    "render_fastapi_routes_init_autodiscovery",
+    # Common
+    "render_standard_main",
+    "render_pydantic_models_init",
+    "render_pydantic_user_models",
     "render_database_manager",
     "render_alembic_ini",
     "render_alembic_env",
@@ -63,7 +90,6 @@ __all__ = [
     "render_cli_command",
     "render_cli_command_simple",
     "render_cli_commands_init",
-    "render_fastapi_routes_init_autodiscovery",
     "render_event",
     "render_event_handler",
     "render_events_init",

vega/cli/templates/components.py

@@ -84,27 +84,27 @@ def render_web_package_init() -> str:
     return render_template("__init__.py.j2", subfolder="web")
 
 
-def render_fastapi_app(project_name: str) -> str:
+def render_vega_app(project_name: str) -> str:
     """Return the template for web/app.py"""
     return render_template("app.py.j2", subfolder="web", project_name=project_name)
 
 
-def render_fastapi_routes_init() -> str:
+def render_vega_routes_init() -> str:
     """Return the template for web/routes/__init__.py"""
     return render_template("routes_init.py.j2", subfolder="web")
 
 
-def render_fastapi_health_route() -> str:
+def render_vega_health_route() -> str:
     """Return the template for web/routes/health.py"""
     return render_template("health_route.py.j2", subfolder="web")
 
 
-def render_fastapi_dependencies() -> str:
+def render_vega_dependencies() -> str:
     """Return the template for web/dependencies.py"""
     return render_template("dependencies.py.j2", subfolder="web")
 
 
-def render_fastapi_main(project_name: str) -> str:
+def render_vega_main(project_name: str) -> str:
     """Return the template for presentation/web/main.py"""
     return render_template("main.py.j2", subfolder="web", project_name=project_name)
 
@@ -116,8 +116,8 @@ def render_standard_main(project_name: str) -> str:
     )
 
 
-def render_fastapi_project_main(project_name: str) -> str:
-    """Return the template for main.py (FastAPI project with Web and CLI)"""
+def render_vega_project_main(project_name: str) -> str:
+    """Return the template for main.py (Vega Web project with Web and CLI)"""
     return render_template(
         "main_fastapi.py.j2", subfolder="project", project_name=project_name
     )
@@ -133,13 +133,13 @@ def render_pydantic_user_models() -> str:
     return render_template("user_models.py.j2", subfolder="web")
 
 
-def render_fastapi_user_route() -> str:
+def render_vega_user_route() -> str:
     """Return the template for web/routes/users.py"""
     return render_template("users_route.py.j2", subfolder="web")
 
 
-def render_fastapi_router(resource_name: str, resource_file: str, project_name: str) -> str:
-    """Return the template for a FastAPI router"""
+def render_vega_router(resource_name: str, resource_file: str, project_name: str) -> str:
+    """Return the template for a Vega Web router"""
     return render_template(
         "router.py.j2",
         subfolder="web",
@@ -149,8 +149,8 @@ def render_fastapi_router(resource_name: str, resource_file: str, project_name:
     )
 
 
-def render_fastapi_middleware(class_name: str, file_name: str) -> str:
-    """Return the template for a FastAPI middleware"""
+def render_vega_middleware(class_name: str, file_name: str) -> str:
+    """Return the template for a Vega Web middleware"""
     return render_template(
         "middleware.py.j2",
         subfolder="web",
@@ -159,6 +159,18 @@ def render_fastapi_middleware(class_name: str, file_name: str) -> str:
     )
 
 
+# Backward compatibility aliases (deprecated)
+render_fastapi_app = render_vega_app
+render_fastapi_routes_init = render_vega_routes_init
+render_fastapi_health_route = render_vega_health_route
+render_fastapi_dependencies = render_vega_dependencies
+render_fastapi_main = render_vega_main
+render_fastapi_project_main = render_vega_project_main
+render_fastapi_user_route = render_vega_user_route
+render_fastapi_router = render_vega_router
+render_fastapi_middleware = render_vega_middleware
+
+
 def render_database_manager() -> str:
     """Return the template for database_manager.py"""
     return render_template("database_manager.py.j2", subfolder="sqlalchemy")
@@ -244,11 +256,15 @@ def render_cli_commands_init() -> str:
     return render_template("commands_init.py.j2", subfolder="cli")
 
 
-def render_fastapi_routes_init_autodiscovery() -> str:
+def render_vega_routes_init_autodiscovery() -> str:
     """Return the template for web/routes/__init__.py with auto-discovery"""
     return render_template("routes_init_autodiscovery.py.j2", subfolder="web")
 
 
+# Backward compatibility alias
+render_fastapi_routes_init_autodiscovery = render_vega_routes_init_autodiscovery
+
+
 def render_event(class_name: str, fields: list[dict]) -> str:
     """Return the template for a domain event"""
     return render_template(

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/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_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()