django-cfg 1.5.14__py3-none-any.whl → 1.5.29__py3-none-any.whl

django_cfg/apps/system/dashboard/serializers/config.py

@@ -5,6 +5,8 @@ Serializers for displaying user's DjangoConfig settings.
 """
 
 from rest_framework import serializers
+from drf_spectacular.utils import extend_schema_field
+from drf_spectacular.types import OpenApiTypes
 
 
 # Nested serializers for complex structures
@@ -89,6 +91,18 @@ class RedisQueueConfigSerializer(serializers.Serializer):
     socket_timeout = serializers.IntegerField(required=False, allow_null=True)
 
 
+class RQScheduleSerializer(serializers.Serializer):
+    """Redis Queue schedule configuration."""
+    func = serializers.CharField(required=False, allow_null=True)
+    cron_string = serializers.CharField(required=False, allow_null=True)
+    queue = serializers.CharField(required=False, allow_null=True)
+    kwargs = serializers.DictField(required=False, allow_null=True)
+    args = serializers.ListField(required=False, allow_null=True)
+    meta = serializers.DictField(required=False, allow_null=True)
+    repeat = serializers.IntegerField(required=False, allow_null=True)
+    result_ttl = serializers.IntegerField(required=False, allow_null=True)
+
+
 class DjangoRQConfigSerializer(serializers.Serializer):
     """Django-RQ configuration."""
     enabled = serializers.BooleanField(required=False, allow_null=True)
@@ -97,7 +111,7 @@ class DjangoRQConfigSerializer(serializers.Serializer):
     exception_handlers = serializers.ListField(required=False, allow_null=True)
     api_token = serializers.CharField(required=False, allow_null=True)
     prometheus_enabled = serializers.BooleanField(required=False, allow_null=True)
-    schedules = serializers.ListField(child=serializers.DictField(), required=False, allow_null=True)
+    schedules = serializers.ListField(child=RQScheduleSerializer(), required=False, allow_null=True)
 
 
 class DRFConfigSerializer(serializers.Serializer):
@@ -126,6 +140,78 @@ class ConfigMetaSerializer(serializers.Serializer):
     secret_key_configured = serializers.BooleanField()
 
 
+class TelegramConfigSerializer(serializers.Serializer):
+    """Telegram service configuration."""
+    bot_token = serializers.CharField(required=False, allow_null=True)
+    chat_id = serializers.IntegerField(required=False, allow_null=True)
+    parse_mode = serializers.CharField(required=False, allow_null=True)
+    disable_notification = serializers.BooleanField(required=False, allow_null=True)
+    disable_web_page_preview = serializers.BooleanField(required=False, allow_null=True)
+    timeout = serializers.IntegerField(required=False, allow_null=True)
+    webhook_url = serializers.CharField(required=False, allow_null=True)
+    webhook_secret = serializers.CharField(required=False, allow_null=True)
+    max_retries = serializers.IntegerField(required=False, allow_null=True)
+    retry_delay = serializers.FloatField(required=False, allow_null=True)
+
+
+class NgrokConfigSerializer(serializers.Serializer):
+    """Ngrok tunneling configuration."""
+    enabled = serializers.BooleanField(required=False, allow_null=True)
+    authtoken = serializers.CharField(required=False, allow_null=True)
+    basic_auth = serializers.ListField(required=False, allow_null=True)
+    compression = serializers.BooleanField(required=False, allow_null=True)
+
+
+class AxesConfigSerializer(serializers.Serializer):
+    """Django-Axes brute-force protection configuration."""
+    enabled = serializers.BooleanField(required=False, allow_null=True)
+    failure_limit = serializers.IntegerField(required=False, allow_null=True)
+    cooloff_time = serializers.IntegerField(required=False, allow_null=True)
+    lock_out_at_failure = serializers.BooleanField(required=False, allow_null=True)
+    reset_on_success = serializers.BooleanField(required=False, allow_null=True)
+    only_user_failures = serializers.BooleanField(required=False, allow_null=True)
+    lockout_template = serializers.CharField(required=False, allow_null=True)
+    lockout_url = serializers.CharField(required=False, allow_null=True)
+    verbose = serializers.BooleanField(required=False, allow_null=True)
+    enable_access_failure_log = serializers.BooleanField(required=False, allow_null=True)
+    ipware_proxy_count = serializers.IntegerField(required=False, allow_null=True)
+    ipware_meta_precedence_order = serializers.ListField(required=False, allow_null=True)
+    allowed_ips = serializers.ListField(required=False, allow_null=True)
+    denied_ips = serializers.ListField(required=False, allow_null=True)
+    cache_name = serializers.CharField(required=False, allow_null=True)
+    use_user_agent = serializers.BooleanField(required=False, allow_null=True)
+    username_form_field = serializers.CharField(required=False, allow_null=True)
+
+
+class NextJSAdminConfigSerializer(serializers.Serializer):
+    """Next.js Admin application configuration."""
+    enabled = serializers.BooleanField(required=False, allow_null=True)
+    url = serializers.CharField(required=False, allow_null=True)
+    api_base_url = serializers.CharField(required=False, allow_null=True)
+
+
+class ConstanceConfigSerializer(serializers.Serializer):
+    """Django-Constance dynamic settings configuration."""
+    config = serializers.DictField(required=False, allow_null=True)
+    config_fieldsets = serializers.DictField(required=False, allow_null=True)
+    backend = serializers.CharField(required=False, allow_null=True)
+    database_prefix = serializers.CharField(required=False, allow_null=True)
+    database_cache_backend = serializers.CharField(required=False, allow_null=True)
+    additional_config = serializers.DictField(required=False, allow_null=True)
+
+
+class OpenAPIClientConfigSerializer(serializers.Serializer):
+    """OpenAPI Client generation configuration."""
+    enabled = serializers.BooleanField(required=False, allow_null=True)
+    output_dir = serializers.CharField(required=False, allow_null=True)
+    client_name = serializers.CharField(required=False, allow_null=True)
+    schema_url = serializers.CharField(required=False, allow_null=True)
+    generator = serializers.CharField(required=False, allow_null=True)
+    additional_properties = serializers.DictField(required=False, allow_null=True)
+    templates = serializers.ListField(required=False, allow_null=True)
+    global_properties = serializers.DictField(required=False, allow_null=True)
+
+
 class DjangoConfigSerializer(serializers.Serializer):
     """
     Typed serializer for user's DjangoConfig settings.
@@ -188,10 +274,10 @@ class DjangoConfigSerializer(serializers.Serializer):
     spectacular = SpectacularConfigSerializer(required=False, allow_null=True)
     jwt = JWTConfigSerializer(required=False, allow_null=True)
 
-    # Other configs (pass-through for flexibility)
-    telegram = serializers.DictField(required=False, allow_null=True)
-    ngrok = serializers.DictField(required=False, allow_null=True)
-    axes = serializers.DictField(required=False, allow_null=True)
+    # Services & Security (now typed!)
+    telegram = TelegramConfigSerializer(required=False, allow_null=True)
+    ngrok = NgrokConfigSerializer(required=False, allow_null=True)
+    axes = AxesConfigSerializer(required=False, allow_null=True)
     crypto_fields = serializers.DictField(required=False, allow_null=True)
     unfold = serializers.CharField(required=False, allow_null=True)  # String representation of Unfold config
     tailwind_app_name = serializers.CharField(required=False, allow_null=True)
@@ -199,10 +285,10 @@ class DjangoConfigSerializer(serializers.Serializer):
     limits = serializers.DictField(required=False, allow_null=True)
     api_keys = serializers.DictField(required=False, allow_null=True)
     custom_middleware = serializers.ListField(required=False, allow_null=True)
-    nextjs_admin = serializers.DictField(required=False, allow_null=True)
+    nextjs_admin = NextJSAdminConfigSerializer(required=False, allow_null=True)
     admin_emails = serializers.ListField(required=False, allow_null=True)
-    constance = serializers.DictField(required=False, allow_null=True)
-    openapi_client = serializers.DictField(required=False, allow_null=True)
+    constance = ConstanceConfigSerializer(required=False, allow_null=True)
+    openapi_client = OpenAPIClientConfigSerializer(required=False, allow_null=True)
 
     # Metadata
     _meta = ConfigMetaSerializer(required=False, allow_null=True)
@@ -238,7 +324,7 @@ class ConfigDataSerializer(serializers.Serializer):
         help_text="User's DjangoConfig settings"
     )
     django_settings = serializers.DictField(
-        help_text="Complete Django settings (sanitized)"
+        help_text="Complete Django settings (sanitized, contains mixed types)"
     )
     _validation = ConfigValidationSerializer(
         help_text="Validation result comparing serializer with actual config"

django_cfg/apps/system/dashboard/serializers/statistics.py

@@ -36,11 +36,16 @@ class UserStatisticsSerializer(serializers.Serializer):
     superusers = serializers.IntegerField(help_text="Number of superusers")
 
 
+class AppStatisticsDataSerializer(serializers.Serializer):
+    """Serializer for application statistics data."""
+
+    name = serializers.CharField(help_text="Human-readable app name")
+    total_records = serializers.IntegerField(help_text="Total records count")
+    model_count = serializers.IntegerField(help_text="Number of models")
+
+
 class AppStatisticsSerializer(serializers.Serializer):
     """Serializer for application-specific statistics."""
 
     app_name = serializers.CharField(help_text="Application name")
-    statistics = serializers.DictField(
-        child=serializers.IntegerField(),
-        help_text="Application statistics"
-    )
+    statistics = AppStatisticsDataSerializer(help_text="Application statistics")

django_cfg/apps/system/frontend/views.py

@@ -130,17 +130,23 @@ class ZipExtractionMixin:
 @method_decorator(xframe_options_exempt, name='dispatch')
 class NextJSStaticView(ZipExtractionMixin, View):
     """
-    Serve Next.js static build files with automatic JWT token injection.
+    Serve Next.js static build files with automatic JWT token injection and precompression support.
 
     Features:
     - Serves Next.js static export files like a static file server
     - Smart ZIP extraction: compares ZIP metadata (size + mtime) with marker file
-    - Automatically injects JWT tokens for authenticated users
-    - Tokens injected into HTML responses only
+    - Automatically injects JWT tokens for authenticated users (HTML only)
+    - **Precompression support**: Automatically serves .br or .gz files if available
     - Handles Next.js client-side routing (.html fallback)
     - Automatically serves index.html for directory paths
     - X-Frame-Options exempt to allow embedding in iframes
 
+    Compression Strategy:
+    - Brotli (.br) preferred over Gzip (.gz) - ~5-15% better compression
+    - Automatically detects browser support via Accept-Encoding header
+    - Skips compression for HTML files (JWT injection requires uncompressed content)
+    - Only serves precompressed files, no runtime compression
+
     ZIP Extraction Logic:
     - If directory doesn't exist: extract from ZIP
     - If marker file missing: extract from ZIP
@@ -154,12 +160,18 @@ class NextJSStaticView(ZipExtractionMixin, View):
     - /cfg/admin/private/      → /cfg/admin/private.html (fallback)
     - /cfg/admin/tasks         → /cfg/admin/tasks.html
     - /cfg/admin/tasks         → /cfg/admin/tasks/index.html (fallback)
+
+    Compression examples:
+    - _app.js (br supported)   → _app.js.br + Content-Encoding: br
+    - _app.js (gzip supported) → _app.js.gz + Content-Encoding: gzip
+    - _app.js (no support)     → _app.js (uncompressed)
+    - index.html               → index.html (never compressed, needs JWT injection)
     """
 
     app_name = 'admin'
 
     def get(self, request, path=''):
-        """Serve static files from Next.js build with JWT injection."""
+        """Serve static files from Next.js build with JWT injection and compression support."""
         import django_cfg
 
         base_dir = Path(django_cfg.__file__).parent / 'static' / 'frontend' / self.app_name
@@ -191,8 +203,18 @@ class NextJSStaticView(ZipExtractionMixin, View):
             request.META.pop('HTTP_IF_MODIFIED_SINCE', None)
             request.META.pop('HTTP_IF_NONE_MATCH', None)
 
-        # Serve the static file
-        response = serve(request, path, document_root=str(base_dir))
+        # Try to serve precompressed file if browser supports it
+        compressed_path, encoding = self._find_precompressed_file(base_dir, path, request)
+        if compressed_path:
+            logger.debug(f"[Compression] Serving {encoding} for {path}")
+            response = serve(request, compressed_path, document_root=str(base_dir))
+            response['Content-Encoding'] = encoding
+            # Remove Content-Length as it's incorrect for compressed content
+            if 'Content-Length' in response:
+                del response['Content-Length']
+        else:
+            # Serve the static file normally
+            response = serve(request, path, document_root=str(base_dir))
 
         # Convert FileResponse to HttpResponse for HTML files to enable JWT injection
         if isinstance(response, FileResponse):
@@ -222,6 +244,65 @@ class NextJSStaticView(ZipExtractionMixin, View):
 
         return response
 
+    def _find_precompressed_file(self, base_dir, path, request):
+        """
+        Find and return precompressed file (.br or .gz) if available and supported by browser.
+
+        Brotli (.br) is preferred over Gzip (.gz) as it provides better compression.
+
+        Args:
+            base_dir: Base directory for static files
+            path: Requested file path
+            request: Django request object
+
+        Returns:
+            tuple: (compressed_path, encoding) if precompressed file found and supported,
+                   (None, None) otherwise
+
+        Examples:
+            _app.js → _app.js.br (if Accept-Encoding: br)
+            _app.js → _app.js.gz (if Accept-Encoding: gzip, no .br)
+            _app.js → (None, None) (if no precompressed files or not supported)
+        """
+        # Get Accept-Encoding header
+        accept_encoding = request.META.get('HTTP_ACCEPT_ENCODING', '').lower()
+
+        # Check if browser supports brotli (preferred) or gzip
+        supports_br = 'br' in accept_encoding
+        supports_gzip = 'gzip' in accept_encoding
+
+        if not (supports_br or supports_gzip):
+            return None, None
+
+        # Don't compress HTML files - we need to inject JWT tokens
+        # JWT injection requires modifying content, which is incompatible with compression
+        if path.endswith('.html'):
+            return None, None
+
+        # Build full file path
+        file_path = base_dir / path
+
+        # Check if original file exists (safety check)
+        if not file_path.exists() or not file_path.is_file():
+            return None, None
+
+        # Try Brotli first (better compression, ~5-15% smaller than gzip)
+        if supports_br:
+            br_path = f"{path}.br"
+            br_file = base_dir / br_path
+            if br_file.exists() and br_file.is_file():
+                return br_path, 'br'
+
+        # Fallback to Gzip
+        if supports_gzip:
+            gz_path = f"{path}.gz"
+            gz_file = base_dir / gz_path
+            if gz_file.exists() and gz_file.is_file():
+                return gz_path, 'gzip'
+
+        # No precompressed file found or not supported
+        return None, None
+
     def _resolve_spa_path(self, base_dir, path):
         """
         Resolve SPA path with multiple fallback strategies.

django_cfg/core/base/config_model.py

@@ -221,6 +221,17 @@ class DjangoConfig(BaseModel):
         description="Database connections",
     )
 
+    enable_pool_cleanup: bool = Field(
+        default=False,
+        description=(
+            "Enable explicit connection pool cleanup middleware. "
+            "Django already closes connections automatically, but this middleware "
+            "adds explicit guarantees and rollback on errors. "
+            "Enable only if you experience connection leaks. "
+            "Note: Not needed with ATOMIC_REQUESTS=True (default)."
+        ),
+    )
+
     # === Cache Configuration ===
     # Redis URL - used for automatic cache configuration if cache_default is not set
     redis_url: Optional[str] = Field(

django_cfg/core/builders/middleware_builder.py

@@ -66,6 +66,11 @@ class MiddlewareBuilder:
         # Add custom user middleware
         middleware.extend(self.config.custom_middleware)
 
+        # Add connection pool cleanup middleware LAST (if enabled)
+        # This ensures connections are returned to pool after ALL other middleware
+        if self.config.enable_pool_cleanup:
+            middleware.append('django_cfg.middleware.pool_cleanup.ConnectionPoolCleanupMiddleware')
+
         return middleware
 
     def _get_feature_middleware(self) -> List[str]:

django_cfg/core/builders/security_builder.py

@@ -323,6 +323,7 @@ class SecurityBuilder:
         """
         popular_ports = [
             3000,  # React/Next.js default
+            3777,  # Next.js Admin default
             5173,  # Vite default
             5174,  # Vite preview
             8080,  # Vue/Spring Boot

django_cfg/core/generation/integration_generators/api.py

@@ -125,6 +125,8 @@ class APIFrameworksGenerator:
                 ],
                 # Add authentication classes from smart defaults
                 "DEFAULT_AUTHENTICATION_CLASSES": drf_defaults["DEFAULT_AUTHENTICATION_CLASSES"],
+                # Force ISO 8601 datetime format with Z suffix for all datetime fields
+                "DATETIME_FORMAT": "%Y-%m-%dT%H:%M:%SZ",
             }
 
             # Note: We don't set DEFAULT_PERMISSION_CLASSES here to allow public endpoints

django_cfg/management/commands/pool_status.py

@@ -0,0 +1,153 @@
+"""
+Django management command to display connection pool status.
+
+Usage:
+    python manage.py pool_status
+    python manage.py pool_status --database=secondary
+    python manage.py pool_status --json
+"""
+
+import json
+
+from django.core.management.base import BaseCommand
+
+from django_cfg.utils.pool_monitor import PoolMonitor
+
+
+class Command(BaseCommand):
+    """Display database connection pool status."""
+
+    help = 'Display database connection pool status and health information'
+
+    def add_arguments(self, parser):
+        """Add command arguments."""
+        parser.add_argument(
+            '--database',
+            default='default',
+            help='Database alias to check (default: default)',
+        )
+        parser.add_argument(
+            '--json',
+            action='store_true',
+            help='Output in JSON format',
+        )
+
+    def handle(self, *args, **options):
+        """Execute command."""
+        database_alias = options['database']
+        json_output = options['json']
+
+        monitor = PoolMonitor(database_alias=database_alias)
+
+        if json_output:
+            self._handle_json_output(monitor)
+        else:
+            self._handle_pretty_output(monitor)
+
+    def _handle_json_output(self, monitor: PoolMonitor):
+        """Output pool status as JSON."""
+        info = monitor.get_pool_info_dict()
+        self.stdout.write(json.dumps(info, indent=2))
+
+    def _handle_pretty_output(self, monitor: PoolMonitor):
+        """Output pool status in pretty formatted text."""
+        stats = monitor.get_pool_stats()
+
+        if not stats:
+            self.stdout.write(self.style.WARNING('\n⚠️  Connection Pooling: Not Configured'))
+            self.stdout.write('')
+            self.stdout.write('Database is not using connection pooling.')
+            self.stdout.write('Consider enabling pooling for production environments.')
+            self.stdout.write('')
+            return
+
+        health = monitor.check_pool_health()
+
+        # Header
+        self.stdout.write('')
+        self.stdout.write(self.style.SUCCESS('=' * 70))
+        self.stdout.write(self.style.SUCCESS('         DATABASE CONNECTION POOL STATUS'))
+        self.stdout.write(self.style.SUCCESS('=' * 70))
+        self.stdout.write('')
+
+        # Deployment Information
+        mode = 'ASGI' if stats['is_asgi'] else 'WSGI'
+        mode_icon = '🚀' if stats['is_asgi'] else '🐍'
+
+        self.stdout.write(self.style.HTTP_INFO('Deployment Information:'))
+        self.stdout.write(f"  Mode:            {mode_icon} {mode}")
+        self.stdout.write(f"  Environment:     {stats['environment'].title()}")
+        self.stdout.write(f"  Database:        {monitor.database_alias}")
+        self.stdout.write(f"  Backend:         {stats['backend']}")
+        self.stdout.write('')
+
+        # Pool Configuration
+        self.stdout.write(self.style.HTTP_INFO('Pool Configuration:'))
+        self.stdout.write(f"  Min Size:        {stats['pool_min_size']:3d} connections")
+        self.stdout.write(f"  Max Size:        {stats['pool_max_size']:3d} connections")
+        self.stdout.write(f"  Timeout:         {stats['pool_timeout']:3d} seconds")
+        self.stdout.write(f"  Max Lifetime:    {stats['max_lifetime']:4d} seconds ({stats['max_lifetime'] // 60} min)")
+        self.stdout.write(f"  Max Idle:        {stats['max_idle']:4d} seconds ({stats['max_idle'] // 60} min)")
+        self.stdout.write('')
+
+        # Current Status (if available)
+        if stats['pool_size'] is not None:
+            self.stdout.write(self.style.HTTP_INFO('Current Status:'))
+            self.stdout.write(f"  Current Size:    {stats['pool_size']:3d} connections")
+            if stats['pool_available'] is not None:
+                self.stdout.write(f"  Available:       {stats['pool_available']:3d} connections")
+            self.stdout.write(f"  Capacity:        {health['capacity_percent']:.1f}% used")
+            self.stdout.write('')
+        else:
+            self.stdout.write(self.style.WARNING('Current Status:     Not available (pool not active yet)'))
+            self.stdout.write('')
+
+        # Health Check
+        status_styles = {
+            'healthy': self.style.SUCCESS,
+            'warning': self.style.WARNING,
+            'critical': self.style.ERROR,
+            'unavailable': self.style.NOTICE,
+        }
+        status_icons = {
+            'healthy': '✅',
+            'warning': '⚠️',
+            'critical': '🔴',
+            'unavailable': '⚪',
+        }
+
+        status_style = status_styles.get(health['status'], self.style.NOTICE)
+        status_icon = status_icons.get(health['status'], '❓')
+        status_text = health['status'].upper()
+
+        self.stdout.write(self.style.HTTP_INFO('Health Check:'))
+        self.stdout.write(f"  Status:          {status_icon} " + status_style(status_text))
+
+        if health['issues']:
+            self.stdout.write('')
+            self.stdout.write(self.style.WARNING('  Issues Detected:'))
+            for issue in health['issues']:
+                self.stdout.write(self.style.WARNING(f"    • {issue}"))
+
+        if health['recommendations']:
+            self.stdout.write('')
+            self.stdout.write(self.style.NOTICE('  Recommendations:'))
+            for rec in health['recommendations']:
+                self.stdout.write(f"    • {rec}")
+
+        # Footer
+        self.stdout.write('')
+        self.stdout.write(self.style.SUCCESS('=' * 70))
+        self.stdout.write('')
+
+        # Overall summary
+        if health['healthy']:
+            self.stdout.write(self.style.SUCCESS('✅ Pool is healthy and operating normally'))
+        elif health['status'] == 'warning':
+            self.stdout.write(self.style.WARNING('⚠️  Pool is functional but requires attention'))
+        elif health['status'] == 'critical':
+            self.stdout.write(self.style.ERROR('🔴 Pool is in critical state - immediate action required'))
+        else:
+            self.stdout.write(self.style.NOTICE('ℹ️  Pool status check completed'))
+
+        self.stdout.write('')