django-cfg 1.5.14__py3-none-any.whl → 1.5.29__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/models/api/grpc/config.py

@@ -370,9 +370,9 @@ class GRPCConfig(BaseConfig):
         description="Proto generation configuration (optional, use flatten fields above for common settings)",
     )
 
-    handlers_hook: str = Field(
+    handlers_hook: str | List[str] = Field(
         default="",
-        description="Import path to grpc_handlers function (optional, e.g., '{ROOT_URLCONF}.grpc_handlers')",
+        description="Import path(s) to grpc_handlers function (optional, e.g., '{ROOT_URLCONF}.grpc_handlers' or list of paths)",
     )
 
     auto_register_apps: bool = Field(

django_cfg/models/infrastructure/database/config.py

@@ -81,6 +81,18 @@ class DatabaseConfig(BaseModel):
         description="Additional database-specific options",
     )
 
+    # Connection pooling options (CRITICAL for preventing connection exhaustion)
+    conn_max_age: int = Field(
+        default=0,  # 0 disables persistent connections when using connection pooling
+        description="Maximum age of database connections in seconds. Must be 0 when using connection pooling.",
+        ge=0,
+    )
+
+    conn_health_checks: bool = Field(
+        default=True,
+        description="Enable database connection health checks",
+    )
+
     # Database routing configuration
     apps: List[str] = Field(
         default_factory=list,
@@ -223,6 +235,8 @@ class DatabaseConfig(BaseModel):
         apps: Optional[List[str]] = None,
         operations: Optional[List[Literal["read", "write", "migrate"]]] = None,
         routing_description: str = "",
+        conn_max_age: int = 0,  # 0 disables persistent connections when using connection pooling
+        conn_health_checks: bool = True,
         **kwargs
     ) -> "DatabaseConfig":
         """
@@ -254,6 +268,8 @@ class DatabaseConfig(BaseModel):
             apps=apps or [],
             operations=operations or ["read", "write", "migrate"],
             routing_description=routing_description,
+            conn_max_age=conn_max_age,
+            conn_health_checks=conn_health_checks,
             **kwargs
         )
 

django_cfg/models/infrastructure/database/converters.py

@@ -25,6 +25,8 @@ def to_django_config(config: "DatabaseConfig") -> Dict[str, Any]:  # type: ignor
         django_config = {
             "ENGINE": config.engine,
             "OPTIONS": {**config.options},
+            "CONN_MAX_AGE": config.conn_max_age,
+            "CONN_HEALTH_CHECKS": config.conn_health_checks,
         }
 
         # Add database-specific options

django_cfg/modules/django_admin/utils/html/composition.py

@@ -28,7 +28,8 @@ class CompositionElements:
 
     @staticmethod
     def icon_text(icon_or_text: Union[str, Any], text: Any = None,
-                  icon_size: str = "xs", separator: str = " ") -> SafeString:
+                  icon_size: str = "xs", separator: str = " ", 
+                  color: str = None) -> SafeString:
         """
         Render icon with text or emoji with text.
 
@@ -37,28 +38,35 @@ class CompositionElements:
             text: Optional text to display after icon
             icon_size: Icon size (xs, sm, base, lg, xl)
             separator: Separator between icon and text
+            color: Optional color (success, warning, danger, info, secondary, primary)
 
         Usage:
             html.icon_text(Icons.EDIT, 5)  # Icon with number
-            html.icon_text("📝", 5)  # Emoji with number
             html.icon_text("Active")  # Just text
+            html.icon_text(Icons.CHECK, "Yes", color="success")  # Icon with color
         """
+        # Color mapping to Tailwind/Unfold classes
+        color_classes = {
+            'success': 'text-green-600 dark:text-green-400',
+            'warning': 'text-yellow-600 dark:text-yellow-400',
+            'danger': 'text-red-600 dark:text-red-400',
+            'error': 'text-red-600 dark:text-red-400',
+            'info': 'text-blue-600 dark:text-blue-400',
+            'secondary': 'text-gray-600 dark:text-gray-400',
+            'primary': 'text-indigo-600 dark:text-indigo-400',
+        }
+        
+        color_class = color_classes.get(color, '') if color else ''
+        
         if text is None:
             # Just text
+            if color_class:
+                return format_html('<span class="{}">{}</span>', color_class, escape(str(icon_or_text)))
             return format_html('<span>{}</span>', escape(str(icon_or_text)))
 
-        # Check if it's a Material Icon (from Icons class) or emoji
+        # Render icon (Material Icon from Icons class)
         icon_str = str(icon_or_text)
-
-        # Detect if it's emoji by checking for non-ASCII characters
-        is_emoji = any(ord(c) > 127 for c in icon_str)
-
-        if is_emoji or icon_str in ['📝', '💬', '🛒', '👤', '📧', '🔔', '⚙️', '🔧', '📊', '🎯']:
-            # Emoji
-            icon_html = escape(icon_str)
-        else:
-            # Material Icon
-            icon_html = CompositionElements.icon(icon_str, size=icon_size)
+        icon_html = CompositionElements.icon(icon_str, size=icon_size)
 
         # DON'T escape SafeString - it's already safe HTML!
         from django.utils.safestring import SafeString
@@ -67,8 +75,44 @@ class CompositionElements:
         else:
             text_html = escape(str(text))
 
+        # Wrap in span with color class if provided
+        if color_class:
+            return format_html('<span class="{}">{}{}<span>{}</span></span>', 
+                             color_class, icon_html, separator, text_html)
+
         return format_html('{}{}<span>{}</span>', icon_html, separator, text_html)
 
+    @staticmethod
+    def colored_text(text: Any, color: str = None) -> SafeString:
+        """
+        Render colored text.
+
+        Args:
+            text: Text to display
+            color: Color (success, warning, danger, info, secondary, primary)
+
+        Usage:
+            html.colored_text("Active", "success")
+            html.colored_text("5 minutes ago", "warning")
+        """
+        # Color mapping to Tailwind/Unfold classes
+        color_classes = {
+            'success': 'text-green-600 dark:text-green-400',
+            'warning': 'text-yellow-600 dark:text-yellow-400',
+            'danger': 'text-red-600 dark:text-red-400',
+            'error': 'text-red-600 dark:text-red-400',
+            'info': 'text-blue-600 dark:text-blue-400',
+            'secondary': 'text-gray-600 dark:text-gray-400',
+            'primary': 'text-indigo-600 dark:text-indigo-400',
+        }
+        
+        color_class = color_classes.get(color, '') if color else ''
+        
+        if color_class:
+            return format_html('<span class="{}">{}</span>', color_class, escape(str(text)))
+        
+        return format_html('<span>{}</span>', escape(str(text)))
+
     @staticmethod
     def inline(*items, separator: str = " | ",
                size: str = "small", css_class: str = "") -> SafeString:

django_cfg/modules/django_admin/utils/html_builder.py

@@ -45,6 +45,7 @@ class HtmlBuilder:
     # === CompositionElements ===
     inline = staticmethod(CompositionElements.inline)
     icon_text = staticmethod(CompositionElements.icon_text)
+    colored_text = staticmethod(CompositionElements.colored_text)
     header = staticmethod(CompositionElements.header)
 
     # === FormattingElements ===

django_cfg/modules/django_client/core/generator/typescript/generator.py

@@ -298,6 +298,14 @@ class TypeScriptGenerator(BaseGenerator):
                                 queue.append(self.context.schemas[prop.items.ref])
                                 seen.add(prop.items.ref)
 
+                    # $ref inside additionalProperties (CRITICAL for Record<string, T> patterns!)
+                    if prop.additional_properties and prop.additional_properties.ref:
+                        if prop.additional_properties.ref not in seen:
+                            if prop.additional_properties.ref in self.context.schemas:
+                                resolved[prop.additional_properties.ref] = self.context.schemas[prop.additional_properties.ref]
+                                queue.append(self.context.schemas[prop.additional_properties.ref])
+                                seen.add(prop.additional_properties.ref)
+
             # Check array items for $ref at schema level
             if schema.items and schema.items.ref:
                 if schema.items.ref not in seen:
@@ -306,6 +314,14 @@ class TypeScriptGenerator(BaseGenerator):
                         queue.append(self.context.schemas[schema.items.ref])
                         seen.add(schema.items.ref)
 
+            # Check additionalProperties for $ref at schema level
+            if schema.additional_properties and schema.additional_properties.ref:
+                if schema.additional_properties.ref not in seen:
+                    if schema.additional_properties.ref in self.context.schemas:
+                        resolved[schema.additional_properties.ref] = self.context.schemas[schema.additional_properties.ref]
+                        queue.append(self.context.schemas[schema.additional_properties.ref])
+                        seen.add(schema.additional_properties.ref)
+
         return resolved
 
     # ===== Zod Schemas Generation =====
@@ -369,11 +385,21 @@ class TypeScriptGenerator(BaseGenerator):
                         if not self.context.schemas[prop.items.ref].enum:
                             refs.add(prop.items.ref)
 
+                if prop.additional_properties and prop.additional_properties.ref:
+                    if prop.additional_properties.ref in self.context.schemas:
+                        if not self.context.schemas[prop.additional_properties.ref].enum:
+                            refs.add(prop.additional_properties.ref)
+
         if schema.items and schema.items.ref:
             if schema.items.ref in self.context.schemas:
                 if not self.context.schemas[schema.items.ref].enum:
                     refs.add(schema.items.ref)
 
+        if schema.additional_properties and schema.additional_properties.ref:
+            if schema.additional_properties.ref in self.context.schemas:
+                if not self.context.schemas[schema.additional_properties.ref].enum:
+                    refs.add(schema.additional_properties.ref)
+
         return refs
 
     # ===== Fetchers Generation =====

django_cfg/modules/django_client/core/generator/typescript/hooks_generator.py

@@ -363,6 +363,8 @@ class HooksGenerator:
         # Separate queries and mutations & collect schema names
         hooks = []
         schema_names = set()
+        has_queries = False
+        has_mutations = False
 
         for operation in operations:
             # Collect schemas used in this operation (only if they exist as components)
@@ -378,11 +380,13 @@ class HooksGenerator:
             if response and response.schema_name:
                 schema_names.add(response.schema_name)
 
-            # Generate hook
+            # Generate hook and track operation types
             if operation.http_method == "GET":
                 hooks.append(self.generate_query_hook(operation))
+                has_queries = True
             else:
                 hooks.append(self.generate_mutation_hook(operation))
+                has_mutations = True
 
         # Get display name for documentation
         tag_display_name = self.base.tag_to_display_name(tag)
@@ -398,6 +402,8 @@ class HooksGenerator:
             tag_file=tag_file,
             has_schemas=bool(schema_names),
             schema_names=sorted(schema_names),
+            has_queries=has_queries,
+            has_mutations=has_mutations,
             hooks=hooks
         )
 

django_cfg/modules/django_client/core/generator/typescript/models_generator.py

@@ -175,8 +175,13 @@ class ModelsGenerator:
         # Handle nullable and optional separately
         # - nullable: add | null to type
         # - not required: add ? optional marker
+        # Special case: readOnly + nullable fields should be optional
+        # (they're always in response but can be null, so from client perspective they're optional)
         if schema.nullable:
             ts_type = f"{ts_type} | null"
+            # Make readOnly nullable fields optional
+            if schema.read_only:
+                is_required = False
 
         optional_marker = "" if is_required else "?"
 

django_cfg/modules/django_client/core/generator/typescript/schemas_generator.py

@@ -237,6 +237,17 @@ class SchemasGenerator:
             if schema.ref:
                 # Explicit reference
                 return f"{schema.ref}Schema"
+            elif schema.additional_properties:
+                # Object with additionalProperties (e.g., Record<string, DatabaseConfig>)
+                if schema.additional_properties.ref:
+                    value_type = f"{schema.additional_properties.ref}Schema"
+                else:
+                    value_type = self._map_type_to_zod(schema.additional_properties)
+                    # If DictField() produces additionalProperties with just string type,
+                    # use z.any() to allow mixed types (common in Django configs/settings)
+                    if value_type == "z.string()":
+                        value_type = "z.any()"
+                return f"z.record(z.string(), {value_type})"
             elif schema.properties:
                 # Inline object with properties - shouldn't reach here, but use z.object
                 return "z.object({})"

django_cfg/modules/django_client/core/generator/typescript/templates/fetchers/fetchers.ts.jinja

@@ -29,6 +29,7 @@
  * const users = await getUsers({ page: 1 }, api)
  * ```
  */
+import { consola } from 'consola'
 {% if has_schemas %}
 {% for schema_name in schema_names %}
 import { {{ schema_name }}Schema, type {{ schema_name }} } from '../schemas/{{ schema_name }}.schema'

django_cfg/modules/django_client/core/generator/typescript/templates/fetchers/function.ts.jinja

@@ -17,7 +17,35 @@ export async function {{ func_name }}(
   const response = await {{ api_call }}()
 {% endif %}
 {% if response_schema %}
-  return {{ response_schema }}.parse(response)
+  try {
+    return {{ response_schema }}.parse(response)
+  } catch (error) {
+    // Zod validation error - log detailed information
+    consola.error('❌ Zod Validation Failed');
+    consola.box({
+      title: '{{ func_name }}',
+      message: `Path: {{ operation.path }}\nMethod: {{ operation.http_method }}`,
+      style: {
+        borderColor: 'red',
+        borderStyle: 'rounded'
+      }
+    });
+
+    if (error instanceof Error && 'issues' in error && Array.isArray((error as any).issues)) {
+      consola.error('Validation Issues:');
+      (error as any).issues.forEach((issue: any, index: number) => {
+        consola.error(`  ${index + 1}. ${issue.path.join('.') || 'root'}`);
+        consola.error(`     ├─ Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     ├─ Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     └─ Received: ${issue.received}`);
+      });
+    }
+
+    consola.error('Response data:', response);
+
+    // Re-throw the error
+    throw error;
+  }
 {% else %}
   return response
 {% endif %}

django_cfg/modules/django_client/core/generator/typescript/templates/hooks/hooks.ts.jinja

@@ -14,8 +14,12 @@
  * await createUser({ name: 'John', email: 'john@example.com' })
  * ```
  */
+{% if has_queries %}
 import useSWR from 'swr'
+{% endif %}
+{% if has_mutations %}
 import { useSWRConfig } from 'swr'
+{% endif %}
 import * as Fetchers from '../fetchers/{{ tag_file }}'
 import type { API } from '../../index'
 {% if has_schemas %}

django_cfg/modules/django_client/core/groups/manager.py

@@ -230,25 +230,32 @@ from django_cfg.apps.urls import urlpatterns
             for app_name in apps:
                 # Try to include app URLs
                 try:
-                    # Find app config by full name
-                    app_config = None
-                    for config in django_apps.get_app_configs():
-                        if config.name == app_name:
-                            app_config = config
-                            break
-
-                    if app_config:
-                        # Use actual label from AppConfig
-                        app_label = app_config.label
-                        # Add API prefix from config (e.g., "api/workspaces/" instead of just "workspaces/")
-                        api_prefix = getattr(self.config, 'api_prefix', '').strip('/')
-                        if api_prefix:
-                            url_path = f"{api_prefix}/{app_label}/"
-                        else:
-                            url_path = f"{app_label}/"
-                        urlpatterns.append(f'    path("{url_path}", include("{app_name}.urls")),')
+                    # Check if app has urls.py module
+                    import importlib
+                    urls_module = f"{app_name}.urls"
+                    try:
+                        importlib.import_module(urls_module)
+                        has_urls = True
+                    except ImportError:
+                        has_urls = False
+                    
+                    if not has_urls:
+                        logger.debug(f"App '{app_name}' has no urls.py - skipping")
+                        continue
+                    
+                    # Determine URL path based on whether app has urls.py
+                    # If app has urls.py, use basename (matches url_integration.py logic)
+                    # e.g., "apps.web.controls" -> "controls"
+                    app_basename = app_name.split('.')[-1]
+                    
+                    # Add API prefix from config (e.g., "api/controls/" instead of just "controls/")
+                    api_prefix = getattr(self.config, 'api_prefix', '').strip('/')
+                    if api_prefix:
+                        url_path = f"{api_prefix}/{app_basename}/"
                     else:
-                        logger.debug(f"App '{app_name}' not found in installed apps")
+                        url_path = f"{app_basename}/"
+                    
+                    urlpatterns.append(f'    path("{url_path}", include("{app_name}.urls")),')
                 except Exception as e:
                     logger.debug(f"App '{app_name}' skipped: {e}")
                     continue