django-cfg 1.3.13__py3-none-any.whl → 1.4.3__py3-none-any.whl

django_cfg/core/builders/apps_builder.py

@@ -0,0 +1,258 @@
+"""
+INSTALLED_APPS builder for Django-CFG.
+
+Single Responsibility: Build Django INSTALLED_APPS list from configuration.
+Extracted from original config.py (903 lines) for better maintainability.
+
+Size: ~220 lines (focused on one task)
+"""
+
+from typing import List, TYPE_CHECKING
+
+from ..constants import DEFAULT_APPS
+
+if TYPE_CHECKING:
+    from ..base.config_model import DjangoConfig
+
+
+class InstalledAppsBuilder:
+    """
+    Builds INSTALLED_APPS list from DjangoConfig.
+
+    Responsibilities:
+    - Combine default Django/third-party apps
+    - Add django-cfg apps based on enabled features
+    - Handle special ordering (accounts before admin)
+    - Auto-enable tasks if needed
+    - Auto-detect dashboard apps from Unfold
+    - Add project-specific apps
+    - Remove duplicates while preserving order
+
+    Example:
+        ```python
+        builder = InstalledAppsBuilder(config)
+        apps = builder.build()
+        ```
+    """
+
+    def __init__(self, config: "DjangoConfig"):
+        """
+        Initialize builder with configuration.
+
+        Args:
+            config: DjangoConfig instance
+        """
+        self.config = config
+
+    def build(self) -> List[str]:
+        """
+        Build complete INSTALLED_APPS list.
+
+        Returns:
+            List of Django app labels in correct order
+
+        Example:
+            >>> config = DjangoConfig(enable_support=True)
+            >>> builder = InstalledAppsBuilder(config)
+            >>> apps = builder.build()
+            >>> "django_cfg.apps.support" in apps
+            True
+        """
+        apps = []
+
+        # Step 1: Add default apps (with special handling for accounts)
+        apps.extend(self._get_default_apps())
+
+        # Step 2: Add django-cfg built-in apps
+        apps.extend(self._get_django_cfg_apps())
+
+        # Step 3: Add optional apps (tasks, dashboard)
+        apps.extend(self._get_optional_apps())
+
+        # Step 4: Add project-specific apps
+        apps.extend(self.config.project_apps)
+
+        # Step 5: Remove duplicates while preserving order
+        return self._deduplicate(apps)
+
+    def _get_default_apps(self) -> List[str]:
+        """
+        Get base Django and third-party apps.
+
+        Handles special case: accounts app must be inserted before admin
+        for proper migration order.
+
+        Returns:
+            List of default app labels
+        """
+        apps = []
+
+        # Add apps one by one, inserting accounts before admin if enabled
+        for app in DEFAULT_APPS:
+            if app == "django.contrib.admin":
+                # Insert accounts before admin if enabled (for proper migration order)
+                if self.config.enable_accounts:
+                    apps.append("django_cfg.apps.accounts")
+            apps.append(app)
+
+        return apps
+
+    def _get_django_cfg_apps(self) -> List[str]:
+        """
+        Get django-cfg built-in apps based on enabled features.
+
+        Returns:
+            List of django-cfg app labels
+        """
+        apps = [
+            # Core apps (always enabled)
+            "django_cfg.modules.django_tailwind",  # Universal Tailwind layouts
+            "django_cfg.apps.api.health",
+            "django_cfg.apps.api.commands",
+        ]
+
+        # Add optional apps based on configuration
+        if self.config.enable_support:
+            apps.append("django_cfg.apps.support")
+
+        if self.config.enable_newsletter:
+            apps.append("django_cfg.apps.newsletter")
+
+        if self.config.enable_leads:
+            apps.append("django_cfg.apps.leads")
+
+        if self.config.enable_knowbase:
+            apps.append("django_cfg.apps.knowbase")
+
+        if self.config.enable_agents:
+            apps.append("django_cfg.apps.agents")
+
+        if self.config.enable_maintenance:
+            apps.append("django_cfg.apps.maintenance")
+
+        if self.config.payments and self.config.payments.enabled:
+            apps.append("django_cfg.apps.payments")
+
+        if self.config.django_ipc and self.config.django_ipc.enabled:
+            apps.append("django_cfg.modules.django_ipc_client.dashboard")
+
+        return apps
+
+    def _get_optional_apps(self) -> List[str]:
+        """
+        Get optional apps like background tasks, dashboard apps, and frontend integrations.
+
+        Returns:
+            List of optional app labels
+        """
+        apps = []
+
+        # Auto-enable tasks if needed by other features
+        if self.config.should_enable_tasks():
+            apps.append("django_dramatiq")  # Add django_dramatiq first
+            apps.append("django_cfg.apps.tasks")
+
+        # Add DRF Tailwind theme module (uses Tailwind via CDN)
+        if self.config.enable_drf_tailwind:
+            apps.append("django_cfg.modules.django_drf_theme.apps.DjangoDRFThemeConfig")
+
+        # Add Tailwind CSS apps (optional, only if theme app exists)
+        # Note: DRF Tailwind theme doesn't require these
+        try:
+            import importlib
+            importlib.import_module(self.config.tailwind_app_name)
+            apps.append("tailwind")
+            apps.append(self.config.tailwind_app_name)
+        except (ImportError, ModuleNotFoundError):
+            # Tailwind app not installed, skip it
+            pass
+
+        # Add browser reload in development (if installed)
+        if self.config.debug:
+            try:
+                import django_browser_reload
+                apps.append("django_browser_reload")
+            except ImportError:
+                # django-browser-reload not installed, skip it
+                pass
+
+        # Auto-detect dashboard apps from Unfold callback
+        dashboard_apps = self._get_dashboard_apps_from_callback()
+        apps.extend(dashboard_apps)
+
+        return apps
+
+    def _get_dashboard_apps_from_callback(self) -> List[str]:
+        """
+        Auto-detect dashboard apps from Unfold dashboard_callback setting.
+
+        Extracts app names from callback paths like:
+        - "api.dashboard.callbacks.main_dashboard_callback" → ["api.dashboard"]
+        - "myproject.admin.callbacks.dashboard" → ["myproject.admin"]
+
+        This allows django-cfg to automatically add dashboard apps to INSTALLED_APPS
+        without requiring manual configuration.
+
+        Returns:
+            List of dashboard app names to add to INSTALLED_APPS
+        """
+        dashboard_apps = []
+
+        # Check if Unfold is configured with a theme
+        if not self.config.unfold or not self.config.unfold.theme:
+            return dashboard_apps
+
+        # Get dashboard callback path from theme
+        callback_path = getattr(self.config.unfold.theme, "dashboard_callback", None)
+        if not callback_path:
+            return dashboard_apps
+
+        try:
+            # Parse callback path: "api.dashboard.callbacks.main_dashboard_callback"
+            # Extract app part: "api.dashboard"
+            parts = callback_path.split(".")
+
+            # Look for common callback patterns
+            callback_indicators = ["callbacks", "views", "handlers"]
+
+            # Find the callback indicator and extract app path before it
+            app_parts = []
+            for i, part in enumerate(parts):
+                if part in callback_indicators:
+                    app_parts = parts[:i]  # Everything before the callback indicator
+                    break
+
+            # If no callback indicator found, assume last part is function name
+            if not app_parts and len(parts) > 1:
+                app_parts = parts[:-1]  # Everything except the last part
+
+            if app_parts:
+                app_name = ".".join(app_parts)
+                dashboard_apps.append(app_name)
+
+        except Exception:
+            # If parsing fails, silently continue - dashboard callback is optional
+            pass
+
+        return dashboard_apps
+
+    def _deduplicate(self, apps: List[str]) -> List[str]:
+        """
+        Remove duplicate apps while preserving order.
+
+        Args:
+            apps: List of app labels (may contain duplicates)
+
+        Returns:
+            Deduplicated list of app labels
+
+        Example:
+            >>> builder._deduplicate(["app1", "app2", "app1", "app3"])
+            ["app1", "app2", "app3"]
+        """
+        seen = set()
+        return [app for app in apps if not (app in seen or seen.add(app))]
+
+
+# Export builder
+__all__ = ["InstalledAppsBuilder"]

django_cfg/core/builders/middleware_builder.py

@@ -0,0 +1,115 @@
+"""
+MIDDLEWARE builder for Django-CFG.
+
+Single Responsibility: Build Django MIDDLEWARE list from configuration.
+Extracted from original config.py for better maintainability.
+
+Size: ~120 lines (focused on middleware logic)
+"""
+
+from typing import List, TYPE_CHECKING
+
+from ..constants import DEFAULT_MIDDLEWARE
+
+if TYPE_CHECKING:
+    from ..base.config_model import DjangoConfig
+
+
+class MiddlewareBuilder:
+    """
+    Builds MIDDLEWARE list from DjangoConfig.
+
+    Responsibilities:
+    - Add default Django middleware
+    - Insert CORS middleware if security domains configured
+    - Add feature-specific middleware (accounts, payments)
+    - Add custom user middleware
+    - Maintain correct middleware ordering
+
+    Example:
+        ```python
+        builder = MiddlewareBuilder(config)
+        middleware = builder.build()
+        ```
+    """
+
+    def __init__(self, config: "DjangoConfig"):
+        """
+        Initialize builder with configuration.
+
+        Args:
+            config: DjangoConfig instance
+        """
+        self.config = config
+
+    def build(self) -> List[str]:
+        """
+        Build complete MIDDLEWARE list.
+
+        Returns:
+            List of middleware class paths in correct order
+
+        Example:
+            >>> config = DjangoConfig(security_domains=["example.com"])
+            >>> builder = MiddlewareBuilder(config)
+            >>> middleware = builder.build()
+            >>> "corsheaders.middleware.CorsMiddleware" in middleware
+            True
+        """
+        # Start with default middleware
+        middleware = list(DEFAULT_MIDDLEWARE)
+
+        # Add CORS middleware if security domains configured
+        # Insert after WhiteNoise but before Session middleware
+        if self.config.security_domains:
+            # Find WhiteNoise position
+            try:
+                whitenoise_index = middleware.index("whitenoise.middleware.WhiteNoiseMiddleware")
+                # Insert CORS after WhiteNoise
+                middleware.insert(whitenoise_index + 1, "corsheaders.middleware.CorsMiddleware")
+            except ValueError:
+                # If WhiteNoise not found, insert at beginning
+                middleware.insert(0, "corsheaders.middleware.CorsMiddleware")
+
+        # Add django-cfg feature-specific middleware
+        feature_middleware = self._get_feature_middleware()
+        middleware.extend(feature_middleware)
+
+        # Add custom user middleware
+        middleware.extend(self.config.custom_middleware)
+
+        return middleware
+
+    def _get_feature_middleware(self) -> List[str]:
+        """
+        Get middleware for enabled django-cfg features.
+
+        Returns:
+            List of feature-specific middleware class paths
+        """
+        middleware = []
+
+        # Accounts middleware (user activity tracking)
+        if self.config.enable_accounts:
+            middleware.append("django_cfg.middleware.UserActivityMiddleware")
+
+        # Payments middleware (if enabled and configured)
+        if self.config.payments and self.config.payments.enabled:
+            payment_middleware = self.config.payments.get_middleware_classes()
+            middleware.extend(payment_middleware)
+
+        # Tailwind CSS middleware (browser reload in development)
+        # Note: Must be after middleware that encodes responses (like GZipMiddleware)
+        if self.config.debug:
+            try:
+                import django_browser_reload
+                middleware.append("django_browser_reload.middleware.BrowserReloadMiddleware")
+            except ImportError:
+                # django-browser-reload not installed, skip it
+                pass
+
+        return middleware
+
+
+# Export builder
+__all__ = ["MiddlewareBuilder"]

django_cfg/core/builders/security_builder.py

@@ -0,0 +1,96 @@
+"""
+Security settings builder for Django-CFG.
+
+Single Responsibility: Build security-related Django settings (ALLOWED_HOSTS, CORS, etc.).
+Extracted from original config.py for better maintainability.
+
+Size: ~100 lines (focused on security)
+"""
+
+from typing import List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..base.config_model import DjangoConfig
+
+
+class SecurityBuilder:
+    """
+    Builds security-related settings from DjangoConfig.
+
+    Responsibilities:
+    - Generate ALLOWED_HOSTS from security_domains
+    - Add localhost/127.0.0.1 in development
+    - Prepare CORS settings
+    - Handle SSL redirect configuration
+
+    Example:
+        ```python
+        builder = SecurityBuilder(config)
+        allowed_hosts = builder.build_allowed_hosts()
+        ```
+    """
+
+    def __init__(self, config: "DjangoConfig"):
+        """
+        Initialize builder with configuration.
+
+        Args:
+            config: DjangoConfig instance
+        """
+        self.config = config
+
+    def build_allowed_hosts(self) -> List[str]:
+        """
+        Build ALLOWED_HOSTS from security_domains.
+
+        In development:
+        - Adds localhost, 127.0.0.1, [::1]
+        - Adds security_domains if provided
+
+        In production:
+        - Uses only security_domains
+        - Warning if security_domains is empty
+
+        Returns:
+            List of allowed host patterns
+
+        Example:
+            >>> config = DjangoConfig(
+            ...     env_mode=EnvironmentMode.PRODUCTION,
+            ...     security_domains=["example.com", "api.example.com"]
+            ... )
+            >>> builder = SecurityBuilder(config)
+            >>> hosts = builder.build_allowed_hosts()
+            >>> "example.com" in hosts
+            True
+        """
+        allowed_hosts = []
+
+        # Development mode: add localhost by default
+        if self.config.is_development:
+            allowed_hosts.extend([
+                "localhost",
+                "127.0.0.1",
+                "[::1]",  # IPv6 localhost
+            ])
+
+        # Add security domains (both dev and prod)
+        allowed_hosts.extend(self.config.security_domains)
+
+        # Production warning if no domains configured
+        if self.config.is_production and not self.config.security_domains:
+            import warnings
+            warnings.warn(
+                "No security_domains configured in production mode. "
+                "Add domains to security_domains field for proper security.",
+                UserWarning,
+                stacklevel=2,
+            )
+            # In production without domains, allow all (not recommended)
+            allowed_hosts = ["*"]
+
+        return allowed_hosts
+
+
+# Export builder
+__all__ = ["SecurityBuilder"]