vega-framework 0.2.3__tar.gz → 0.2.5__tar.gz

{vega_framework-0.2.3 → vega_framework-0.2.5}/PKG-INFO

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

{vega_framework-0.2.3 → vega_framework-0.2.5}/pyproject.toml

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

{vega_framework-0.2.3 → vega_framework-0.2.5}/vega/cli/commands/generate.py

@@ -569,92 +569,33 @@ def _generate_middleware(project_root: Path, project_name: str, class_name: str,
 
     click.echo(f"+ Created {click.style(str(middleware_file.relative_to(project_root)), fg='green')}")
 
-    # Register the middleware in app.py
-    _register_middleware_in_app(project_root, class_name, file_name)
+    # Warn if legacy app-level registration is present
+    app_file = project_root / "presentation" / "web" / "app.py"
+    if app_file.exists():
+        app_content = app_file.read_text()
+        legacy_call = f"app.add_middleware({class_name}Middleware"
+        if legacy_call in app_content:
+            click.echo(click.style(
+                f"WARNING: Detected legacy app-level registration for {class_name}Middleware in presentation/web/app.py.",
+                fg='yellow'
+            ))
+            click.echo(click.style(
+                "         Route middleware should be applied with the @middleware decorator per route.",
+                fg='yellow'
+            ))
 
     # Instructions for next steps
     click.echo(f"\nNext steps:")
-    click.echo(f"   1. Implement your middleware logic in {class_name}Middleware.dispatch()")
-    click.echo(f"   2. The middleware has been registered in app.py")
-    click.echo(f"   3. Restart your server to apply changes")
-
-
-def _register_middleware_in_app(project_root: Path, class_name: str, file_name: str) -> None:
-    """Register a new middleware in app.py"""
-    app_file = project_root / "presentation" / "web" / "app.py"
-
-    if not app_file.exists():
-        click.echo(click.style("WARNING: app.py not found", fg='yellow'))
-        click.echo(f"\nTo register manually, add to app.py:")
-        click.echo(click.style(f'''
-from .middleware.{file_name} import {class_name}Middleware
-
-def create_app() -> VegaApp:
-    app = VegaApp(...)
-    app.add_middleware({class_name}Middleware)
-    app.include_router(get_api_router())
-    return app
-''', fg='cyan'))
-        return
-
-    content = app_file.read_text()
-    lines = content.split('\n')
-
-    # Check if already registered
-    middleware_import = f"from .middleware.{file_name} import {class_name}Middleware"
-    middleware_call = f"app.add_middleware({class_name}Middleware)"
-
-    if any(middleware_import in line for line in lines):
-        click.echo(click.style(f"WARNING: Middleware {class_name} already imported in app.py", fg='yellow'))
-        return
-
-    # Find import section and add middleware import
-    import_added = False
-    for i, line in enumerate(lines):
-        if line.startswith('from .routes import'):
-            # Add import before routes import
-            lines.insert(i, middleware_import)
-            lines.insert(i + 1, '')
-            import_added = True
-            break
-
-    if not import_added:
-        # Fallback: add after VegaApp import
-        for i, line in enumerate(lines):
-            if 'from vega.web import' in line:
-                lines.insert(i + 1, middleware_import)
-                lines.insert(i + 2, '')
-                break
-
-    # Find create_app function and add middleware registration
-    middleware_added = False
-    for i, line in enumerate(lines):
-        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
-
-            # Add middleware registration before include_router
-            lines.insert(j, f'    {middleware_call}')
-            middleware_added = True
-            break
-
-    if import_added or middleware_added:
-        app_file.write_text('\n'.join(lines))
-        click.echo(f"+ Updated {click.style(str(app_file.relative_to(project_root)), fg='green')}")
-    else:
-        click.echo(click.style("WARNING: Could not auto-register middleware in app.py", fg='yellow'))
-        click.echo(f"\nTo register manually, add to app.py:")
-        click.echo(click.style(f'''
-from .middleware.{file_name} import {class_name}Middleware
-
-def create_app() -> VegaApp:
-    app = VegaApp(...)
-    app.add_middleware({class_name}Middleware)
-    app.include_router(get_api_router())
-    return app
-''', fg='cyan'))
+    click.echo(f"   1. Implement your middleware logic in {class_name}Middleware.before/after().")
+    click.echo(f"   2. Apply it to routes using the @middleware decorator, for example:")
+    click.echo(click.style(f'''      from vega.web import middleware
+      from .middleware.{file_name} import {class_name}Middleware
+
+      @router.get("/example")
+      @middleware({class_name}Middleware())
+      async def example():
+          return {{"status": "ok"}}''', fg='cyan'))
+    click.echo(f"   3. Restart your server to load the updated route middleware.")
 
 
 

vega_framework-0.2.5/vega/cli/templates/web/middleware.py.j2

@@ -0,0 +1,56 @@
+"""{{ class_name }} middleware for Vega Web application"""
+from typing import Optional
+
+from vega.web import MiddlewarePhase, Request, Response, RouteMiddleware
+
+
+class {{ class_name }}Middleware(RouteMiddleware):
+    """
+    {{ class_name }} middleware.
+
+    This middleware runs in the Vega route middleware pipeline.
+
+    Usage:
+        from vega.web import middleware
+        from .middleware.{{ file_name }} import {{ class_name }}Middleware
+
+        @router.get("/example")
+        @middleware({{ class_name }}Middleware())
+        async def example_endpoint():
+            return {"message": "ok"}
+    """
+
+    def __init__(self):
+        super().__init__(phase=MiddlewarePhase.BOTH)
+        # Add any initialization logic here
+        # Example: self.audit_header = "X-Audit-ID"
+
+    async def before(self, request: Request) -> Optional[Response]:
+        """
+        Execute code before the route handler.
+
+        Return a Response to short-circuit the pipeline, or None to continue.
+        """
+        # Example: validate header and stop request
+        # from vega.web import JSONResponse, status
+        # if not request.headers.get("x-custom"):
+        #     return JSONResponse(
+        #         {"detail": "Missing X-Custom header"},
+        #         status_code=status.HTTP_400_BAD_REQUEST,
+        #     )
+
+        # Example: store data on request state for later middleware/handler
+        # request.state.audit_id = generate_request_id()
+        return None
+
+    async def after(self, request: Request, response: Response) -> Response:
+        """
+        Execute code after the route handler.
+
+        Always return the (modified) response object.
+        """
+        # Example: add header using previously stored state
+        # if hasattr(request.state, "audit_id") and hasattr(response, "headers"):
+        #     response.headers[self.audit_header] = request.state.audit_id
+
+        return response

{vega_framework-0.2.3 → vega_framework-0.2.5}/vega/web/openapi.py

@@ -93,15 +93,9 @@ def get_openapi_schema(
                 operation["parameters"] = params
 
             # Analyze request body
-            request_body = _get_request_body(route)
+            request_body = _get_request_body(route, components)
             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:
@@ -192,7 +186,7 @@ def _get_parameters(route: Any) -> List[Dict[str, Any]]:
     return parameters
 
 
-def _get_request_body(route: Any) -> Optional[Dict[str, Any]]:
+def _get_request_body(route: Any, components: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     """Extract request body schema from route."""
     if not PYDANTIC_AVAILABLE:
         return None
@@ -212,9 +206,12 @@ def _get_request_body(route: Any) -> Optional[Dict[str, Any]]:
 
         # 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__
 
+            # Add model schema to components
+            if model_name not in components["schemas"]:
+                components["schemas"][model_name] = param_type.model_json_schema()
+
             return {
                 "required": True,
                 "content": {

vega_framework-0.2.3/vega/cli/templates/web/middleware.py.j2

@@ -1,65 +0,0 @@
-"""{{ 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
-from typing import Callable
-
-
-class {{ class_name }}Middleware(BaseHTTPMiddleware):
-    """
-    {{ class_name }} middleware
-
-    This middleware processes requests before they reach your endpoints
-    and responses before they're returned to clients.
-
-    Usage:
-        Add to your Vega Web app in app.py:
-        from .middleware.{{ file_name }} import {{ class_name }}Middleware
-        app.add_middleware({{ class_name }}Middleware)
-    """
-
-    def __init__(self, app: ASGIApp):
-        super().__init__(app)
-        # Add any initialization logic here
-        # Example: self.config = load_config()
-
-    async def dispatch(self, request: Request, call_next: Callable) -> Response:
-        """
-        Process the request and response
-
-        Args:
-            request: The incoming request
-            call_next: Function to call the next middleware or endpoint
-
-        Returns:
-            Response object
-        """
-        # ==========================================
-        # BEFORE REQUEST - Add your logic here
-        # ==========================================
-        # Example: Log request
-        # print(f"Incoming request: {request.method} {request.url}")
-
-        # Example: Add custom headers
-        # request.state.custom_data = "some value"
-
-        # Example: Measure request time
-        start_time = time.time()
-
-        # ==========================================
-        # PROCESS REQUEST
-        # ==========================================
-        response = await call_next(request)
-
-        # ==========================================
-        # AFTER REQUEST - Add your logic here
-        # ==========================================
-        # Example: Add custom response headers
-        # response.headers["X-Process-Time"] = str(time.time() - start_time)
-
-        # Example: Log response
-        process_time = time.time() - start_time
-        # print(f"Request completed in {process_time:.4f}s")
-
-        return response