core-framework 0.12.5__tar.gz → 0.12.7__tar.gz

{core_framework-0.12.5 → core_framework-0.12.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-framework
-Version: 0.12.5
+Version: 0.12.7
 Summary: Core Framework - Django-inspired, FastAPI-powered. Alta performance, baixo acoplamento, produtividade extrema.
 Project-URL: Homepage, https://github.com/SorPuti/core-framework
 Project-URL: Documentation, https://github.com/SorPuti/core-framework#readme

{core_framework-0.12.5 → core_framework-0.12.7}/core/__init__.py

@@ -278,7 +278,7 @@ from core.exceptions import (
     MissingDependency,
 )
 
-__version__ = "0.12.5"
+__version__ = "0.12.7"
 __all__ = [
     # Models
     "Model",

{core_framework-0.12.5 → core_framework-0.12.7}/core/auth/__init__.py

@@ -121,9 +121,18 @@ from core.auth.views import (
 from core.auth.middleware import (
     AuthenticationMiddleware,
     OptionalAuthenticationMiddleware,
+    JWTAuthBackend,
+    AuthenticatedUser,
     ensure_auth_middleware,
 )
 
+# Helper functions for consistent user access
+from core.auth.helpers import (
+    get_request_user,
+    is_authenticated,
+    set_request_user,
+)
+
 __all__ = [
     # Base
     "AuthBackend",
@@ -196,5 +205,11 @@ __all__ = [
     # Middleware
     "AuthenticationMiddleware",
     "OptionalAuthenticationMiddleware",
+    "JWTAuthBackend",
+    "AuthenticatedUser",
     "ensure_auth_middleware",
+    # Helpers
+    "get_request_user",
+    "is_authenticated",
+    "set_request_user",
 ]

{core_framework-0.12.5 → core_framework-0.12.7}/core/auth/backends.py

@@ -161,14 +161,14 @@ class ModelBackend(AuthBackend):
     
     async def login(self, request: "Request", user: Any) -> None:
         """Executa ações pós-login."""
-        # Armazena usuário no request.state
-        request.state.user = user
+        # Armazena usuário no request.state (for backward compatibility)
+        from core.auth.helpers import set_request_user
+        set_request_user(request, user)
     
     async def logout(self, request: "Request", user: Any) -> None:
         """Executa ações de logout."""
-        # Remove usuário do request.state
-        if hasattr(request.state, "user"):
-            request.state.user = None
+        from core.auth.helpers import set_request_user
+        set_request_user(request, None)
 
 
 class TokenAuthBackend(AuthBackend):

{core_framework-0.12.5 → core_framework-0.12.7}/core/auth/decorators.py

@@ -29,6 +29,28 @@ if TYPE_CHECKING:
     pass
 
 
+def _get_user(request: Request) -> Any | None:
+    """
+    Get authenticated user from request.
+    
+    Internal helper to avoid circular imports.
+    Checks both Starlette and legacy patterns.
+    """
+    # Pattern 1: request.user (Starlette AuthenticationMiddleware)
+    user = getattr(request, "user", None)
+    if user is not None:
+        if getattr(user, "is_authenticated", False):
+            if hasattr(user, "_user"):
+                return user._user
+            return user
+    
+    # Pattern 2: request.state.user (legacy)
+    if hasattr(request, "state"):
+        return getattr(request.state, "user", None)
+    
+    return None
+
+
 # =============================================================================
 # Classes de Permissão (para uso em ViewSets)
 # =============================================================================
@@ -70,7 +92,7 @@ class HasPermission(PermissionBase):
         request: Request,
         view: Any = None,
     ) -> bool:
-        user = getattr(request.state, "user", None)
+        user = _get_user(request)
         
         if user is None:
             return False
@@ -135,7 +157,7 @@ class IsInGroup(PermissionBase):
         request: Request,
         view: Any = None,
     ) -> bool:
-        user = getattr(request.state, "user", None)
+        user = _get_user(request)
         
         if user is None:
             return False
@@ -179,7 +201,7 @@ class IsSuperuser(PermissionBase):
         request: Request,
         view: Any = None,
     ) -> bool:
-        user = getattr(request.state, "user", None)
+        user = _get_user(request)
         
         if user is None:
             return False
@@ -207,7 +229,7 @@ class IsStaff(PermissionBase):
         request: Request,
         view: Any = None,
     ) -> bool:
-        user = getattr(request.state, "user", None)
+        user = _get_user(request)
         
         if user is None:
             return False
@@ -235,7 +257,7 @@ class IsActive(PermissionBase):
         request: Request,
         view: Any = None,
     ) -> bool:
-        user = getattr(request.state, "user", None)
+        user = _get_user(request)
         
         if user is None:
             return False
@@ -371,7 +393,7 @@ def login_required():
             ...
     """
     async def check(request: Request):
-        user = getattr(request.state, "user", None)
+        user = _get_user(request)
         
         if user is None:
             raise HTTPException(

core_framework-0.12.7/core/auth/helpers.py

@@ -0,0 +1,104 @@
+"""
+Helper functions for authentication.
+
+Provides consistent user access across the framework, supporting both:
+- request.user (Starlette AuthenticationMiddleware pattern - preferred)
+- request.state.user (legacy pattern - backward compatibility)
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from starlette.requests import Request
+
+logger = logging.getLogger("core.auth")
+
+
+def get_request_user(request: "Request") -> Any | None:
+    """
+    Get authenticated user from request.
+    
+    Checks both patterns for compatibility:
+    1. request.user (Starlette AuthenticationMiddleware - preferred)
+    2. request.state.user (legacy pattern)
+    
+    Args:
+        request: The Starlette/FastAPI request object
+        
+    Returns:
+        The authenticated user model or None if not authenticated
+        
+    Example:
+        from core.auth.helpers import get_request_user
+        
+        async def my_view(request: Request):
+            user = get_request_user(request)
+            if user is None:
+                raise HTTPException(401, "Not authenticated")
+    """
+    # Pattern 1: request.user (Starlette AuthenticationMiddleware)
+    user = getattr(request, "user", None)
+    if user is not None:
+        # Check if it's an authenticated user (has is_authenticated = True)
+        if getattr(user, "is_authenticated", False):
+            # If it's our AuthenticatedUser wrapper, return the underlying model
+            if hasattr(user, "_user"):
+                return user._user
+            return user
+    
+    # Pattern 2: request.state.user (legacy)
+    user = getattr(request.state, "user", None) if hasattr(request, "state") else None
+    
+    return user
+
+
+def is_authenticated(request: "Request") -> bool:
+    """
+    Check if request has an authenticated user.
+    
+    Args:
+        request: The Starlette/FastAPI request object
+        
+    Returns:
+        True if authenticated, False otherwise
+    """
+    # Pattern 1: request.user with is_authenticated
+    user = getattr(request, "user", None)
+    if user is not None and getattr(user, "is_authenticated", False):
+        return True
+    
+    # Pattern 2: request.state.user
+    if hasattr(request, "state"):
+        user = getattr(request.state, "user", None)
+        if user is not None:
+            return True
+    
+    return False
+
+
+def set_request_user(request: "Request", user: Any | None) -> None:
+    """
+    Set the authenticated user on the request.
+    
+    Sets both patterns for maximum compatibility:
+    - request.state.user (for dependencies and legacy code)
+    
+    Note: request.user is set by Starlette's AuthenticationMiddleware
+    via scope["user"] and cannot be set directly.
+    
+    Args:
+        request: The Starlette/FastAPI request object
+        user: The user model or None
+    """
+    if hasattr(request, "state"):
+        request.state.user = user
+
+
+__all__ = [
+    "get_request_user",
+    "is_authenticated", 
+    "set_request_user",
+]

{core_framework-0.12.5 → core_framework-0.12.7}/core/cli/main.py

@@ -1039,9 +1039,10 @@ class AuthViewSet(ModelViewSet):
         Returns:
             Current user data
         """
-        # User is available via request.state.user (populated by auth middleware)
+        # User is available via request.user (Starlette pattern) or request.state.user (legacy)
         # permission_classes=[IsAuthenticated] ensures user is authenticated
-        user = request.state.user
+        from core.auth.helpers import get_request_user
+        user = get_request_user(request)
         
         if user is None:
             raise HTTPException(status_code=401, detail="Authentication required")
@@ -1065,9 +1066,10 @@ class AuthViewSet(ModelViewSet):
         body = await request.json()
         data = ChangePasswordInput.model_validate(body)
         
-        # User is available via request.state.user (populated by auth middleware)
+        # User is available via request.user (Starlette pattern) or request.state.user (legacy)
         # permission_classes=[IsAuthenticated] ensures user is authenticated
-        user = request.state.user
+        from core.auth.helpers import get_request_user
+        user = get_request_user(request)
         
         if user is None:
             raise HTTPException(status_code=401, detail="Authentication required")

{core_framework-0.12.5 → core_framework-0.12.7}/core/dependencies.py

@@ -395,12 +395,14 @@ async def get_request_context(request: Request) -> dict[str, Any]:
     
     Útil para logging e auditoria.
     """
+    from core.auth.helpers import get_request_user
+    
     return {
         "method": request.method,
         "url": str(request.url),
         "client_ip": request.client.host if request.client else None,
         "user_agent": request.headers.get("user-agent"),
-        "user": getattr(request.state, "user", None),
+        "user": get_request_user(request),
     }
 
 

{core_framework-0.12.5 → core_framework-0.12.7}/core/permissions.py

@@ -19,6 +19,29 @@ if TYPE_CHECKING:
     from core.views import APIView
 
 
+def _get_user(request: Request) -> Any | None:
+    """
+    Get authenticated user from request.
+    
+    Internal helper to avoid circular imports.
+    Checks both Starlette and legacy patterns.
+    """
+    # Pattern 1: request.user (Starlette AuthenticationMiddleware)
+    user = getattr(request, "user", None)
+    if user is not None:
+        if getattr(user, "is_authenticated", False):
+            # If it's our AuthenticatedUser wrapper, return the underlying model
+            if hasattr(user, "_user"):
+                return user._user
+            return user
+    
+    # Pattern 2: request.state.user (legacy)
+    if hasattr(request, "state"):
+        return getattr(request.state, "user", None)
+    
+    return None
+
+
 class Permission(ABC):
     """
     Classe base para permissões.
@@ -32,7 +55,7 @@ class Permission(ABC):
                 request: Request,
                 view: APIView | None = None,
             ) -> bool:
-                user = getattr(request.state, "user", None)
+                user = _get_user(request)
                 return user is not None and user.is_admin
     """
     
@@ -214,7 +237,7 @@ class IsAuthenticated(Permission):
         request: Request,
         view: "APIView | None" = None,
     ) -> bool:
-        user = getattr(request.state, "user", None)
+        user = _get_user(request)
         return user is not None
 
 
@@ -236,7 +259,7 @@ class IsAuthenticatedOrReadOnly(Permission):
         if request.method in self.SAFE_METHODS:
             return True
         
-        user = getattr(request.state, "user", None)
+        user = _get_user(request)
         return user is not None
 
 
@@ -250,7 +273,7 @@ class IsAdmin(Permission):
         request: Request,
         view: "APIView | None" = None,
     ) -> bool:
-        user = getattr(request.state, "user", None)
+        user = _get_user(request)
         if user is None:
             return False
         
@@ -285,7 +308,7 @@ class IsOwner(Permission):
         if obj is None:
             return True
         
-        user = getattr(request.state, "user", None)
+        user = _get_user(request)
         if user is None:
             return False
         
@@ -318,7 +341,7 @@ class HasRole(Permission):
         request: Request,
         view: "APIView | None" = None,
     ) -> bool:
-        user = getattr(request.state, "user", None)
+        user = _get_user(request)
         if user is None:
             return False
         

{core_framework-0.12.5 → core_framework-0.12.7}/core/tenancy.py

@@ -231,8 +231,9 @@ async def extract_tenant_from_request(
 
     Checks user, header, and query param in order.
     """
-    # tenant_id = await extract_tenant_from_request(request)
-    user = getattr(request.state, "user", None)
+    from core.auth.helpers import get_request_user
+    
+    user = get_request_user(request)
     if user is not None:
         tenant_id = getattr(user, user_tenant_attr, None)
         if tenant_id is not None:

{core_framework-0.12.5 → core_framework-0.12.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "core-framework"
-version = "0.12.5"
+version = "0.12.7"
 description = "Core Framework - Django-inspired, FastAPI-powered. Alta performance, baixo acoplamento, produtividade extrema."
 requires-python = ">=3.10,<4.0"
 readme = "README.md"

core_framework-0.12.7/tests/test_auth_helpers.py

@@ -0,0 +1,206 @@
+"""
+Tests for auth helpers.
+
+These tests validate the get_request_user helper works correctly
+with both Starlette and legacy patterns.
+"""
+
+import pytest
+from unittest.mock import MagicMock, PropertyMock
+
+
+class TestGetRequestUser:
+    """Test get_request_user helper function."""
+    
+    def test_returns_none_when_no_user(self):
+        """Test returns None when no user is set."""
+        from core.auth.helpers import get_request_user
+        
+        request = MagicMock()
+        request.user = None
+        request.state = MagicMock()
+        request.state.user = None
+        
+        result = get_request_user(request)
+        assert result is None
+    
+    def test_returns_user_from_starlette_pattern(self):
+        """Test returns user from request.user (Starlette pattern)."""
+        from core.auth.helpers import get_request_user
+        
+        # Create a mock user that looks like AuthenticatedUser
+        mock_user = MagicMock()
+        mock_user.is_authenticated = True
+        mock_user._user = MagicMock()  # The underlying model
+        mock_user._user.email = "test@example.com"
+        
+        request = MagicMock()
+        request.user = mock_user
+        
+        result = get_request_user(request)
+        assert result == mock_user._user
+    
+    def test_returns_user_from_legacy_pattern(self):
+        """Test returns user from request.state.user (legacy pattern)."""
+        from core.auth.helpers import get_request_user
+        
+        mock_user = MagicMock()
+        mock_user.email = "test@example.com"
+        
+        request = MagicMock()
+        request.user = MagicMock()
+        request.user.is_authenticated = False  # Not authenticated via Starlette
+        request.state = MagicMock()
+        request.state.user = mock_user
+        
+        result = get_request_user(request)
+        assert result == mock_user
+    
+    def test_prefers_starlette_over_legacy(self):
+        """Test prefers request.user over request.state.user."""
+        from core.auth.helpers import get_request_user
+        
+        starlette_user = MagicMock()
+        starlette_user.is_authenticated = True
+        starlette_user._user = MagicMock()
+        starlette_user._user.email = "starlette@example.com"
+        
+        legacy_user = MagicMock()
+        legacy_user.email = "legacy@example.com"
+        
+        request = MagicMock()
+        request.user = starlette_user
+        request.state = MagicMock()
+        request.state.user = legacy_user
+        
+        result = get_request_user(request)
+        # Should return the Starlette user
+        assert result.email == "starlette@example.com"
+    
+    def test_handles_missing_state(self):
+        """Test handles request without state attribute."""
+        from core.auth.helpers import get_request_user
+        
+        request = MagicMock(spec=[])  # No attributes by default
+        request.user = None
+        
+        # This should not raise an error
+        result = get_request_user(request)
+        assert result is None
+
+
+class TestIsAuthenticated:
+    """Test is_authenticated helper function."""
+    
+    def test_returns_false_when_no_user(self):
+        """Test returns False when no user."""
+        from core.auth.helpers import is_authenticated
+        
+        request = MagicMock()
+        request.user = None
+        request.state = MagicMock()
+        request.state.user = None
+        
+        assert is_authenticated(request) is False
+    
+    def test_returns_true_for_starlette_user(self):
+        """Test returns True for Starlette authenticated user."""
+        from core.auth.helpers import is_authenticated
+        
+        mock_user = MagicMock()
+        mock_user.is_authenticated = True
+        
+        request = MagicMock()
+        request.user = mock_user
+        
+        assert is_authenticated(request) is True
+    
+    def test_returns_true_for_legacy_user(self):
+        """Test returns True for legacy user."""
+        from core.auth.helpers import is_authenticated
+        
+        mock_user = MagicMock()
+        
+        request = MagicMock()
+        request.user = MagicMock()
+        request.user.is_authenticated = False
+        request.state = MagicMock()
+        request.state.user = mock_user
+        
+        assert is_authenticated(request) is True
+
+
+class TestSetRequestUser:
+    """Test set_request_user helper function."""
+    
+    def test_sets_user_on_state(self):
+        """Test sets user on request.state."""
+        from core.auth.helpers import set_request_user
+        
+        mock_user = MagicMock()
+        request = MagicMock()
+        request.state = MagicMock()
+        
+        set_request_user(request, mock_user)
+        
+        assert request.state.user == mock_user
+    
+    def test_clears_user_when_none(self):
+        """Test clears user when None is passed."""
+        from core.auth.helpers import set_request_user
+        
+        request = MagicMock()
+        request.state = MagicMock()
+        request.state.user = MagicMock()  # Previous user
+        
+        set_request_user(request, None)
+        
+        assert request.state.user is None
+
+
+class TestAuthenticatedUserWrapper:
+    """Test AuthenticatedUser wrapper class."""
+    
+    def test_is_authenticated_property(self):
+        """Test is_authenticated returns True."""
+        from core.auth.middleware import AuthenticatedUser
+        
+        mock_model = MagicMock()
+        wrapper = AuthenticatedUser(mock_model)
+        
+        assert wrapper.is_authenticated is True
+    
+    def test_proxies_attributes(self):
+        """Test proxies attribute access to underlying model."""
+        from core.auth.middleware import AuthenticatedUser
+        
+        mock_model = MagicMock()
+        mock_model.email = "test@example.com"
+        mock_model.id = 123
+        
+        wrapper = AuthenticatedUser(mock_model)
+        
+        assert wrapper.email == "test@example.com"
+        assert wrapper.id == 123
+    
+    def test_display_name(self):
+        """Test display_name returns email."""
+        from core.auth.middleware import AuthenticatedUser
+        
+        mock_model = MagicMock()
+        mock_model.email = "test@example.com"
+        
+        wrapper = AuthenticatedUser(mock_model)
+        
+        assert wrapper.display_name == "test@example.com"
+    
+    def test_identity(self):
+        """Test identity returns string id."""
+        from core.auth.middleware import AuthenticatedUser
+        
+        mock_model = MagicMock()
+        mock_model.id = 123
+        
+        wrapper = AuthenticatedUser(mock_model)
+        
+        assert wrapper.identity == "123"