django-cfg 1.4.46__py3-none-any.whl → 1.5.181__py3-none-any.whl

django_cfg/middleware/pool_cleanup.py

@@ -0,0 +1,261 @@
+"""
+Connection Pool Cleanup Middleware.
+
+Ensures database connections are properly returned to the pool after each
+request, including error cases. Prevents connection leaks in production.
+
+Usage:
+    Add to MIDDLEWARE in settings.py:
+    MIDDLEWARE = [
+        # ... other middleware ...
+        'django_cfg.middleware.pool_cleanup.ConnectionPoolCleanupMiddleware',
+    ]
+
+Note:
+    This middleware should be placed AFTER all other middleware to ensure
+    cleanup happens regardless of what other middleware does.
+"""
+
+import logging
+import time
+from typing import Callable
+
+from django.db import connection, connections, transaction
+from django.http import HttpRequest, HttpResponse
+from django.utils.deprecation import MiddlewareMixin
+
+logger = logging.getLogger('django_cfg.middleware.pool_cleanup')
+
+
+class ConnectionPoolCleanupMiddleware(MiddlewareMixin):
+    """
+    Middleware to ensure database connections are cleaned up after each request.
+
+    Features:
+    - Closes connections after successful responses
+    - Closes connections after exceptions
+    - Rolls back uncommitted transactions on errors
+    - Works with both sync and async views
+    - Minimal performance overhead (<1ms)
+
+    This middleware is critical when using connection pooling with
+    ATOMIC_REQUESTS=False, as it ensures connections don't leak.
+    """
+
+    def __init__(self, get_response: Callable):
+        """
+        Initialize middleware.
+
+        Args:
+            get_response: The next middleware or view to call
+        """
+        super().__init__(get_response)
+        self.get_response = get_response
+        self._enable_logging = False  # Set to True for debug logging
+
+    def __call__(self, request: HttpRequest) -> HttpResponse:
+        """
+        Process request through middleware chain.
+
+        Args:
+            request: The HTTP request
+
+        Returns:
+            HttpResponse from view or next middleware
+        """
+        start_time = time.time() if self._enable_logging else None
+
+        try:
+            response = self.get_response(request)
+            return response
+        finally:
+            # Cleanup happens in finally block to ensure it runs
+            self._cleanup_connections(request, rollback_on_error=False)
+
+            if self._enable_logging and start_time:
+                duration_ms = (time.time() - start_time) * 1000
+                logger.debug(f"Pool cleanup overhead: {duration_ms:.2f}ms")
+
+    def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse:
+        """
+        Process response before returning to client.
+
+        Called after view execution for successful responses.
+
+        Args:
+            request: The HTTP request
+            response: The HTTP response from view
+
+        Returns:
+            The HTTP response (unchanged)
+        """
+        # Cleanup handled in __call__ finally block
+        return response
+
+    def process_exception(self, request: HttpRequest, exception: Exception) -> None:
+        """
+        Process exception raised during request handling.
+
+        Called when view raises an exception. Rolls back any pending
+        transactions and closes connections.
+
+        Args:
+            request: The HTTP request
+            exception: The exception that was raised
+
+        Returns:
+            None (allows exception to propagate)
+        """
+        logger.warning(
+            f"Exception in request, rolling back transactions: {exception.__class__.__name__}",
+            extra={
+                'path': request.path,
+                'method': request.method,
+                'exception': str(exception),
+            }
+        )
+
+        # Rollback all open transactions
+        self._cleanup_connections(request, rollback_on_error=True)
+
+        # Return None to allow exception to propagate
+        return None
+
+    def _cleanup_connections(self, request: HttpRequest, rollback_on_error: bool = False) -> None:
+        """
+        Clean up all database connections.
+
+        Args:
+            request: The HTTP request
+            rollback_on_error: If True, rollback uncommitted transactions
+        """
+        for db_alias in connections:
+            try:
+                conn = connections[db_alias]
+
+                # Check if connection is open
+                if conn.connection is None:
+                    continue
+
+                # Rollback uncommitted transactions if requested
+                if rollback_on_error:
+                    self._rollback_transaction(conn, db_alias)
+
+                # Close the connection to return it to pool
+                # Django's close() is safe to call multiple times
+                conn.close()
+
+            except Exception as e:
+                logger.error(
+                    f"Error cleaning up connection '{db_alias}': {e}",
+                    exc_info=True,
+                    extra={
+                        'database': db_alias,
+                        'path': request.path,
+                    }
+                )
+
+    def _rollback_transaction(self, conn, db_alias: str) -> None:
+        """
+        Rollback any uncommitted transaction on a connection.
+
+        Args:
+            conn: Database connection
+            db_alias: Database alias for logging
+        """
+        try:
+            # Check if there's an open transaction
+            if conn.in_atomic_block:
+                logger.debug(f"Rolling back transaction for database '{db_alias}'")
+                conn.rollback()
+        except Exception as e:
+            logger.error(
+                f"Error rolling back transaction for '{db_alias}': {e}",
+                exc_info=True
+            )
+
+
+class AsyncConnectionPoolCleanupMiddleware:
+    """
+    Async version of ConnectionPoolCleanupMiddleware.
+
+    Use this middleware in ASGI deployments for better async compatibility.
+
+    Usage:
+        MIDDLEWARE = [
+            'django_cfg.middleware.pool_cleanup.AsyncConnectionPoolCleanupMiddleware',
+        ]
+    """
+
+    def __init__(self, get_response: Callable):
+        """
+        Initialize async middleware.
+
+        Args:
+            get_response: The next middleware or view to call
+        """
+        self.get_response = get_response
+        self._enable_logging = False
+
+    async def __call__(self, request: HttpRequest) -> HttpResponse:
+        """
+        Process request through middleware chain (async).
+
+        Args:
+            request: The HTTP request
+
+        Returns:
+            HttpResponse from view or next middleware
+        """
+        start_time = time.time() if self._enable_logging else None
+
+        try:
+            response = await self.get_response(request)
+            return response
+        except Exception as e:
+            # Rollback on exception
+            logger.warning(
+                f"Exception in async request, rolling back: {e.__class__.__name__}",
+                extra={'path': request.path, 'exception': str(e)}
+            )
+            self._cleanup_connections(request, rollback_on_error=True)
+            raise
+        finally:
+            # Always cleanup connections
+            self._cleanup_connections(request, rollback_on_error=False)
+
+            if self._enable_logging and start_time:
+                duration_ms = (time.time() - start_time) * 1000
+                logger.debug(f"Async pool cleanup overhead: {duration_ms:.2f}ms")
+
+    def _cleanup_connections(self, request: HttpRequest, rollback_on_error: bool = False) -> None:
+        """
+        Clean up all database connections (sync code in async middleware).
+
+        Args:
+            request: The HTTP request
+            rollback_on_error: If True, rollback uncommitted transactions
+        """
+        for db_alias in connections:
+            try:
+                conn = connections[db_alias]
+
+                if conn.connection is None:
+                    continue
+
+                if rollback_on_error and conn.in_atomic_block:
+                    logger.debug(f"Rolling back async transaction for '{db_alias}'")
+                    conn.rollback()
+
+                conn.close()
+
+            except Exception as e:
+                logger.error(
+                    f"Error cleaning up async connection '{db_alias}': {e}",
+                    exc_info=True,
+                    extra={'database': db_alias, 'path': request.path}
+                )
+
+
+# Default export - use sync middleware
+__all__ = ['ConnectionPoolCleanupMiddleware', 'AsyncConnectionPoolCleanupMiddleware']

django_cfg/middleware/public_endpoints.py

@@ -152,7 +152,6 @@ class PublicEndpointsMiddleware(MiddlewareMixin):
         return {
             **self.stats,
             'public_patterns_count': len(self.public_patterns),
-            'middleware_active': True,
         }
 
     def reset_stats(self):

django_cfg/middleware/user_activity.py

@@ -50,9 +50,6 @@ class UserActivityMiddleware(MiddlewareMixin, BaseCfgModule):
         Args:
             request: Django HttpRequest object
         """
-        # Only process if accounts app is enabled
-        if not self.is_accounts_enabled():
-            return None
 
         # Only track authenticated users
         if not hasattr(request, 'user') or not request.user.is_authenticated:
@@ -169,6 +166,4 @@ class UserActivityMiddleware(MiddlewareMixin, BaseCfgModule):
             'tracked_users': len(self._last_updates),
             'update_interval': self.update_interval,
             'api_only': self.api_only,
-            'accounts_enabled': self.is_accounts_enabled(),
-            'middleware_active': self.is_accounts_enabled(),
         }

django_cfg/mixins/__init__.py

@@ -0,0 +1,17 @@
+"""
+Django-CFG Common Mixins.
+
+Shared mixins for DRF views and viewsets.
+"""
+
+from .admin_api import AdminAPIMixin
+from .client_api import ClientAPIMixin
+from .public_api import PublicAPIMixin
+from .superadmin_api import SuperAdminAPIMixin
+
+__all__ = [
+    "AdminAPIMixin",
+    "ClientAPIMixin",
+    "PublicAPIMixin",
+    "SuperAdminAPIMixin",
+]

django_cfg/mixins/admin_api.py

@@ -0,0 +1,37 @@
+"""
+Admin API Mixin.
+
+Common configuration for admin-only API endpoints.
+"""
+from rest_framework.authentication import BasicAuthentication, SessionAuthentication
+from rest_framework.permissions import IsAdminUser
+from rest_framework_simplejwt.authentication import JWTAuthentication
+
+
+class AdminAPIMixin:
+    """
+    Mixin for admin-only API endpoints.
+
+    Provides:
+    - JWT, Session, and Basic authentication
+    - IsAdminUser permission requirement
+
+    Usage:
+        class MyViewSet(AdminAPIMixin, viewsets.ModelViewSet):
+            queryset = MyModel.objects.all()
+            serializer_class = MySerializer
+
+    Authentication Methods:
+        1. JWT Token (Bearer): For frontend SPA authentication
+        2. Session: For Django admin integration
+        3. Basic Auth: For testing and scripts
+
+    All endpoints require admin user privileges.
+    """
+
+    authentication_classes = [
+        JWTAuthentication,      # JWT tokens (Bearer)
+        SessionAuthentication,  # Django session (for admin)
+        BasicAuthentication,    # HTTP Basic (for testing)
+    ]
+    permission_classes = [IsAdminUser]

django_cfg/mixins/client_api.py

@@ -0,0 +1,39 @@
+"""
+Client API Mixin.
+
+Common configuration for client API endpoints (authenticated users).
+"""
+from rest_framework.authentication import SessionAuthentication
+from rest_framework.permissions import IsAuthenticated
+from rest_framework_simplejwt.authentication import JWTAuthentication
+
+
+class ClientAPIMixin:
+    """
+    Mixin for client API endpoints (authenticated regular users).
+
+    Provides:
+    - JWT and Session authentication
+    - IsAuthenticated permission requirement
+
+    Usage:
+        class MyViewSet(ClientAPIMixin, viewsets.ModelViewSet):
+            queryset = MyModel.objects.all()
+            serializer_class = MySerializer
+
+            def get_queryset(self):
+                # Filter by current user
+                return super().get_queryset().filter(user=self.request.user)
+
+    Authentication Methods:
+        1. JWT Token (Bearer): For frontend SPA authentication
+        2. Session: For web browser sessions
+
+    All endpoints require authenticated user (not necessarily admin).
+    """
+
+    authentication_classes = [
+        JWTAuthentication,      # JWT tokens (Bearer)
+        SessionAuthentication,  # Django session
+    ]
+    permission_classes = [IsAuthenticated]

django_cfg/mixins/public_api.py

@@ -0,0 +1,31 @@
+"""
+Public API Mixin.
+
+Mixin for public API endpoints without authentication.
+CORS is handled by PublicAPICORSMiddleware (configured via PUBLIC_API_CORS_PATHS).
+"""
+
+from typing import Any, List
+
+from rest_framework.permissions import AllowAny
+
+
+class PublicAPIMixin:
+    """
+    Mixin for public API endpoints.
+
+    Provides:
+    - AllowAny permission (no authentication required)
+    - No authentication classes
+
+    CORS is handled by PublicAPICORSMiddleware middleware.
+    Configure paths in settings: PUBLIC_API_CORS_PATHS = ['/cfg/leads/']
+
+    Usage:
+        class LeadViewSet(PublicAPIMixin, viewsets.ModelViewSet):
+            queryset = Lead.objects.all()
+            serializer_class = LeadSerializer
+    """
+
+    permission_classes = [AllowAny]
+    authentication_classes: List[Any] = []

django_cfg/mixins/superadmin_api.py

@@ -0,0 +1,59 @@
+"""
+SuperAdmin API Mixin.
+
+Common configuration for superuser-only API endpoints.
+More restrictive than AdminAPIMixin - requires is_superuser flag.
+"""
+from rest_framework.authentication import BasicAuthentication, SessionAuthentication
+from rest_framework.permissions import BasePermission
+from rest_framework_simplejwt.authentication import JWTAuthentication
+
+
+class IsSuperUser(BasePermission):
+    """
+    Permission that allows access only to superusers.
+
+    More restrictive than IsAdminUser - requires is_superuser flag.
+    Use for sensitive operations like command execution.
+    """
+
+    def has_permission(self, request, view):
+        """Check if user is authenticated and is a superuser."""
+        return bool(
+            request.user and
+            request.user.is_authenticated and
+            request.user.is_superuser
+        )
+
+
+class SuperAdminAPIMixin:
+    """
+    Mixin for superuser-only API endpoints.
+
+    Provides:
+    - JWT, Session, and Basic authentication
+    - IsSuperUser permission requirement (is_superuser=True)
+
+    Usage:
+        class MyViewSet(SuperAdminAPIMixin, viewsets.ModelViewSet):
+            queryset = MyModel.objects.all()
+            serializer_class = MySerializer
+
+    Authentication Methods:
+        1. JWT Token (Bearer): For frontend SPA authentication
+        2. Session: For Django admin integration
+        3. Basic Auth: For testing and scripts
+
+    All endpoints require superuser privileges.
+    Only use this for sensitive operations like:
+    - Command execution
+    - System configuration changes
+    - Direct database operations
+    """
+
+    authentication_classes = [
+        JWTAuthentication,      # JWT tokens (Bearer)
+        SessionAuthentication,  # Django session (for admin)
+        BasicAuthentication,    # HTTP Basic (for testing)
+    ]
+    permission_classes = [IsSuperUser]

django_cfg/models/__init__.py

@@ -28,16 +28,29 @@ from .api.drf.swagger import SwaggerUISettings
 from .api.jwt import JWTConfig
 from .api.keys import ApiKeys
 from .api.limits import LimitsConfig
+from .api.oauth import GitHubOAuthConfig, OAuthConfig
+from .api.twofactor import TwoFactorConfig
 from .base.config import BaseConfig, BaseSettings
 from .base.module import BaseCfgAutoModule
-from .django.constance import ConstanceConfig, ConstanceField
 
 # Django-specific
+from .django.axes import AxesConfig
+from .django.constance import ConstanceConfig, ConstanceField
+from .django.crypto_fields import CryptoFieldsConfig
+from .django.currency import CurrencyConfig
+from .django.django_rq import DjangoRQConfig, RQQueueConfig
 from .django.environment import EnvironmentConfig
 from .django.openapi import OpenAPIClientConfig
 from .infrastructure.cache import CacheConfig
 
 # Infrastructure
+from .infrastructure.backup import (
+    BackupConfig,
+    BackupDatabaseConfig,
+    BackupRetentionConfig,
+    BackupScheduleConfig,
+    BackupStorageConfig,
+)
 from .infrastructure.database import DatabaseConfig
 from .infrastructure.logging import LoggingConfig
 from .infrastructure.security import SecurityConfig
@@ -59,8 +72,13 @@ __all__ = [
     "BaseSettings",
     "BaseCfgAutoModule",
     # Infrastructure
-    "DatabaseConfig",
+    "BackupConfig",
+    "BackupDatabaseConfig",
+    "BackupRetentionConfig",
+    "BackupScheduleConfig",
+    "BackupStorageConfig",
     "CacheConfig",
+    "DatabaseConfig",
     "LoggingConfig",
     "SecurityConfig",
     # API
@@ -77,8 +95,13 @@ __all__ = [
     "EnvironmentConfig",
     "ConstanceConfig",
     "ConstanceField",
+    "CurrencyConfig",
+    "DjangoRQConfig",
+    "RQQueueConfig",
     "OpenAPIClientConfig",
     "UnfoldConfig",
+    "AxesConfig",
+    "CryptoFieldsConfig",
     # Services
     "EmailConfig",
     "TelegramConfig",
@@ -89,4 +112,9 @@ __all__ = [
     # Payments
     "PaymentsConfig",
     "NowPaymentsConfig",
+    # OAuth
+    "GitHubOAuthConfig",
+    "OAuthConfig",
+    # 2FA
+    "TwoFactorConfig",
 ]

django_cfg/models/api/__init__.py

@@ -13,6 +13,10 @@ from .drf.swagger import SwaggerUISettings
 from .jwt import JWTConfig
 from .keys import ApiKeys
 from .limits import LimitsConfig
+from .oauth import GitHubOAuthConfig, OAuthConfig
+from .rate_limiting import RateLimitConfig, RateLimitRule
+from .twofactor import TwoFactorConfig
+from .webpush import WebPushConfig
 
 __all__ = [
     "APIConfig",
@@ -20,8 +24,14 @@ __all__ = [
     "JWTConfig",
     "CORSConfig",
     "LimitsConfig",
+    "RateLimitConfig",
+    "RateLimitRule",
     "DRFConfig",
     "SpectacularConfig",
     "SwaggerUISettings",
     "RedocUISettings",
+    "GitHubOAuthConfig",
+    "OAuthConfig",
+    "TwoFactorConfig",
+    "WebPushConfig",
 ]

django_cfg/models/api/config.py

@@ -99,9 +99,9 @@ class APIConfig(BaseConfig):
                 'MAX_PAGE_SIZE': self.max_page_size,
 
                 'DEFAULT_AUTHENTICATION_CLASSES': [
-                    'rest_framework.authentication.SessionAuthentication',
-                    'rest_framework.authentication.TokenAuthentication',
                     'rest_framework_simplejwt.authentication.JWTAuthentication',
+                    'rest_framework.authentication.TokenAuthentication',
+                    # SessionAuthentication removed (requires CSRF)
                 ],
 
                 'DEFAULT_PERMISSION_CLASSES': [

django_cfg/models/api/drf/config.py

@@ -17,10 +17,12 @@ class DRFConfig(BaseModel):
     # Authentication
     authentication_classes: List[str] = Field(
         default_factory=lambda: [
+            'django_cfg.middleware.authentication.JWTAuthenticationWithLastLogin',
             'rest_framework.authentication.TokenAuthentication',
-            'rest_framework.authentication.SessionAuthentication',
+            # SessionAuthentication removed from defaults (requires CSRF)
+            # Add it manually in your config if you need Browsable API with session auth
         ],
-        description="Default authentication classes"
+        description="Default authentication classes (JWT with auto last_login update)"
     )
 
     # Permissions

django_cfg/models/api/grpc/__init__.py

@@ -0,0 +1,75 @@
+"""
+gRPC configuration models.
+
+Type-safe Pydantic v2 models for gRPC integration.
+
+Requires: pip install django-cfg[grpc]
+
+Example:
+    Flat API (recommended - no nested config imports needed):
+    >>> from django_cfg import GRPCConfig
+    >>> config = GRPCConfig(
+    ...     enabled=True,
+    ...     enabled_apps=["crypto"],
+    ...     port=50051,
+    ...     package_prefix="api",
+    ... )
+
+    Advanced with nested configs:
+    >>> from django_cfg import GRPCServerConfig, GRPCKeepaliveConfig
+    >>> config = GRPCConfig(
+    ...     enabled=True,
+    ...     server=GRPCServerConfig(
+    ...         keepalive=GRPCKeepaliveConfig.for_streaming(),
+    ...     ),
+    ... )
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .config import (
+        GRPCConfig,
+        GRPCServerConfig,
+        GRPCKeepaliveConfig,
+        GRPCConnectionLimitsConfig,
+        GRPCObservabilityConfig,
+    )
+
+__all__ = [
+    "GRPCConfig",
+    "GRPCServerConfig",
+    "GRPCKeepaliveConfig",
+    "GRPCConnectionLimitsConfig",
+    "GRPCObservabilityConfig",
+]
+
+
+def __getattr__(name: str):
+    """Lazy import with helpful error message."""
+    if name in __all__:
+        try:
+            from .config import (
+                GRPCConfig,
+                GRPCServerConfig,
+                GRPCKeepaliveConfig,
+                GRPCConnectionLimitsConfig,
+                GRPCObservabilityConfig,
+            )
+
+            return {
+                "GRPCConfig": GRPCConfig,
+                "GRPCServerConfig": GRPCServerConfig,
+                "GRPCKeepaliveConfig": GRPCKeepaliveConfig,
+                "GRPCConnectionLimitsConfig": GRPCConnectionLimitsConfig,
+                "GRPCObservabilityConfig": GRPCObservabilityConfig,
+            }[name]
+
+        except ImportError as e:
+            raise ImportError(
+                f"gRPC support requires additional dependencies. "
+                f"Install with: pip install django-cfg[grpc]\n"
+                f"Missing module: {e.name}"
+            ) from e
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")